OutOfMemoryException 클래스

정의

프로그램을 계속 실행하기 위한 메모리가 부족할 때 throw되는 예외입니다.The exception that is thrown when there is not enough memory to continue the execution of a program.

public ref class OutOfMemoryException : SystemException
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class OutOfMemoryException : SystemException
type OutOfMemoryException = class
    inherit SystemException
Public Class OutOfMemoryException
Inherits SystemException
상속
OutOfMemoryException
파생
특성

설명

OutOfMemoryException HRESULT를 사용 하 여 COR_E_OUTOFMEMORY, 0x8007000E 값입니다.OutOfMemoryException uses the HRESULT COR_E_OUTOFMEMORY, which has the value 0x8007000E.

인스턴스의 초기 속성 값의 목록을 OutOfMemoryException, 참조는 OutOfMemoryException 생성자입니다.For a list of initial property values for an instance of OutOfMemoryException, see the OutOfMemoryException constructors.

참고

상속 된 값 Data 속성은 항상 null합니다.The value of the inherited Data property is always null.

OutOfMemoryException 예외는 두 가지 주요 원인:An OutOfMemoryException exception has two major causes:

  • 확장 하려는 StringBuilder 정의한 길이 초과 하는 개체는 StringBuilder.MaxCapacity 속성입니다.You are attempting to expand a StringBuilder object beyond the length defined by its StringBuilder.MaxCapacity property.

  • 공용 언어 런타임에서 성공적으로 작업을 수행 하려면 충분 한 인접 한 메모리를 할당할 수 없습니다.The common language runtime cannot allocate enough contiguous memory to successfully perform an operation. 메모리를 할당 해야 하는 모든 속성 할당 또는 메서드 호출에서이 예외가 throw 될 수 있습니다.This exception can be thrown by any property assignment or method call that requires a memory allocation. OutOfMemoryException 예외의 원인에 대 한 자세한 내용은 블로그 게시물 "메모리 부족"이 실제 메모리를 참조 하지 않음을 참조 하세요.For more information on the cause of the OutOfMemoryException exception, see the blog post "Out of Memory" Does Not Refer to Physical Memory.

    이 유형의 OutOfMemoryException 예외는 치명적인 오류를 나타냅니다.This type of OutOfMemoryException exception represents a catastrophic failure. 예외를 처리 하려는 경우를 포함 해야는 catch 호출 하는 블록을 Environment.FailFast 앱을 종료 하 고 다음 예제와 같이 시스템 이벤트 로그에 항목을 추가 하는 메서드.If you choose to handle the exception, you should include a catch block that calls the Environment.FailFast method to terminate your app and add an entry to the system event log, as the following example does.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          try {
             // Outer block to handle any unexpected exceptions.
             try {
                string s = "This";
                s = s.Insert(2, "is ");
    
                // Throw an OutOfMemoryException exception.
                throw new OutOfMemoryException();
             }
             catch (ArgumentException) {
                Console.WriteLine("ArgumentException in String.Insert");
             }
    
             // Execute program logic.
          }
          catch (OutOfMemoryException e) {
             Console.WriteLine("Terminating application unexpectedly...");
             Environment.FailFast(String.Format("Out of Memory: {0}",
                                                e.Message));
          }
       }
    }
    // The example displays the following output:
    //        Terminating application unexpectedly...
    
    Module Example
       Public Sub Main()
          Try
             ' Outer block to handle any unexpected exceptions.
             Try
                Dim s As String = "This"
                s = s.Insert(2, "is ")
    
                ' Throw an OutOfMemoryException exception.
                Throw New OutOfMemoryException()
             Catch e As ArgumentException
                Console.WriteLine("ArgumentException in String.Insert")
             End Try
             
             ' Execute program logic.
    
          Catch e As OutOfMemoryException
             Console.WriteLine("Terminating application unexpectedly...")
             Environment.FailFast(String.Format("Out of Memory: {0}",
                                                e.Message))
          End Try
       End Sub
    End Module
    ' The example displays the following output:
    '       Terminating application unexpectedly...
    

일부 조건은는 예외가 throw 되 고 제거 하기 위해 수행할 수 있는 작업에는 다음과 같습니다.Some of the conditions under which the exception is thrown and the actions you can take to eliminate it include the following:

메서드를 StringBuilder.Insert 호출 하 고 있습니다.You are calling the StringBuilder.Insert method.

