OutOfMemoryException Třída

Definice

Výjimka, která je vyvolána, pokud není k dispozici dostatek paměti pro pokračování v provádění 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
Dědičnost
OutOfMemoryException
Odvozené
Atributy

Poznámky

OutOfMemoryExceptionpoužívá HRESULT COR_E_OUTOFMEMORY, který má hodnotu 0x8007000E.OutOfMemoryException uses the HRESULT COR_E_OUTOFMEMORY, which has the value 0x8007000E.

Seznam počáteční hodnoty vlastností pro instanci OutOfMemoryException, najdete v článku OutOfMemoryException konstruktory.For a list of initial property values for an instance of OutOfMemoryException, see the OutOfMemoryException constructors.

Poznámka

Hodnota zděděné Data vlastnosti je vždy null.The value of the inherited Data property is always null.

OutOfMemoryException Výjimka má dvě hlavní příčiny:An OutOfMemoryException exception has two major causes:

  • Pokoušíte se rozšířit StringBuilder objekt nad délku definovanou StringBuilder.MaxCapacity vlastností.You are attempting to expand a StringBuilder object beyond the length defined by its StringBuilder.MaxCapacity property.

  • Modul CLR (Common Language Runtime) nemůže přidělit dostatek souvislé paměti pro úspěšné provedení operace.The common language runtime cannot allocate enough contiguous memory to successfully perform an operation. Tato výjimka může být vyvolána jakýmkoli přiřazením vlastnosti nebo voláním metody, která vyžaduje přidělení paměti.This exception can be thrown by any property assignment or method call that requires a memory allocation. Další informace o příčině OutOfMemoryException výjimky najdete v blogovém příspěvku "nedostatek paměti", který neodkazuje na fyzickou paměť.For more information on the cause of the OutOfMemoryException exception, see the blog post "Out of Memory" Does Not Refer to Physical Memory.

    Tento typ OutOfMemoryException výjimky představuje závažnou chybu.This type of OutOfMemoryException exception represents a catastrophic failure. Pokud se rozhodnete tuto výjimku zpracovat, měli byste zahrnout catch blok, který Environment.FailFast volá metodu pro ukončení vaší aplikace a přidání položky do protokolu událostí systému, jak je uvedeno v následujícím příkladu.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...
    

Některé podmínky, za kterých je vyvolána výjimka, a akce, které můžete provést k odstranění, zahrnují následující:Some of the conditions under which the exception is thrown and the actions you can take to eliminate it include the following:

Zavoláte StringBuilder.Insert metodu.You are calling the StringBuilder.Insert method.

Pokoušíte se zvětšit délku StringBuilder objektu nad rámec velikosti určenou StringBuilder.MaxCapacity vlastností.You are attempting to increase the length of a StringBuilder object beyond the size specified by its StringBuilder.MaxCapacity property. Následující příklad ukazuje OutOfMemoryException výjimku vyvolanou voláním StringBuilder.Insert(Int32, String, Int32) metody, když se v příkladu pokusí vložit řetězec, který Length by způsobil překročení maximální kapacity vlastnosti objektu.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.

Tuto chybu můžete vyřešit jedním z následujících způsobů:You can do either of the following to address the error:

Vaše aplikace běží jako 32 proces.Your app runs as a 32-bit process.

32 – bitové procesy mohou přidělit maximálně 2 GB paměti virtuálního počítače v systémech s 32 a 4 GB paměti virtuálního uživatele v systémech 64-bit.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. To může být obtížnější pro modul CLR (Common Language Runtime) k přidělení dostatečné souvislé paměti, když je potřeba velké přidělení.This can make it more difficult for the common language runtime to allocate sufficient contiguous memory when a large allocation is needed. Naproti tomu 64 procesy mohou přidělit až 8TB virtuální paměti.In contrast, 64-bit processes can allocate up to 8TB of virtual memory. Chcete-li vyřešit tuto výjimku, znovu zkompilujte aplikaci a Zaměřte se na 64 bitovou platformu.To address this exception, recompile your app to target a 64-bit platform. Informace o cílení na konkrétní platformy v aplikaci Visual Studio naleznete v tématu How to: Nakonfigurujte projekty na cílové platformy.For information on targeting specific platforms in Visual Studio, see How to: Configure Projects to Target Platforms.

Vaše aplikace nevrací nespravované prostředky.Your app is leaking unmanaged resources

I když systém uvolňování paměti dokáže uvolnit paměť přidělenou spravovaným typům, nespravuje paměť přidělená nespravovaným prostředkům, jako jsou popisovače operačního systému (včetně popisovačů souborů, souborů mapovaných do paměti, kanálů, klíčů registru a obslužných rutin čekání). a bloky paměti přidělené přímo voláními rozhraní API systému Windows nebo volání funkcí přidělování paměti, mallocjako je.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, které využívají nespravované prostředky IDisposable , implementují rozhraní.Types that consume unmanaged resources implement the IDisposable interface.

