OutOfMemoryException OutOfMemoryException OutOfMemoryException OutOfMemoryException Class

Définition

Exception levée quand il n'y a pas suffisamment de mémoire pour poursuivre l'exécution d'un programme.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
Héritage
OutOfMemoryExceptionOutOfMemoryExceptionOutOfMemoryExceptionOutOfMemoryException
Dérivé
Attributs

Remarques

OutOfMemoryExceptionutilise le HRESULT COR_E_OUTOFMEMORY, qui a la valeur 0x8007000E.OutOfMemoryException uses the HRESULT COR_E_OUTOFMEMORY, which has the value 0x8007000E.

Pour obtenir la liste des valeurs initiales des propriétés d’une instance de OutOfMemoryException, consultez le OutOfMemoryException constructeurs.For a list of initial property values for an instance of OutOfMemoryException, see the OutOfMemoryException constructors.

Notes

La valeur de la propriété Data héritée est nulltoujours.The value of the inherited Data property is always null.

Une OutOfMemoryException exception a deux causes principales :An OutOfMemoryException exception has two major causes:

  • Vous tentez de développer un StringBuilder objet au-delà de la longueur StringBuilder.MaxCapacity définie par sa propriété.You are attempting to expand a StringBuilder object beyond the length defined by its StringBuilder.MaxCapacity property.

  • La common language runtime ne peut pas allouer suffisamment de mémoire contiguë pour effectuer correctement une opération.The common language runtime cannot allocate enough contiguous memory to successfully perform an operation. Cette exception peut être levée par toute assignation de propriété ou appel de méthode qui requiert une allocation de mémoire.This exception can be thrown by any property assignment or method call that requires a memory allocation. Pour plus d’informations sur la cause de OutOfMemoryException l’exception, consultez le billet de blog « mémoire insuffisante » ne fait pas référence à la mémoire physique.For more information on the cause of the OutOfMemoryException exception, see the blog post "Out of Memory" Does Not Refer to Physical Memory.

    Ce type d' OutOfMemoryException exception représente une défaillance catastrophique.This type of OutOfMemoryException exception represents a catastrophic failure. Si vous choisissez de gérer l’exception, vous devez inclure un catch bloc qui appelle la Environment.FailFast méthode pour mettre fin à votre application et ajouter une entrée au journal des événements système, comme le fait l’exemple suivant.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...
    

Certaines des conditions dans lesquelles l’exception est levée et les actions que vous pouvez entreprendre pour l’éliminer sont les suivantes :Some of the conditions under which the exception is thrown and the actions you can take to eliminate it include the following:

Vous appelez la StringBuilder.Insert méthode.You are calling the StringBuilder.Insert method.

Vous essayez d’augmenter la longueur d’un StringBuilder objet au-delà de la taille spécifiée par sa StringBuilder.MaxCapacity propriété.You are attempting to increase the length of a StringBuilder object beyond the size specified by its StringBuilder.MaxCapacity property. L’exemple suivant illustre l' OutOfMemoryException exception levée par un appel à la StringBuilder.Insert(Int32, String, Int32) méthode quand l’exemple tente d’insérer une chaîne qui entraînerait un dépassement de la Length capacité maximale de la propriété de l’objet.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.

Vous pouvez effectuer l’une des opérations suivantes pour résoudre l’erreur :You can do either of the following to address the error:

Votre application s’exécute en tant que processus 32 bits.Your app runs as a 32-bit process.