길이 늘립니다 하려는 StringBuilder 개체에서 지정 된 크기 보다 해당 StringBuilder.MaxCapacity 속성입니다.You are attempting to increase the length of a StringBuilder object beyond the size specified by its StringBuilder.MaxCapacity property. 다음 예제는 OutOfMemoryException 에 대 한 호출에서 throw 된 예외를 StringBuilder.Insert(Int32, String, Int32) 메서드는 예제는 개체의 문자열을 삽입 하려고 할 때 Length 최대 용량을 초과 하는 속성입니다.The following example illustrates the OutOfMemoryException exception thrown by a call to the StringBuilder.Insert(Int32, String, Int32) method when the example tries to insert a string that would cause the object's Length property to exceed its maximum capacity.

using System;
using System.Text;

public class Example
{
   public static void Main()
   {
      StringBuilder sb = new StringBuilder(15, 15);
      sb.Append("Substring #1 ");
      try {
         sb.Insert(0, "Substring #2 ", 1);
      }
      catch (OutOfMemoryException e) {
         Console.WriteLine("Out of Memory: {0}", e.Message);
      }
   }
}
// The example displays the following output:
//    Out of Memory: Insufficient memory to continue the execution of the program.
Imports System.Text

Module Example
   Public Sub Main()
      Dim sb As New StringBuilder(15, 15)
      sb.Append("Substring #1 ")
      Try
         sb.Insert(0, "Substring #2 ", 1)
      Catch e As OutOfMemoryException
         Console.WriteLine("Out of Memory: {0}", e.Message)
      End Try
   End Sub
End Module
' The example displays the following output:
'   Out of Memory: Insufficient memory to continue the execution of the program.

오류를 해결 하기 위해 다음 중 하나를 수행할 수 있습니다.You can do either of the following to address the error:

앱이 32 비트 프로세스로 실행 됩니다.Your app runs as a 32-bit process.

32 비트 프로세스는 최대 2GB의 32 비트 시스템에서는 사용자 모드 가상 메모리 및 4GB의 64 비트 시스템에서 사용자 모드 가상 메모리를 할당할 수 있습니다.32-bit processes can allocate a maximum of 2GB of virtual user-mode memory on 32-bit systems, and 4GB of virtual user-mode memory on 64-bit systems. 이 어려울 수 있습니다 보다 큰 할당을 필요할 때 충분 한 인접 한 메모리를 할당할 공용 언어 런타임에 대 한 합니다.This can make it more difficult for the common language runtime to allocate sufficient contiguous memory when a large allocation is needed. 반면, 64 비트 프로세스는 최대 8TB의 가상 메모리를 할당할 수 있습니다.In contrast, 64-bit processes can allocate up to 8TB of virtual memory. 이 예외를 해결 하기 위해 64 비트 플랫폼을 대상으로 앱을 다시 컴파일하십시오.To address this exception, recompile your app to target a 64-bit platform. Visual Studio의 특정 플랫폼을 대상으로 지정 하는 방법에 대 한 자세한 내용은 방법: 플랫폼을 대상으로 한 프로젝트 구성을 참조하세요.For information on targeting specific platforms in Visual Studio, see How to: Configure Projects to Target Platforms.

앱이 관리 되지 않는 리소스를 누수 하 고 있습니다.Your app is leaking unmanaged resources

가비지 수집기가 관리 되는 형식에 할당 된 메모리를 해제할 수 있지만,이 관리 하지 않는 운영 체제 파일, 메모리 매핑된 파일, 파이프, 레지스트리 키 및 대기 핸들에 대 한 핸들 등 처리와 같은 관리 되지 않는 리소스에 할당 된 메모리 와 같은 Windows API 호출에 의해 직접 또는 메모리 할당 함수를 호출 하 여 할당 된 메모리 블록 malloc합니다.Although the garbage collector is able to free memory allocated to managed types, it does not manage memory allocated to unmanaged resources such as operating system handles (including handles to files, memory-mapped files, pipes, registry keys, and wait handles) and memory blocks allocated directly by Windows API calls or by calls to memory allocation functions such as malloc. 관리 되지 않는 리소스를 소비 하는 형식은 구현 된 IDisposable 인터페이스입니다.Types that consume unmanaged resources implement the IDisposable interface.

