OutOfMemoryException Klasa

Definicja

Wyjątek, który jest generowany, gdy nie ma wystarczającej ilości pamięci, aby kontynuować wykonywanie programu.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
Dziedziczenie
OutOfMemoryException
Pochodne
Atrybuty

Uwagi

OutOfMemoryExceptionużywa HRESULT COR_E_OUTOFMEMORY, która ma wartość 0x8007000E.OutOfMemoryException uses the HRESULT COR_E_OUTOFMEMORY, which has the value 0x8007000E.

Aby uzyskać listę początkowe wartości właściwości wystąpienia OutOfMemoryException, zobacz OutOfMemoryException konstruktorów.For a list of initial property values for an instance of OutOfMemoryException, see the OutOfMemoryException constructors.

Uwaga

Wartość dziedziczonej Data właściwości jest zawsze null.The value of the inherited Data property is always null.

OutOfMemoryException Wyjątek ma dwie główne przyczyny:An OutOfMemoryException exception has two major causes:

  • Próbujesz rozszerzyć StringBuilder obiekt poza długość zdefiniowaną przez jego StringBuilder.MaxCapacity właściwość.You are attempting to expand a StringBuilder object beyond the length defined by its StringBuilder.MaxCapacity property.

  • Środowisko uruchomieniowe języka wspólnego nie może przydzielić wystarczającej ilości ciągłej pamięci, aby pomyślnie wykonać operację.The common language runtime cannot allocate enough contiguous memory to successfully perform an operation. Ten wyjątek może być zgłaszany przez przypisanie właściwości lub wywołanie metody wymagające alokacji pamięci.This exception can be thrown by any property assignment or method call that requires a memory allocation. Aby uzyskać więcej informacji na temat przyczyny OutOfMemoryException wyjątku, zobacz wpis w blogu "Brak pamięci" nie odwołuje się do pamięci fizycznej.For more information on the cause of the OutOfMemoryException exception, see the blog post "Out of Memory" Does Not Refer to Physical Memory.

    Ten typ OutOfMemoryException wyjątku reprezentuje błąd krytyczny.This type of OutOfMemoryException exception represents a catastrophic failure. W przypadku wybrania obsługi wyjątku należy uwzględnić catch blok, który Environment.FailFast wywołuje metodę, aby zakończyć działanie aplikacji, i dodać wpis do dziennika zdarzeń systemu, jak pokazano w poniższym przykładzie.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...
    

Niektóre warunki, w których wyjątek jest zgłaszany, oraz akcje, które można wykonać, aby wyeliminować, obejmują następujące elementy:Some of the conditions under which the exception is thrown and the actions you can take to eliminate it include the following:

Wywoływana StringBuilder.Insert jest metoda.You are calling the StringBuilder.Insert method.

Próbujesz zwiększyć długość StringBuilder obiektu poza rozmiarem określonym przez jego StringBuilder.MaxCapacity właściwość.You are attempting to increase the length of a StringBuilder object beyond the size specified by its StringBuilder.MaxCapacity property. Poniższy przykład ilustruje OutOfMemoryException wyjątek zgłoszony przez wywołanie metody, StringBuilder.Insert(Int32, String, Int32) gdy przykład próbuje wstawić ciąg, który Length spowodowałoby przekroczenie maksymalnej pojemności właściwości obiektu.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.

Aby rozwiązać ten problem, można wykonać jedną z następujących czynności:You can do either of the following to address the error:

Aplikacja działa jako proces 32-bitowy.Your app runs as a 32-bit process.