les processus 32 bits peuvent allouer un maximum de 2 Go de mémoire en mode utilisateur virtuel sur les systèmes 32 bits et 4 Go de mémoire virtuelle en mode utilisateur sur les systèmes 64 bits.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. Cela peut compliquer le common language runtime d’allouer suffisamment de mémoire contiguë lorsqu’une allocation importante est nécessaire.This can make it more difficult for the common language runtime to allocate sufficient contiguous memory when a large allocation is needed. En revanche, les processus 64 bits peuvent allouer jusqu’à 8 to de mémoire virtuelle.In contrast, 64-bit processes can allocate up to 8TB of virtual memory. Pour résoudre cette exception, recompilez votre application pour cibler une plateforme 64 bits.To address this exception, recompile your app to target a 64-bit platform. Pour plus d’informations sur le ciblage de plateformes spécifiques dans Visual Studio, consultez Procédure : Configurer des projets pour des plateformes cibles.For information on targeting specific platforms in Visual Studio, see How to: Configure Projects to Target Platforms.

Votre application subit des fuites de ressources non géréesYour app is leaking unmanaged resources

Bien que le garbage collector soit en mesure de libérer de la mémoire allouée aux types managés, il ne gère pas la mémoire allouée aux ressources non managées telles que les handles de système d’exploitation (y compris les handles de fichiers, les fichiers mappés en mémoire, les canaux, les clés de Registre et les handles d’attente) et les blocs de mémoire alloués directement par les appels d’API Windows ou par les mallocappels aux fonctions d’allocation de mémoire telles que.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. Les types qui utilisent des ressources non managées IDisposable implémentent l’interface.Types that consume unmanaged resources implement the IDisposable interface.

Si vous utilisez un type qui utilise des ressources non managées, vous devez être sûr d’appeler sa IDisposable.Dispose méthode une fois que vous avez fini de l’utiliser.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. (Certains types implémentent également Close une méthode qui est identique dans une fonction Dispose à une méthode.) Pour plus d’informations, consultez la rubrique utilisation d’objets qui implémentent 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.

Si vous avez créé un type qui utilise des ressources non managées, assurez-vous que vous avez implémenté le modèle de suppression et, si nécessaire, fourni un finaliseur.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. Pour plus d’informations, consultez implémentation d’une méthode dispose et Object.Finalize.For more information, see Implementing a Dispose method and Object.Finalize.

Vous essayez de créer un tableau volumineux dans un processus 64 bitsYou are attempting to create a large array in a 64-bit process

Par défaut, le common language runtime dans .NET Framework n’autorise pas les objets uniques dont la taille est supérieure à 2 Go.By default, the common language runtime in .NET Framework does not allow single objects whose size exceeds 2GB. Pour remplacer cette valeur par défaut, vous pouvez utiliser le paramètre de fichier de configuration <gcAllowVeryLargeObjects > pour activer les tableaux dont la taille totale dépasse 2 Go.To override this default, you can use the <gcAllowVeryLargeObjects> configuration file setting to enable arrays whose total size exceeds 2 GB. Sur .NET Core, la prise en charge des tableaux de plus de 2 Go est activée par défaut.On .NET Core, support for arrays of greater than 2 GB is enabled by default.

Vous travaillez avec de très grands ensembles de données (tels que des tableaux, des collections ou des jeux de données de base de données) en mémoire.You are working with very large sets of data (such as arrays, collections, or database data sets) in memory.

Lorsque les structures de données ou les jeux de données qui résident en mémoire deviennent tellement volumineux que le Common Language Runtime ne peut pas allouer suffisamment de mémoire OutOfMemoryException contiguë pour eux, une exception se produit.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.

Pour éviter les OutOfMemoryException exceptions, vous devez modifier votre application afin que moins de données résident dans la mémoire, ou que les données soient divisées en segments nécessitant des allocations de mémoire plus petites.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. Par exemple :For example:

  • Si vous récupérez toutes les données d’une base de données, puis que vous les filtrez dans votre application afin de réduire au maximum les allers-retours vers le serveur, vous devez modifier vos requêtes pour qu’elles ne retournent que le sous-ensemble de données dont votre application a besoin.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. Lorsque vous utilisez des tables volumineuses, plusieurs requêtes sont presque toujours plus efficaces que la récupération de toutes les données d’une table unique, puis leur manipulation.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.

  • Si vous exécutez des requêtes que les utilisateurs créent dynamiquement, vous devez vous assurer que le nombre d’enregistrements retournés par la requête est limité.If you are executing queries that users create dynamically, you should ensure that the number of records returned by the query is limited.

  • Si vous utilisez des tableaux de grande taille ou d’autres objets de collection dont la OutOfMemoryException taille entraîne une exception, vous devez modifier votre application pour qu’elle fonctionne avec les données dans des sous-ensembles plutôt que de les utiliser toutes en même temps.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.