Pokud pracujete s typem, který používá nespravované prostředky, měli byste zavolat jeho IDisposable.Dispose metodu po jejím dokončení.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. (Některé typy také implementují Close metodu, která je ve funkci Dispose totožná s metodou.) Další informace naleznete v tématu použití objektů, které implementují 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.

Pokud jste vytvořili typ, který používá nespravované prostředky, ujistěte se, že jste implementovali vzor Dispose a v případě potřeby zadal finalizační metodu.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. Další informace naleznete v tématu implementace metody Dispose a Object.Finalize.For more information, see Implementing a Dispose method and Object.Finalize.

Pokoušíte se vytvořit velké pole v 64 procesu.You are attempting to create a large array in a 64-bit process

Ve výchozím nastavení modul CLR (Common Language Runtime) v .NET Framework nepovoluje jednotlivé objekty, jejichž velikost překračuje 2 GB.By default, the common language runtime in .NET Framework does not allow single objects whose size exceeds 2GB. Chcete-li přepsat toto výchozí nastavení, můžete použít <nastavení gcAllowVeryLargeObjects > konfiguračního souboru a povolit pole, jejichž celková velikost přesahuje 2 GB.To override this default, you can use the <gcAllowVeryLargeObjects> configuration file setting to enable arrays whose total size exceeds 2 GB. V .NET Core je ve výchozím nastavení povolená podpora pro pole o velikosti větší než 2 GB.On .NET Core, support for arrays of greater than 2 GB is enabled by default.

Pracujete s velmi velkými sadami dat (jako jsou pole, kolekce nebo databázové sady dat) v paměti.You are working with very large sets of data (such as arrays, collections, or database data sets) in memory.

Když datové struktury nebo sady dat, které jsou umístěny v paměti, jsou tak velké, že modul CLR (Common Language Runtime) nedokáže přidělit dostatek souvislé OutOfMemoryException paměti pro ně, což je výsledek výjimky.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 nedocházelo OutOfMemoryException k výjimkám, musíte aplikaci upravit tak, aby v paměti bylo menší množství dat, nebo jsou data rozdělena na segmenty, které vyžadují menší přidělení paměti.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. Příklad:For example:

  • Pokud načítáte všechna data z databáze a pak je filtrujete v aplikaci, abyste minimalizovali cesty k serveru, měli byste upravit dotazy tak, aby vracely jenom podmnožinu dat, kterou vaše aplikace potřebuje.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. Při práci s velkými tabulkami je více dotazů skoro vždy efektivnější než načtení všech dat v jedné tabulce a jejich manipulace.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.

  • Pokud spouštíte dotazy, které uživatelé vytvářejí dynamicky, měli byste zajistit, aby byl počet záznamů vrácených dotazem omezen.If you are executing queries that users create dynamically, you should ensure that the number of records returned by the query is limited.

  • Pokud používáte velká pole nebo jiné objekty kolekce, jejichž velikost má za OutOfMemoryException následek výjimku, měli byste aplikaci upravit tak, aby data v podmnožinách pracovala, a ne vše najednou.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.

Následující příklad získá pole, které se skládá z 200 000 000 hodnot s plovoucí desetinnou čárkou a následně vypočítá jejich střední hodnotu.The following example gets a array that consists of 200 million floating-point values and then calculates their mean. Výstup z příkladu ukazuje, že vzhledem k tomu, že v příkladu je uloženo celé pole v paměti před výpočtem střední hodnoty OutOfMemoryException , je vyvolána výjimka.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.

Následující příklad eliminuje OutOfMemoryException výjimku tím, že zpracovává příchozí data bez uložení celé datové sady do paměti, a v případě potřeby k serializaci dat do souboru, pokud je to nutné k povolení dalšího zpracování (tyto řádky jsou v příkladu zakomentovány). vzhledem k tomu, že v tomto případě vytvoří soubor, jehož velikost je větší než 1 GB, a vrátí vypočtený význam a počet případů volající rutiny.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

Opakovaně probíhá zřetězení velkých řetězců.You are repeatedly concatenating large strings.

Vzhledem k tomu, že řetězce jsou neměnné, každá operace zřetězení řetězce vytvoří nový řetězec.Because strings are immutable, each string concatenation operation creates a new string. Dopad malých řetězců nebo malý počet operací zřetězení je zanedbatelný.The impact for small strings, or for a small number of concatenation operations, is negligible. Ale u velkých řetězců nebo velmi velkého počtu operací zřetězení může zřetězení řetězců vést k velkému počtu přidělení paměti a fragmentaci paměti, špatnému výkonu a možným OutOfMemoryException výjimkám.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.