32-bitowe procesy mogą przydzielić maksymalnie 2 GB pamięci wirtualnego trybu użytkownika w systemach 32-bitowych i 4 GB wirtualnej pamięci w trybie użytkownika w systemach 64-bitowych.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. Może to utrudnić, aby środowisko uruchomieniowe języka wspólnego przydzielić wystarczającą ilość pamięci ciągłej, gdy jest wymagana duża alokacja.This can make it more difficult for the common language runtime to allocate sufficient contiguous memory when a large allocation is needed. Z kolei procesy 64-bitowe mogą przydzielić maksymalnie 8TB pamięci wirtualnej.In contrast, 64-bit processes can allocate up to 8TB of virtual memory. Aby rozwiązać ten wyjątek, Skompiluj ponownie aplikację pod kątem platformy 64-bitowej.To address this exception, recompile your app to target a 64-bit platform. Aby uzyskać informacje na temat określania konkretnych platform w programie Visual Studio, zobacz How to: Skonfiguruj projekty na platformachdocelowych.For information on targeting specific platforms in Visual Studio, see How to: Configure Projects to Target Platforms.

Twoja aplikacja wycieka niezarządzane zasobyYour app is leaking unmanaged resources

Mimo że moduł wyrzucania elementów bezużytecznych może zwolnić pamięć przydzieloną do typów zarządzanych, nie zarządza pamięcią przydzieloną do zasobów niezarządzanych, takich jak uchwyty systemu operacyjnego (w tym dojścia do plików, pliki mapowane w pamięci, potoki, klucze rejestru i dojścia oczekiwania) bloki pamięci przydzielone bezpośrednio przez wywołania interfejsu API systemu Windows lub wywołania funkcji alokacji pamięci, takich mallocjak.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. Typy korzystające z IDisposable zasobów niezarządzanych implementują interfejs.Types that consume unmanaged resources implement the IDisposable interface.

W przypadku korzystania z typu, który korzysta z zasobów niezarządzanych, należy pamiętać, aby wywołać IDisposable.Dispose metodę, gdy zostanie ona ukończona.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. (Niektóre typy również implementują Close metodę, która jest identyczna w funkcji Dispose dla metody). Aby uzyskać więcej informacji, zobacz temat Używanie obiektów, które implementują interfejs 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.

Jeśli utworzono typ, który korzysta z zasobów niezarządzanych, upewnij się, że został zaimplementowany wzorzec usuwania i, w razie potrzeby, dostarczony finalizator.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. Aby uzyskać więcej informacji, zobacz implementowanie metody Dispose i Object.Finalize.For more information, see Implementing a Dispose method and Object.Finalize.

Podjęto próbę utworzenia dużej macierzy w procesie 64-bitowymYou are attempting to create a large array in a 64-bit process

Domyślnie środowisko uruchomieniowe języka wspólnego w .NET Framework nie zezwala na użycie pojedynczych obiektów, których rozmiar przekracza 2 GB.By default, the common language runtime in .NET Framework does not allow single objects whose size exceeds 2GB. Aby zastąpić to ustawienie domyślne, można użyć <ustawienia gcAllowVeryLargeObjects > pliku konfiguracji, aby włączyć tablice, których rozmiar całkowity przekracza 2 GB.To override this default, you can use the <gcAllowVeryLargeObjects> configuration file setting to enable arrays whose total size exceeds 2 GB. W przypadku platformy .NET Core obsługa tablic o wartości większej niż 2 GB jest domyślnie włączona.On .NET Core, support for arrays of greater than 2 GB is enabled by default.

Pracujesz z bardzo dużymi zestawami danych (takimi jak tablice, kolekcje lub zestawy danych bazy danych) w pamięci.You are working with very large sets of data (such as arrays, collections, or database data sets) in memory.

Gdy struktury danych lub zestawy danych, które znajdują się w pamięci, stają się duże, że środowisko uruchomieniowe języka wspólnego nie jest w stanie przydzielić OutOfMemoryException wystarczającej ilości pamięci ciągłej dla nich, zostanie użyty wyjątek.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.

