Freigeben über

OutOfMemoryException Klasse

  • Referenz

Definition

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll
Quelle:
OutOfMemoryException.cs
Quelle:
OutOfMemoryException.cs
Quelle:
OutOfMemoryException.cs

Die Ausnahme, die ausgelöst wird, wenn für die weitere Ausführung eines Programms nicht genügend Arbeitsspeicher zur Verfügung steht.

public ref class OutOfMemoryException : Exception
public ref class OutOfMemoryException : SystemException
public class OutOfMemoryException : Exception
public class OutOfMemoryException : SystemException
[System.Serializable]
public class OutOfMemoryException : SystemException
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class OutOfMemoryException : SystemException
type OutOfMemoryException = class
    inherit Exception
type OutOfMemoryException = class
    inherit SystemException
[<System.Serializable>]
type OutOfMemoryException = class
    inherit SystemException
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type OutOfMemoryException = class
    inherit SystemException
Public Class OutOfMemoryException
Inherits Exception
Public Class OutOfMemoryException
Inherits SystemException
Vererbung
Object
Exception
OutOfMemoryException
Vererbung
Object
Exception
SystemException
OutOfMemoryException
Abgeleitet
Attribute
SerializableAttribute ComVisibleAttribute

Hinweise

OutOfMemoryException verwendet HRESULT COR_E_OUTOFMEMORY, das den Wert 0x8007000E hat.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von OutOfMemoryException, finden Sie unter den OutOfMemoryException Konstruktoren.

Hinweis

Der Wert der geerbten Data Eigenschaft ist immer null.

Eine OutOfMemoryException Ausnahme hat zwei Hauptgründe:

  • Sie versuchen, ein StringBuilder Objekt über die durch die StringBuilder.MaxCapacity -Eigenschaft definierte Länge hinaus zu erweitern.

  • Die Common Language Runtime kann nicht genügend zusammenhängenden Arbeitsspeicher zuweisen, um einen Vorgang erfolgreich auszuführen. Diese Ausnahme kann durch jeden Eigenschaftszuweisungs- oder Methodenaufruf ausgelöst werden, der eine Speicherbelegung erfordert. Weitere Informationen zur Ursache der OutOfMemoryException Ausnahme finden Sie im Blogbeitrag "Nicht genügend Arbeitsspeicher" verweist nicht auf physischen Arbeitsspeicher.

    Dieser Ausnahmetyp OutOfMemoryException stellt einen schwerwiegenden Fehler dar. Wenn Sie sich für die Behandlung der Ausnahme entscheiden, sollten Sie einen catch Block einschließen, der die Environment.FailFast -Methode aufruft, um Ihre App zu beenden, und wie im folgenden Beispiel einen Eintrag zum Systemereignisprotokoll hinzufügen.

    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...

    open System

try
    // Outer block to handle any unexpected exceptions.
    try
        let s = "This"
        let s = s.Insert(2, "is ")

        // Throw an OutOfMemoryException exception.
        raise (OutOfMemoryException())
    with
    | :? ArgumentException ->
        printfn "ArgumentException in String.Insert"

    // Execute program logic.
with :? OutOfMemoryException as e ->
    printfn "Terminating application unexpectedly..."
    Environment.FailFast $"Out of Memory: {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...

Zu den Bedingungen, unter denen die Ausnahme ausgelöst wird, und die Aktionen, die Sie ergreifen können, um sie zu beseitigen, gehören die folgenden:

Sie rufen die StringBuilder.Insert -Methode auf.

Sie versuchen, die Länge eines StringBuilder Objekts über die durch StringBuilder.MaxCapacity die -Eigenschaft angegebene Größe hinaus zu erhöhen. Das folgende Beispiel veranschaulicht die Ausnahme, die OutOfMemoryException durch einen Aufruf der StringBuilder.Insert(Int32, String, Int32) -Methode ausgelöst wird, wenn im Beispiel versucht wird, eine Zeichenfolge einzufügen, die dazu führen würde, dass die Eigenschaft des Length Objekts die maximale Kapazität überschreitet.

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.