관리 되지 않는 리소스를 사용 하는 형식을 사용 하는 경우에 호출 해야 해야 해당 IDisposable.Dispose 메서드를 사용 하는 것이 했으면 합니다.If you are consuming a type that uses unmanaged resources, you should be sure to call its IDisposable.Dispose method when you have finished using it. (일부 형식은 또한 구현 하는 Close 메서드입니다 기능상에서 동일를 Dispose 메서드.) 자세한 내용은 참조는 를 사용 하 여 개체는 구현 IDisposable 항목입니다.(Some types also implement a Close method that is identical in function to a Dispose method.) For more information, see the Using Objects That Implement IDisposable topic.

관리 되지 않는 리소스를 사용 하는 형식을 만든 경우 Dispose 패턴을 구현 했으며, 필요한 경우 종료자를 제공 하는지 확인 합니다.If you have created a type that uses unmanaged resources, make sure that you have implemented the Dispose pattern and, if necessary, supplied a finalizer. 자세한 내용은 Dispose 메서드 구현Object.Finalize을 참조 하세요.For more information, see Implementing a Dispose method and Object.Finalize.

64 비트 프로세스에서 많은 배열을 만들려고 합니다.You are attempting to create a large array in a 64-bit process

기본적으로 .NET Framework의 공용 언어 런타임에서는 크기가 2GB를 초과 하는 단일 개체를 허용 하지 않습니다.By default, the common language runtime in .NET Framework does not allow single objects whose size exceeds 2GB. 이 기본값을 재정의 하려면 <gcallowverylargeobjects> > 구성 파일 설정을 사용 하 여 총 크기가 2gb를 초과 하는 배열을 사용 하도록 설정할 수 있습니다.To override this default, you can use the <gcAllowVeryLargeObjects> configuration file setting to enable arrays whose total size exceeds 2 GB. .NET Core에서 2gb 보다 큰 배열에 대 한 지원은 기본적으로 사용 하도록 설정 되어 있습니다.On .NET Core, support for arrays of greater than 2 GB is enabled by default.

메모리에서 매우 큰 데이터 집합 (예: 배열, 컬렉션 또는 데이터베이스 데이터 집합)으로 작업 하 고 있습니다.You are working with very large sets of data (such as arrays, collections, or database data sets) in memory.

데이터 구조 또는 메모리에 상주 하는 데이터 집합이 너무 커져 공용 언어 런타임, 충분 한 인접 한 메모리를 할당할 수 없는 경우는 OutOfMemoryException 예외가 발생 합니다.When data structures or data sets that reside in memory become so large that the common language runtime is unable to allocate enough contiguous memory for them, an OutOfMemoryException exception results.

방지 하기 위해는 OutOfMemoryException 예외 적은 데이터를 메모리에 상주 하거나 데이터 구분 되어 세그먼트로 작은 메모리 할당을 필요로 하는 애플리케이션을 수정 해야 합니다.To prevent the OutOfMemoryException exceptions, you must modify your application so that less data is resident in memory, or the data is divided into segments that require smaller memory allocations. 예:For example:

  • 데이터베이스에서 모든 데이터를 검색 하 고 다음 서버에 왕복을 최소화 하기 위해 앱에서 필터링 하는 경우 앱에 필요한 데이터의 하위 집합만 반환 하도록 쿼리를 수정 해야 합니다.If you are retrieving all of the data from a database and then filtering it in your app to minimize trips to the server, you should modify your queries to return only the subset of data that your app needs. 대형 테이블에서 작업할 때는 여러 쿼리는 거의 항상 더 단일 테이블에 데이터를 검색 하 고 조작 하는 것 보다 효율적입니다.When working with large tables, multiple queries are almost always more efficient than retrieving all of the data in a single table and then manipulating it.

  • 사용자가 동적으로 만든 쿼리를 실행 하는 경우 쿼리에서 반환 된 레코드 수가 제한 된다는 확인 해야 합니다.If you are executing queries that users create dynamically, you should ensure that the number of records returned by the query is limited.

  • 대형 배열을 사용 하는 경우 또는 다른 컬렉션의 크기가 결과 개체는 OutOfMemoryException 예외를 한 번에 모두 사용 하기 보다는 데이터 하위 집합에서 작동 하도록 애플리케이션을 수정 해야 합니다.If you are using large arrays or other collection objects whose size results in an OutOfMemoryException exception, you should modify your application to work the data in subsets rather than to work with it all at once.