Aby zapobiec OutOfMemoryException wyjątkom, należy zmodyfikować aplikację tak, aby mniejsza ilość danych była rezydentem pamięci, lub dane są dzielone na segmenty, które wymagają mniejszych alokacji pamięci.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. Na przykład:For example:

  • Jeśli pobierasz wszystkie dane z bazy danych, a następnie przefiltrusz ją w aplikacji, aby zminimalizować podróże do serwera, należy zmodyfikować zapytania, aby zwracały tylko podzbiór danych, których potrzebuje aplikacja.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. Podczas pracy z dużymi tabelami wiele zapytań jest prawie zawsze bardziej wydajne niż pobieranie wszystkich danych w pojedynczej tabeli, a następnie manipulowanie nimi.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.

  • W przypadku wykonywania zapytań, które użytkownicy tworzą dynamicznie, należy upewnić się, że liczba rekordów zwracanych przez zapytanie jest ograniczona.If you are executing queries that users create dynamically, you should ensure that the number of records returned by the query is limited.

  • Jeśli używasz dużych tablic lub innych obiektów kolekcji, których rozmiar powoduje OutOfMemoryException wyjątek, należy zmodyfikować aplikację tak, aby działała w podzestawach, a nie do pracy z nią wszystkie jednocześnie.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.

Poniższy przykład pobiera tablicę, która składa się z 200 000 000 wartości zmiennoprzecinkowych, a następnie oblicza ich średnią.The following example gets a array that consists of 200 million floating-point values and then calculates their mean. Dane wyjściowe z przykładu pokazują, że ponieważ przykład zapisuje całą tablicę w pamięci przed obliczeniem średniej, OutOfMemoryException zostanie zgłoszony.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.

Poniższy przykład eliminuje OutOfMemoryException wyjątek poprzez przetwarzanie danych przychodzących bez przechowywania całego zestawu danych w pamięci, serializacji danych do pliku, jeśli jest to konieczne, aby zezwolić na dalsze przetwarzanie (te wiersze są w tym przykładzie komentarzem, ponieważ w tym przypadku tworzy plik, którego rozmiar jest większy niż 1 GB, i zwraca obliczoną wartość średnią oraz liczbę przypadków do procedury wywołującej.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

Często łączmy duże ciągi.You are repeatedly concatenating large strings.

Ponieważ ciągi są niezmienne, każda operacja łączenia ciągów tworzy nowy ciąg.Because strings are immutable, each string concatenation operation creates a new string. Wpływ małych ciągów lub niewielkiej liczby operacji łączenia jest nieznaczny.The impact for small strings, or for a small number of concatenation operations, is negligible. Jednak w przypadku dużych ciągów lub bardzo dużej liczby operacji łączenia ciąg łączenia może prowadzić do dużej liczby alokacji pamięci i fragmentacji pamięci, słabej wydajności i ewentualnych OutOfMemoryException wyjątków.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.

Podczas łączenia dużych ciągów lub wykonywania dużej liczby operacji łączenia należy użyć StringBuilder klasy zamiast String klasy.When concatenating large strings or performing a large number of concatenation operations, you should use the StringBuilder class instead of the String class. Po zakończeniu manipulowania ciągiem, należy przekonwertować StringBuilder wystąpienie na ciąg, StringBuilder.ToString wywołując metodę.When you have finished manipulating the string, convert the StringBuilder instance to a string by calling the StringBuilder.ToString method.

Przypinanie dużej liczby obiektów w pamięci.You pin a large number of objects in memory.

Przypinanie dużej liczby obiektów w pamięci przez długie okresy może utrudnić wyrzucanie elementów bezużytecznych w celu przydzielenia ciągłych bloków pamięci.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. Jeśli przypięto dużą liczbę obiektów w pamięci, fixed na przykład przy użyciu instrukcji w C# GCHandle.Alloc(Object, GCHandleType) lub przez wywołanie metody z typem GCHandleType.Pinneddojścia, można wykonać następujące czynności, aby rozwiązać OutOfMemoryException wyjątek.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.

  • Oceń, czy każdy obiekt naprawdę musi być przypięty,Evaluate whether each object really needs to be pinned,

  • Upewnij się, że każdy obiekt nie jest przypięty tak szybko, jak to możliwe.Ensure that each object is unpinned as soon as possible.

  • Upewnij się, że każde wywołanie GCHandle.Alloc(Object, GCHandleType) metody do przypięcia pamięci ma odpowiednie wywołanie GCHandle.Free metody w celu odpinania tej pamięci.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.

Następujące instrukcje OutOfMemoryException pośrednika firmy Microsoft (MSIL) zgłaszają wyjątek:The following Microsoft intermediate (MSIL) instructions throw an OutOfMemoryException exception:

Konstruktory

OutOfMemoryException()

Inicjuje nowe wystąpienie klasy OutOfMemoryException klasy.Initializes a new instance of the OutOfMemoryException class.

OutOfMemoryException(SerializationInfo, StreamingContext)

Inicjuje nowe wystąpienie klasy OutOfMemoryException klasy z serializowanych danych.Initializes a new instance of the OutOfMemoryException class with serialized data.

OutOfMemoryException(String)

Inicjuje nowe wystąpienie klasy OutOfMemoryException klasy przy użyciu określonego komunikatu o błędzie.Initializes a new instance of the OutOfMemoryException class with a specified error message.

OutOfMemoryException(String, Exception)

Inicjuje nowe wystąpienie klasy OutOfMemoryException klasy przy użyciu określonego komunikatu o błędzie i odwołania do wewnętrznego wyjątku, który jest przyczyną tego wyjątku.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.

Właściwości

Data

Pobiera kolekcję par klucz/wartość, które zawierają dodatkowe informacje zdefiniowane przez użytkownika dotyczące wyjątku.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Odziedziczone po Exception)
HelpLink