open System
open System.Text

let sb = StringBuilder(15, 15)
sb.Append "Substring #1 "
|> ignore
try
    sb.Insert(0, "Substring #2 ", 1)
    |> ignore
with :? OutOfMemoryException as e ->
    printfn $"Out of Memory: {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.

Sie können eine der folgenden Aktionen ausführen, um den Fehler zu beheben:

Ihre App wird als 32-Bit-Prozess ausgeführt.

32-Bit-Prozesse können maximal 2 GB arbeitsspeicher im virtuellen Benutzermodus auf 32-Bit-Systemen und 4 GB arbeitsspeicher im virtuellen Benutzermodus auf 64-Bit-Systemen zuordnen. Dies kann es für die Common Language Runtime erschweren, ausreichend zusammenhängenden Arbeitsspeicher zuzuweisen, wenn eine große Zuordnung erforderlich ist. Im Gegensatz dazu können 64-Bit-Prozesse bis zu 8 TB virtuellen Arbeitsspeicher zuordnen. Um diese Ausnahme zu beheben, kompilieren Sie Ihre App erneut, um eine 64-Bit-Plattform als Ziel zu verwenden. Informationen zum Ziel bestimmter Plattformen in Visual Studio finden Sie unter Vorgehensweise: Konfigurieren von Projekten für Zielplattformen.

Ihre App gibt nicht verwaltete Ressourcen aus

Der Garbage Collector kann zwar Arbeitsspeicher freigeben, der verwalteten Typen zugeordnet ist, verwaltet jedoch keinen Arbeitsspeicher, der nicht verwalteten Ressourcen wie Betriebssystemhandles (einschließlich Handles für Dateien, im Speicher zugeordnete Dateien, Pipes, Registrierungsschlüssel und Wartehandles) und Speicherblöcke, die direkt durch Windows-API-Aufrufe oder durch Aufrufe von Speicherbelegungsfunktionen wie malloczugewiesen werden. Typen, die nicht verwaltete Ressourcen nutzen, implementieren die IDisposable -Schnittstelle.

Wenn Sie einen Typ verwenden, der nicht verwaltete Ressourcen verwendet, sollten Sie die -Methode aufrufen IDisposable.Dispose , wenn Sie die Verwendung abgeschlossen haben. (Einige Typen implementieren auch eine Close Methode, die in ihrer Funktion mit einer Dispose Methode identisch ist.) Weitere Informationen finden Sie im Thema Verwenden von Objekten, die IDisposable implementieren .

Wenn Sie einen Typ erstellt haben, der nicht verwaltete Ressourcen verwendet, stellen Sie sicher, dass Sie das Dispose-Muster implementiert und bei Bedarf einen Finalizer bereitgestellt haben. Weitere Informationen finden Sie unter Implementieren einer Dispose-Methode und Object.Finalize.

Sie versuchen, ein großes Array in einem 64-Bit-Prozess zu erstellen.

Standardmäßig lässt die Common Language Runtime in .NET Framework keine einzelnen Objekte zu, deren Größe 2 GB überschreitet. Um diese Standardeinstellung zu überschreiben, können Sie die <Konfigurationsdateieinstellung gcAllowVeryLargeObjects> verwenden, um Arrays zu aktivieren, deren Gesamtgröße 2 GB überschreitet. Unter .NET Core ist die Unterstützung für Arrays mit mehr als 2 GB standardmäßig aktiviert.

Sie arbeiten mit sehr großen Datasets (z. B. Arrays, Sammlungen oder Datenbankdatensätze) im Arbeitsspeicher.

Wenn Datenstrukturen oder Datasets, die sich im Arbeitsspeicher befinden, so groß werden, dass die Common Language Runtime nicht genügend zusammenhängenden Arbeitsspeicher für sie zuordnen kann, entsteht eine OutOfMemoryException Ausnahme.