다음 예제에서는 200 백만 부동 소수점 값으로 구성 됩니다 한 후 평균을 계산 하는 배열을 가져옵니다.The following example gets a array that consists of 200 million floating-point values and then calculates their mean. 예제의 출력은 평균 OutOfMemoryException 을 계산 하기 전에 전체 배열을 메모리에 저장 하므로이 throw 됨을 보여 줍니다.The output from the example shows that, because the example stores the entire array in memory before it calculates the mean, an OutOfMemoryException is thrown.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      Double[] values = GetData();
      // Compute mean.
      Console.WriteLine("Sample mean: {0}, N = {1}",
                        GetMean(values), values.Length);
   }

   private static Double[] GetData()
   {
      Random rnd = new Random();
      List<Double> values = new List<Double>();
      for (int ctr = 1; ctr <= 200000000; ctr++) {
         values.Add(rnd.NextDouble());
         if (ctr % 10000000 == 0)
            Console.WriteLine("Retrieved {0:N0} items of data.",
                              ctr);
      }
      return values.ToArray();
   }

   private static Double GetMean(Double[] values)
   {
      Double sum = 0;
      foreach (var value in values)
         sum += value;

      return sum / values.Length;
   }
}
// The example displays output like the following:
//    Retrieved 10,000,000 items of data.
//    Retrieved 20,000,000 items of data.
//    Retrieved 30,000,000 items of data.
//    Retrieved 40,000,000 items of data.
//    Retrieved 50,000,000 items of data.
//    Retrieved 60,000,000 items of data.
//    Retrieved 70,000,000 items of data.
//    Retrieved 80,000,000 items of data.
//    Retrieved 90,000,000 items of data.
//    Retrieved 100,000,000 items of data.
//    Retrieved 110,000,000 items of data.
//    Retrieved 120,000,000 items of data.
//    Retrieved 130,000,000 items of data.
//
//    Unhandled Exception: OutOfMemoryException.
Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim values() As Double = GetData()
      ' Compute mean.
      Console.WriteLine("Sample mean: {0}, N = {1}",
                        GetMean(values), values.Length)
   End Sub
   
   Private Function GetData() As Double()
      Dim rnd As New Random()
      Dim values As New List(Of Double)()
      For ctr As Integer = 1 To 200000000
         values.Add(rnd.NextDouble)
         If ctr Mod 10000000 = 0 Then
            Console.WriteLine("Retrieved {0:N0} items of data.",
                              ctr)
         End If
      Next
      Return values.ToArray()
   End Function
   
   Private Function GetMean(values() As Double) As Double
      Dim sum As Double = 0
      For Each value In values
         sum += value
      Next
      Return sum / values.Length
   End Function
End Module
' The example displays output like the following:
'    Retrieved 10,000,000 items of data.
'    Retrieved 20,000,000 items of data.
'    Retrieved 30,000,000 items of data.
'    Retrieved 40,000,000 items of data.
'    Retrieved 50,000,000 items of data.
'    Retrieved 60,000,000 items of data.
'    Retrieved 70,000,000 items of data.
'    Retrieved 80,000,000 items of data.
'    Retrieved 90,000,000 items of data.
'    Retrieved 100,000,000 items of data.
'    Retrieved 110,000,000 items of data.
'    Retrieved 120,000,000 items of data.
'    Retrieved 130,000,000 items of data.
'
'    Unhandled Exception: OutOfMemoryException.

다음 예제에서는 제거 된 OutOfMemoryException (이러한 줄은 주석 처리 된 예제에서는 추가 처리를 허용 하는 데 필요한 경우 파일에 데이터를 직렬화 하는 메모리에 전체 데이터 집합을 저장 하지 않고 들어오는 데이터를 처리 하 여 예외 하므로 여기서 생성 크기가 1GB 보다 큽니다. 파일)를 호출 하는 루틴 계산 된 평균 및 사례 수를 반환 합니다.The following example eliminates the OutOfMemoryException exception by processing the incoming data without storing the entire data set in memory, serializing the data to a file if necessary to permit further processing (these lines are commented out in the example, since in this case they produce a file whose size is greater than 1GB), and returning the calculated mean and the number of cases to the calling routine.

using System;
using System.IO;

public class Example
{
   public static void Main()
   {
      Tuple<Double, long> result = GetResult();
      Console.WriteLine("Sample mean: {0}, N = {1:N0}",
                        result.Item1, result.Item2);
   }