Při zřetězení velkých řetězců nebo provádění velkého počtu operací zřetězení byste měli místo StringBuilder String třídy použít třídu.When concatenating large strings or performing a large number of concatenation operations, you should use the StringBuilder class instead of the String class. Po dokončení manipulace s řetězcem převeďte StringBuilder instanci na řetězec StringBuilder.ToString voláním metody.When you have finished manipulating the string, convert the StringBuilder instance to a string by calling the StringBuilder.ToString method.

V paměti připnete velký počet objektů.You pin a large number of objects in memory.

Připnutí velkého počtu objektů v paměti pro dlouhá období může pro uvolňování paměti být obtížné přidělit souvislé bloky paměti.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. Pokud jste připnuli velký počet objektů v fixed paměti, například pomocí příkazu v C# GCHandle.Alloc(Object, GCHandleType) nebo voláním metody s typem GCHandleType.Pinnedpopisovače, můžete vyřešit OutOfMemoryException výjimku následujícím způsobem.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.

  • Vyhodnoťte, jestli je potřeba každý objekt skutečně připnout.Evaluate whether each object really needs to be pinned,

  • Zajistěte, aby byl každý objekt co nejdříve nepřipnutý.Ensure that each object is unpinned as soon as possible.

  • Ujistěte se, že každé volání GCHandle.Alloc(Object, GCHandleType) metody připnutí paměti má odpovídající volání GCHandle.Free metody k uvolnění této paměti.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.

Následující pokyny pro Microsoft Intermediate (MSIL) vyvolávají OutOfMemoryException výjimku:The following Microsoft intermediate (MSIL) instructions throw an OutOfMemoryException exception:

Konstruktory

OutOfMemoryException()

Inicializuje novou instanci třídy OutOfMemoryException třídy.Initializes a new instance of the OutOfMemoryException class.

OutOfMemoryException(SerializationInfo, StreamingContext)

Inicializuje novou instanci třídy OutOfMemoryException třídy se serializovanými daty.Initializes a new instance of the OutOfMemoryException class with serialized data.

OutOfMemoryException(String)

Inicializuje novou instanci třídy OutOfMemoryException třídy pomocí zadané chybové zprávy.Initializes a new instance of the OutOfMemoryException class with a specified error message.

OutOfMemoryException(String, Exception)

Inicializuje novou instanci třídy OutOfMemoryException třídy pomocí zadané chybové zprávy a odkazu na vnitřní výjimku, která je příčinou této výjimky.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.

Vlastnosti

Data

Získá kolekci párů klíč/hodnota, které poskytují další uživatelsky definované informace o výjimce.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Zděděno od Exception)
HelpLink

Získá nebo nastaví odkaz na soubor s nápovědě spojený s touto výjimkou.Gets or sets a link to the help file associated with this exception.

(Zděděno od Exception)
HResult

Získá nebo nastaví hodnotu HRESULT, kódované číselné hodnoty, která je přiřazena konkrétní výjimce.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Zděděno od Exception)
InnerException

Získá instanci Exception, která způsobila aktuální výjimku.Gets the Exception instance that caused the current exception.

(Zděděno od Exception)
Message

Získá zprávu s popisem aktuální výjimky.Gets a message that describes the current exception.

(Zděděno od Exception)
Source

Získá nebo nastaví název aplikace nebo objektu, který způsobuje chybu.Gets or sets the name of the application or the object that causes the error.

(Zděděno od Exception)
StackTrace

Načte řetězcovou reprezentaci okamžitých snímků v zásobníku volání.Gets a string representation of the immediate frames on the call stack.

(Zděděno od Exception)
TargetSite

Získá metodu, která vyvolá aktuální výjimku.Gets the method that throws the current exception.

(Zděděno od Exception)

Metody

Equals(Object)

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
GetBaseException()

Při přepsání v odvozené třídě vrátí Exception, který je hlavní příčinou jedné nebo více následných výjimek.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Zděděno od Exception)
GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetObjectData(SerializationInfo, StreamingContext)

Při přepsání v odvozené třídě nastaví SerializationInfo s informacemi o výjimce.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Zděděno od Exception)
GetType()

Získá typ modulu runtime aktuální instance.Gets the runtime type of the current instance.

(Zděděno od Exception)
MemberwiseClone()

Vytvoří kopii aktuálního Objectbez podstruktury.Creates a shallow copy of the current Object.

(Zděděno od Object)
ToString()

Vytvoří a vrátí řetězcovou reprezentaci aktuální výjimky.Creates and returns a string representation of the current exception.

(Zděděno od Exception)

Události

SerializeObjectState

Nastane, pokud je serializovaná výjimka pro vytvoření objektu stavu výjimky, který obsahuje Serializovaná data o výjimce.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Zděděno od Exception)

Platí pro

Viz také