Um die OutOfMemoryException Ausnahmen zu verhindern, müssen Sie Ihre Anwendung so ändern, dass weniger Daten im Arbeitsspeicher vorhanden sind, oder die Daten in Segmente unterteilt werden, die kleinere Speicherbelegungen erfordern. Beispiel:

  • Wenn Sie alle Daten aus einer Datenbank abrufen und diese dann in Ihrer App filtern, um Die Fahrten zum Server zu minimieren, sollten Sie Ihre Abfragen so ändern, dass nur die Teilmenge der Daten zurückgegeben wird, die Ihre App benötigt. Bei der Arbeit mit großen Tabellen sind mehrere Abfragen fast immer effizienter, als alle Daten in einer einzelnen Tabelle abzurufen und dann zu bearbeiten.

  • Wenn Sie Abfragen ausführen, die Benutzer dynamisch erstellen, sollten Sie sicherstellen, dass die Anzahl der von der Abfrage zurückgegebenen Datensätze begrenzt ist.

  • Wenn Sie große Arrays oder andere Sammlungsobjekte verwenden, deren Größe zu einer OutOfMemoryException Ausnahme führt, sollten Sie Ihre Anwendung so ändern, dass die Daten in Teilmengen bearbeitet werden, anstatt alle gleichzeitig zu verwenden.

Im folgenden Beispiel wird ein Array abgerufen, das aus 200 Millionen Gleitkommawerten besteht, und dann deren Mittelwert berechnet. Die Ausgabe des Beispiels zeigt, dass, da das Beispiel das gesamte Array im Arbeitsspeicher speichert, bevor es den Mittelwert berechnet, ein OutOfMemoryException ausgelöst wird.

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.

open System

let getData () =
    let rnd = Random()
    [|  for i = 1 to 200000000 do
            rnd.NextDouble()
            if i % 10000000 = 0 then
                printfn $"Retrieved {i:N0} items of data." |]
    
let getMean values =
    let sum = Array.sum values

    sum / float values.Length

let values = getData ()
// Compute mean.
printfn $"Sample mean: {getMean values}, N = {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.

Im folgenden Beispiel wird die OutOfMemoryException Ausnahme beseitigt, indem die eingehenden Daten verarbeitet werden, ohne das gesamte Dataset im Arbeitsspeicher zu speichern, die Daten bei Bedarf in eine Datei serialisiert werden, um die weitere Verarbeitung zu ermöglichen (diese Zeilen sind im Beispiel auskommentiert, da sie in diesem Fall eine Datei mit einer Größe von mehr als 1 GB erzeugen) und den berechneten Mittelwert und die Anzahl der Fälle an die aufrufende Routine zurückgeben.

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

open System
// open System.IO

let getResult () =
    let chunkSize = 50000000
    let nToGet = 200000000
    let rnd = Random()
    // use fs = new FileStream(@".\data.bin", FileMode.Create)
    // use bin = new BinaryWriter(fs)
    // bin.Write 0
    let mutable n = 0
    let mutable sum = 0.
    for _ = 0 to int (ceil (nToGet / chunkSize |> float) - 1.) do
        for _ = 0 to min (nToGet - n - 1) (chunkSize - 1) do
            let value = rnd.NextDouble()
            sum <- sum + value
            n <- n + 1
            // bin.Write(value)
    // bin.Seek(0, SeekOrigin.Begin) |> ignore
    // bin.Write n
    sum / float n, n

let mean, n = getResult ()
printfn $"Sample mean: {mean}, N = {n:N0}"

// 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

Sie verketten wiederholt große Zeichenfolgen.

Da Zeichenfolgen unveränderlich sind, erstellt jeder Zeichenfolgenverkettungsvorgang eine neue Zeichenfolge. Die Auswirkungen für kleine Zeichenfolgen oder für eine kleine Anzahl von Verkettungsvorgängen sind vernachlässigbar. Bei großen Zeichenfolgen oder einer sehr großen Anzahl von Verkettungsvorgängen kann die Zeichenfolgenverkettung jedoch zu einer großen Anzahl von Speicherbelegungen und Speicherfragmentierung, schlechter Leistung und möglicherweise OutOfMemoryException Ausnahmen führen.