   private static Tuple<Double, long> GetResult()
   {
      int chunkSize = 50000000;
      int nToGet = 200000000;
      Random rnd = new Random();
      // FileStream fs = new FileStream(@".\data.bin", FileMode.Create);
      // BinaryWriter bin = new BinaryWriter(fs);
      // bin.Write((int)0);
      int n = 0;
      Double sum = 0;
      for (int outer = 0;
           outer <= ((int) Math.Ceiling(nToGet * 1.0 / chunkSize) - 1);
           outer++) {
         for (int inner = 0;
              inner <= Math.Min(nToGet - n - 1, chunkSize - 1);
              inner++) {
            Double value = rnd.NextDouble();
            sum += value;
            n++;
            // bin.Write(value);
         }
      }
      // bin.Seek(0, SeekOrigin.Begin);
      // bin.Write(n);
      // bin.Close();
      return new Tuple<Double, long>(sum/n, n);
   }
}
// The example displays output like the following:
//    Sample mean: 0.500022771458399, N = 200,000,000
Imports System.IO

Module Example
   Public Sub Main()
      Dim result As Tuple(Of Double, Long) = GetResult()
      Console.WriteLine("Sample mean: {0}, N = {1:N0}",
                        result.Item1, result.Item2)
   End Sub

   Private Function GetResult As Tuple(Of Double, Long)
      Dim chunkSize As Integer = 50000000
      Dim nToGet As Integer = 200000000
      Dim rnd As New Random()
'       Dim fs As New FileStream(".\data.bin", FileMode.Create)
'       Dim bin As New BinaryWriter(fs)
'       bin.Write(CInt(0))
      Dim n As Integer
      Dim sum As Double
      For outer As Integer = 0 To CInt(Math.Ceiling(nToGet/chunkSize) - 1)
         For inner = 0 To Math.Min(nToGet - n - 1, chunkSize - 1)
            Dim value As Double = rnd.NextDouble()
            sum += value
            n += 1
'            bin.Write(value)
         Next
      Next
'       bin.Seek(0, SeekOrigin.Begin)
'       bin.Write(n)
'       bin.Close()
      Return New Tuple(Of Double, Long)(sum/n, n)
   End Function
End Module
' The example displays output like the following:
'   Sample mean: 0.500022771458399, N = 200,000,000

매우 많은 문자열을 반복적으로 연결 하 고 있습니다.You are repeatedly concatenating large strings.

문자열을 변경할 수 없기 때문에 각 문자열 연결 작업에는 새 문자열을 만듭니다.Because strings are immutable, each string concatenation operation creates a new string. 작은 문자열 또는 소수의 연결 작업에 주는 영향은 매우 적습니다.The impact for small strings, or for a small number of concatenation operations, is negligible. 큰 문자열 또는 연결 작업 수가 매우 많은 경우 문자열 연결 수가 많은 메모리 할당 및 메모리 조각화로 성능 저하를 발생할 수 있습니다 하지만 및 OutOfMemoryException 예외입니다.But for large strings or a very large number of concatenation operations, string concatenation can lead to a large number of memory allocations and memory fragmentation, poor performance, and possibly OutOfMemoryException exceptions.

큰 문자열 연결 또는 다 수의 연결 작업을 수행 해야 사용 하는 경우는 StringBuilder 대신 클래스는 String 클래스입니다.When concatenating large strings or performing a large number of concatenation operations, you should use the StringBuilder class instead of the String class. 완료 한 후 문자열을 조작 하는 경우 변환 된 StringBuilder 인스턴스를 호출 하 여 문자열로 StringBuilder.ToString 메서드.When you have finished manipulating the string, convert the StringBuilder instance to a string by calling the StringBuilder.ToString method.

많은 수의 개체를 메모리에 고정 합니다.You pin a large number of objects in memory.