Pobiera lub ustawia link do pliku pomocy skojarzonego z tym wyjątkiem.Gets or sets a link to the help file associated with this exception.

(Odziedziczone po Exception)
HResult

Pobiera lub ustawia wartość HRESULT, kodowane wartości liczbowe przypisane do określonego wyjątku.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Odziedziczone po Exception)
InnerException

Pobiera wystąpienie Exception, które spowodowało wyjątek bieżący.Gets the Exception instance that caused the current exception.

(Odziedziczone po Exception)
Message

Pobiera komunikat, który opisuje bieżący wyjątek.Gets a message that describes the current exception.

(Odziedziczone po Exception)
Source

Pobiera lub ustawia nazwę aplikacji lub obiekt, który powoduje błąd.Gets or sets the name of the application or the object that causes the error.

(Odziedziczone po Exception)
StackTrace

Pobiera ciąg reprezentujący bezpośrednie ramki w stosie wywołań.Gets a string representation of the immediate frames on the call stack.

(Odziedziczone po Exception)
TargetSite

Pobiera metodę, która zgłasza bieżący wyjątek.Gets the method that throws the current exception.

(Odziedziczone po Exception)

Metody

Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetBaseException()

Gdy jest zastępowany w klasie pochodnej, zwraca Exception, który jest główną przyczyną jednego lub kilku kolejnych wyjątków.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Odziedziczone po Exception)
GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetObjectData(SerializationInfo, StreamingContext)

Gdy jest zastępowany w klasie pochodnej, ustawia SerializationInfo z informacjami o wyjątku.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Odziedziczone po Exception)
GetType()

Pobiera typ środowiska uruchomieniowego bieżącego wystąpienia.Gets the runtime type of the current instance.

(Odziedziczone po Exception)
MemberwiseClone()

Tworzy skróconą kopię bieżącego Object.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
ToString()

Tworzy i zwraca reprezentację ciągu bieżącego wyjątku.Creates and returns a string representation of the current exception.

(Odziedziczone po Exception)

Zdarzenia

SerializeObjectState

Występuje, gdy wyjątek jest serializowany w celu utworzenia obiektu stanu wyjątku, który zawiera serializowane dane dotyczące wyjątku.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Odziedziczone po Exception)

Dotyczy

Zobacz też