Wenn Sie große Zeichenfolgen verketten oder eine große Anzahl von Verkettungsvorgängen ausführen, sollten Sie die StringBuilder -Klasse anstelle der String -Klasse verwenden. Wenn Sie die Bearbeitung der Zeichenfolge abgeschlossen haben, konvertieren Sie die StringBuilder Instanz in eine Zeichenfolge, indem Sie die StringBuilder.ToString -Methode aufrufen.

Sie heften eine große Anzahl von Objekten im Arbeitsspeicher an.

Das Anheften einer großen Anzahl von Objekten im Arbeitsspeicher über einen längeren Zeitraum kann es für den Garbage Collector erschweren, zusammenhängende Speicherblöcke zuzuordnen. Wenn Sie eine große Anzahl von Objekten im Arbeitsspeicher angeheftet haben, z. B. indem Sie die fixed -Anweisung in C# verwenden oder die -Methode mit dem GCHandle.Alloc(Object, GCHandleType) Handle-Typ GCHandleType.Pinnedaufrufen, können Sie die folgenden Schritte ausführen, um die OutOfMemoryException Ausnahme zu beheben.

  • Evaluieren, ob jedes Objekt wirklich angeheftet werden muss,

  • Stellen Sie sicher, dass jedes Objekt so bald wie möglich aufgehoben wird.

  • Stellen Sie sicher, dass jeder Aufruf der Methode zum Anheften des GCHandle.Alloc(Object, GCHandleType) Arbeitsspeichers über einen entsprechenden Aufruf der -Methode verfügt, um diesen GCHandle.Free Arbeitsspeicher zu lösen.

Die folgenden MSIL-Anweisungen (Microsoft Intermediate) lösen eine Ausnahme aus OutOfMemoryException :

Konstruktoren

OutOfMemoryException()

Initialisiert eine neue Instanz der OutOfMemoryException-Klasse.
OutOfMemoryException(SerializationInfo, StreamingContext)
Veraltet.

Initialisiert eine neue Instanz der OutOfMemoryException-Klasse mit serialisierten Daten.
OutOfMemoryException(String)

Initialisiert eine neue Instanz der OutOfMemoryException-Klasse mit einer angegebenen Fehlermeldung.
OutOfMemoryException(String, Exception)

Initialisiert eine neue Instanz der OutOfMemoryException-Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat.

Eigenschaften

Data

Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen zur Ausnahme bereitstellen.

(Geerbt von Exception)
HelpLink

Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest.

(Geerbt von Exception)
HResult

Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist.

(Geerbt von Exception)
InnerException

Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat.

(Geerbt von Exception)
Message

Ruft eine Meldung ab, mit der die aktuelle Ausnahme beschrieben wird.

(Geerbt von Exception)
Source

Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest.

(Geerbt von Exception)
StackTrace

Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab.

(Geerbt von Exception)
TargetSite

Ruft die Methode ab, die die aktuelle Ausnahme auslöst.

(Geerbt von Exception)

Methoden

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetBaseException()

Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die Grundursache für eine oder mehrere nachfolgende Ausnahmen ist.

(Geerbt von Exception)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetObjectData(SerializationInfo, StreamingContext)
Veraltet.

Legt beim Überschreiben in einer abgeleiteten Klasse die SerializationInfo mit Informationen über die Ausnahme fest.

(Geerbt von Exception)
GetType()

Ruft den Laufzeittyp der aktuellen Instanz ab.

(Geerbt von Exception)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ToString()

Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück.

(Geerbt von Exception)

Ereignisse

SerializeObjectState
Veraltet.

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt mit serialisierten Daten über die Ausnahme zu erstellen.

(Geerbt von Exception)

Gilt für:

Weitere Informationen