오랫동안 메모리에 다 수의 개체를 고정 어려울 수 있습니다 연속 메모리 블록을 할당할 가비지 수집기에 대 한 합니다.Pinning a large number of objects in memory for long periods can make it difficult for the garbage collector to allocate contiguous blocks of memory. 한 고정 한 경우 많은 수의 개체를 메모리에 예를 들어 사용 하 여는 fixed C#의 문이나 호출 하 여는 GCHandle.Alloc(Object, GCHandleType) 핸들 형식의 메서드 GCHandleType.Pinned, 주소로 다음을 수행할 수는 OutOfMemoryException 예외.If you've pinned a large number of objects in memory, for example by using the fixed statement in C# or by calling the GCHandle.Alloc(Object, GCHandleType) method with a handle type of GCHandleType.Pinned, you can do the following to address the OutOfMemoryException exception.

  • 각 개체는 실제로 고정할 수 해야 하는지 여부를 평가합니다Evaluate whether each object really needs to be pinned,

  • 각 개체 아님을 고정 가능한 한 빨리 확인 합니다.Ensure that each object is unpinned as soon as possible.

  • 호출할 때마다 있는지 확인 합니다 GCHandle.Alloc(Object, GCHandleType) pin 메모리 메서드가 해당 호출을 GCHandle.Free 해당 메모리를 고정 해제 하는 방법입니다.Make sure that each call to the GCHandle.Alloc(Object, GCHandleType) method to pin memory has a corresponding call to the GCHandle.Free method to unpin that memory.

중간 (MSIL) 명령은 throw 다음 Microsoft는 OutOfMemoryException 예외:The following Microsoft intermediate (MSIL) instructions throw an OutOfMemoryException exception:

생성자

OutOfMemoryException()

OutOfMemoryException 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the OutOfMemoryException class.

OutOfMemoryException(SerializationInfo, StreamingContext)

serialize된 데이터를 사용하여 OutOfMemoryException 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the OutOfMemoryException class with serialized data.

OutOfMemoryException(String)

지정된 오류 메시지를 사용하여 OutOfMemoryException 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the OutOfMemoryException class with a specified error message.

OutOfMemoryException(String, Exception)

지정된 오류 메시지와 해당 예외의 원인인 내부 예외에 대한 참조를 사용하여 OutOfMemoryException 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the OutOfMemoryException class with a specified error message and a reference to the inner exception that is the cause of this exception.

속성

Data

예외에 대한 사용자 정의 추가 정보를 제공하는 키/값 쌍의 컬렉션을 가져옵니다.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(다음에서 상속됨 Exception)
HelpLink

이 예외와 연결된 도움말 파일에 대한 링크를 가져오거나 설정합니다.Gets or sets a link to the help file associated with this exception.

(다음에서 상속됨 Exception)
HResult

특정 예외에 할당된 코드화된 숫자 값인 HRESULT를 가져오거나 설정합니다.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(다음에서 상속됨 Exception)
InnerException

현재 예외를 발생시킨 Exception 인스턴스를 가져옵니다.Gets the Exception instance that caused the current exception.

(다음에서 상속됨 Exception)
Message

현재 예외를 설명하는 메시지를 가져옵니다.Gets a message that describes the current exception.

(다음에서 상속됨 Exception)
Source

오류를 발생시키는 애플리케이션 또는 개체의 이름을 가져오거나 설정합니다.Gets or sets the name of the application or the object that causes the error.

(다음에서 상속됨 Exception)
StackTrace

호출 스택의 직접 실행 프레임에 대한 문자열 표현을 가져옵니다.Gets a string representation of the immediate frames on the call stack.

(다음에서 상속됨 Exception)
TargetSite

현재 예외를 throw하는 메서드를 가져옵니다.Gets the method that throws the current exception.

(다음에서 상속됨 Exception)

메서드

Equals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
GetBaseException()

파생 클래스에서 재정의되었을 때, 하나 이상의 후속 예외의 근본 원인이 되는 Exception을 반환합니다.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(다음에서 상속됨 Exception)
GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetObjectData(SerializationInfo, StreamingContext)

파생 클래스에서 재정의될 때, 예외에 관한 정보를 SerializationInfo에 설정합니다.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(다음에서 상속됨 Exception)
GetType()

현재 인스턴스의 런타임 형식을 가져옵니다.Gets the runtime type of the current instance.

(다음에서 상속됨 Exception)
MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
ToString()

현재 예외에 대한 문자열 표현을 만들고 반환합니다.Creates and returns a string representation of the current exception.

(다음에서 상속됨 Exception)

이벤트

SerializeObjectState

예외에 대한 serialize된 데이터가 들어 있는 예외 상태 개체가 만들어지도록 예외가 serialize될 때 발생합니다.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(다음에서 상속됨 Exception)

적용 대상

추가 정보