L’exemple suivant obtient un tableau qui se compose de valeurs à virgule flottante 200 millions, puis calcule leur moyenne.The following example gets a array that consists of 200 million floating-point values and then calculates their mean. La sortie de l’exemple montre que, étant donné que l’exemple stocke l’ensemble du tableau dans la mémoire avant de calculer OutOfMemoryException la moyenne, une exception est levée.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.

L’exemple suivant élimine l' OutOfMemoryException exception en traitant les données entrantes sans stocker l’ensemble du jeu de données en mémoire, en sérialisant les données dans un fichier si nécessaire pour permettre un traitement supplémentaire (ces lignes sont commentées dans l’exemple, dans ce cas, ils produisent un fichier dont la taille est supérieure à 1 Go) et retournent la moyenne calculée et le nombre de cas à la routine d’appel.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

Vous concaténez plusieurs chaînes de grande taille.You are repeatedly concatenating large strings.

Étant donné que les chaînes sont immuables, chaque opération de concaténation de chaîne crée une nouvelle chaîne.Because strings are immutable, each string concatenation operation creates a new string. L’impact pour les chaînes de petite taille, ou pour un petit nombre d’opérations de concaténation, est négligeable.The impact for small strings, or for a small number of concatenation operations, is negligible. Toutefois, pour les chaînes de grande taille ou un très grand nombre d’opérations de concaténation, la concaténation de chaînes peut entraîner un grand nombre d’allocations de mémoire et de OutOfMemoryException fragmentation de la mémoire, de mauvaises performances et éventuellement d’exceptions.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.

Lors de la concaténation de chaînes volumineuses ou de l’exécution d’un grand nombre d’opérations StringBuilder de concaténation, String vous devez utiliser la classe au lieu de la classe.When concatenating large strings or performing a large number of concatenation operations, you should use the StringBuilder class instead of the String class. Lorsque vous avez terminé de manipuler la chaîne, convertissez StringBuilder l’instance en une chaîne en appelant StringBuilder.ToString la méthode.When you have finished manipulating the string, convert the StringBuilder instance to a string by calling the StringBuilder.ToString method.

Vous épinglez un grand nombre d’objets en mémoire.You pin a large number of objects in memory.

L’épinglage d’un grand nombre d’objets en mémoire pour de longues périodes peut compliquer l’allocation de blocs de mémoire contigus au « garbage collector ».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. Si vous avez épinglé un grand nombre d’objets en mémoire, par exemple en utilisant l' fixed instruction dans C# ou en appelant la GCHandle.Alloc(Object, GCHandleType) méthode avec un type de handle GCHandleType.Pinnedde, vous pouvez effectuer les opérations suivantes pour OutOfMemoryException traiter l’exception.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.

  • Évaluer si chaque objet doit vraiment être épinglé,Evaluate whether each object really needs to be pinned,

  • Assurez-vous que chaque objet est libéré dès que possible.Ensure that each object is unpinned as soon as possible.

  • Assurez-vous que chaque appel GCHandle.Alloc(Object, GCHandleType) à la méthode pour épingler la mémoire a un GCHandle.Free appel correspondant à la méthode pour détacher la mémoire.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.

Les instructions MSIL (Microsoft Intermediate Language) suivantes lèvent une OutOfMemoryException exception :The following Microsoft intermediate (MSIL) instructions throw an OutOfMemoryException exception:

Constructeurs

OutOfMemoryException() OutOfMemoryException() OutOfMemoryException() OutOfMemoryException()

Initialise une nouvelle instance de la classe OutOfMemoryException.Initializes a new instance of the OutOfMemoryException class.

OutOfMemoryException(SerializationInfo, StreamingContext) OutOfMemoryException(SerializationInfo, StreamingContext) OutOfMemoryException(SerializationInfo, StreamingContext) OutOfMemoryException(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe OutOfMemoryException avec des données sérialisées.Initializes a new instance of the OutOfMemoryException class with serialized data.

OutOfMemoryException(String) OutOfMemoryException(String) OutOfMemoryException(String) OutOfMemoryException(String)

Initialise une nouvelle instance de la classe OutOfMemoryException avec un message d'erreur spécifié.Initializes a new instance of the OutOfMemoryException class with a specified error message.

OutOfMemoryException(String, Exception) OutOfMemoryException(String, Exception) OutOfMemoryException(String, Exception) OutOfMemoryException(String, Exception)

Initialise une nouvelle instance de la classe OutOfMemoryException avec un message d'erreur spécifié et une référence à l'exception interne ayant provoqué cette exception.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.

Propriétés

Data Data Data Data

Obtient une collection de paires clé/valeur qui fournissent des informations supplémentaires définies par l’utilisateur sur l’exception.Gets a collection of key/value pairs that provide additional user-defined information about the exception.

(Inherited from Exception)
HelpLink HelpLink HelpLink HelpLink

Obtient ou définit un lien vers le fichier d'aide associé à cette exception.Gets or sets a link to the help file associated with this exception.

(Inherited from Exception)
HResult HResult HResult HResult

Obtient ou définit HRESULT, valeur numérique codée qui est assignée à une exception spécifique.Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception.

(Inherited from Exception)
InnerException InnerException InnerException InnerException

Obtient l'instance Exception qui a provoqué l'exception actuelle.Gets the Exception instance that caused the current exception.

(Inherited from Exception)
Message Message Message Message

Obtient un message qui décrit l'exception actuelle.Gets a message that describes the current exception.

(Inherited from Exception)
Source Source Source Source

Obtient ou définit le nom de l'application ou de l'objet qui est à l'origine de l'erreur.Gets or sets the name of the application or the object that causes the error.

(Inherited from Exception)
StackTrace StackTrace StackTrace StackTrace

Obtient une représentation sous forme de chaîne des frames immédiats sur la pile des appels.Gets a string representation of the immediate frames on the call stack.

(Inherited from Exception)
TargetSite TargetSite TargetSite TargetSite

Obtient la méthode qui lève l'exception actuelle.Gets the method that throws the current exception.

(Inherited from Exception)

Méthodes

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetBaseException() GetBaseException() GetBaseException() GetBaseException()

En cas de substitution dans une classe dérivée, retourne la Exception qui est à l'origine d'une ou de plusieurs exceptions ultérieures.When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions.

(Inherited from Exception)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

En cas de substitution dans une classe dérivée, définit SerializationInfo avec des informations sur l'exception.When overridden in a derived class, sets the SerializationInfo with information about the exception.

(Inherited from Exception)
GetType() GetType() GetType() GetType()

Obtient le type au moment de l'exécution de l'instance actuelle.Gets the runtime type of the current instance.

(Inherited from Exception)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Crée et retourne une chaîne représentant l'exception actuelle.Creates and returns a string representation of the current exception.

(Inherited from Exception)

Événements

SerializeObjectState SerializeObjectState SerializeObjectState SerializeObjectState

Se produit quand une exception est sérialisée pour créer un objet d'état d'exception qui contient des données sérialisées concernant l'exception.Occurs when an exception is serialized to create an exception state object that contains serialized data about the exception.

(Inherited from Exception)

S’applique à

Voir aussi