OutOfMemoryException Classe

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: OutOfMemoryException.cs

Source:: OutOfMemoryException.cs

Source:: OutOfMemoryException.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Exception levée lorsqu’il n’y a pas suffisamment de mémoire pour continuer l’exécution d’un programme.

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

Héritage: Object

Exception
OutOfMemoryException

Héritage: Object

Exception

SystemException
OutOfMemoryException

Dérivé: System.InsufficientMemoryException

Attributs: SerializableAttribute ComVisibleAttribute

Remarques

OutOfMemoryException utilise le COR_E_OUTOFMEMORYHRESULT, qui a la valeur 0x8007000E.

Pour obtenir la liste des valeurs de propriété initiales d’une instance de OutOfMemoryException, consultez les constructeurs OutOfMemoryException.

Note

La valeur de la propriété Data héritée est toujours null.

Une exception OutOfMemoryException a deux causes principales :

Vous tentez de développer un objet StringBuilder au-delà de la longueur définie par sa propriété StringBuilder.MaxCapacity.

Le Common Language Runtime ne peut pas allouer suffisamment de mémoire contiguë pour effectuer correctement une opération. Cette exception peut être levée par n’importe quelle affectation de propriété ou appel de méthode qui nécessite une allocation de mémoire. Pour plus d’informations sur la cause de l’exception OutOfMemoryException, consultez le billet de blog « Hors mémoire » ne fait pas référence à la mémoire physique.

Ce type d’exception OutOfMemoryException représente une défaillance catastrophique. Si vous choisissez de gérer l’exception, vous devez inclure un bloc catch qui appelle la méthode Environment.FailFast pour arrêter votre application et ajouter une entrée au journal des événements système, comme l’illustre l’exemple suivant.

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

Certaines des conditions dans lesquelles l’exception est levée et les actions que vous pouvez effectuer pour l’éliminer incluent les éléments suivants :

Vous appelez la méthode StringBuilder.Insert.

Vous tentez d’augmenter la longueur d’un objet StringBuilder au-delà de la taille spécifiée par sa propriété StringBuilder.MaxCapacity. L’exemple suivant illustre l’exception OutOfMemoryException levée par un appel à la méthode StringBuilder.Insert(Int32, String, Int32) lorsque l’exemple tente d’insérer une chaîne qui entraînerait l’dépassement de sa capacité maximale par la propriété Length de l’objet.

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.

Vous pouvez effectuer l’une des opérations suivantes pour résoudre l’erreur :

Remplacez l’appel du constructeur StringBuilder.StringBuilder(Int32, Int32) par un appel de toute autre surcharge de constructeur StringBuilder. La capacité maximale de votre objet StringBuilder est définie sur sa valeur par défaut, qui est Int32.MaxValue.
Appelez le constructeur StringBuilder.StringBuilder(Int32, Int32) avec une valeur maxCapacity suffisamment grande pour prendre en charge les expansions de l’objet StringBuilder.

Votre application s’exécute en tant que processus 32 bits.

Les processus 32 bits peuvent allouer un maximum de 2 Go de mémoire en mode utilisateur virtuel sur des systèmes 32 bits et 4 Go de mémoire en mode utilisateur virtuel sur des systèmes 64 bits. Cela peut rendre plus difficile pour le Common Language Runtime d’allouer suffisamment de mémoire contiguë lorsqu’une allocation importante est nécessaire. En revanche, les processus 64 bits peuvent allouer jusqu’à 8 To de mémoire virtuelle. Pour résoudre cette exception, recompilez votre application pour cibler une plateforme 64 bits. Pour plus d’informations sur le ciblage de plateformes spécifiques dans Visual Studio, consultez Guide pratique pour configurer des projets sur des plateformes cibles.

votre application fuit des ressources non managées

Bien que le garbage collector puisse 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 du système d’exploitation (y compris les handles aux 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 des appels à des fonctions d’allocation de mémoire telles que malloc. Les types qui consomment des ressources non managées implémentent l’interface IDisposable.

Si vous consommez un type qui utilise des ressources non managées, vous devez être sûr d’appeler sa méthode IDisposable.Dispose lorsque vous avez fini de l’utiliser. (Certains types implémentent également une méthode Close identique dans la fonction à une méthode Dispose.) Pour plus d’informations, consultez la rubrique Using Objects That Implement IDisposable rubrique.

Si vous avez créé un type qui utilise des ressources non managées, vérifiez que vous avez implémenté le modèle Dispose et, si nécessaire, fourni un finaliseur. Pour plus d’informations, consultez Implémentation d’une méthode Dispose et Object.Finalize.

Vous tentez de créer un tableau volumineux dans un processus 64 bits

Par défaut, le Common Language Runtime dans .NET Framework n’autorise pas les objets uniques dont la taille dépasse 2 Go. 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. Sur .NET Core, la prise en charge des tableaux de plus de 2 Go est activée par défaut.

Vous travaillez avec des jeux de données très volumineux (tels que des tableaux, des collections ou des jeux de données de base de données) en mémoire.

Lorsque les structures de données ou les jeux de données qui résident en mémoire deviennent si volumineux que le Common Language Runtime ne peut pas allouer suffisamment de mémoire contiguë pour eux, une exception OutOfMemoryException résultats.

Pour empêcher les exceptions OutOfMemoryException, vous devez modifier votre application afin que moins de données résident en mémoire, ou que les données soient divisées en segments nécessitant des allocations de mémoire plus petites. Par exemple:

Si vous récupérez toutes les données d’une base de données et que vous la filtrez dans votre application pour réduire les déplacements vers le serveur, vous devez modifier vos requêtes pour retourner uniquement le sous-ensemble de données dont votre application a besoin. Lors de l’utilisation de tables volumineuses, plusieurs requêtes sont presque toujours plus efficaces que de récupérer toutes les données d’une table unique, puis de les manipuler.
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é.
Si vous utilisez des tableaux volumineux ou d’autres objets de collection dont la taille entraîne une exception OutOfMemoryException, vous devez modifier votre application pour travailler les données dans des sous-ensembles plutôt que de les utiliser en une seule fois.

L’exemple suivant obtient un tableau qui se compose de 200 millions de valeurs à virgule flottante, puis calcule leur moyenne. La sortie de l’exemple montre que, étant donné que l’exemple stocke l’intégralité du tableau en mémoire avant qu’il calcule la moyenne, une OutOfMemoryException est levée.

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.

L’exemple suivant élimine l’exception OutOfMemoryException en traitant les données entrantes sans stocker l’ensemble du jeu de données en mémoire, 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, car dans ce cas, elles produisent un fichier dont la taille est supérieure à 1 Go) et retournent la moyenne calculée et le nombre de cas à la routine appelante.

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

Vous concatènez à plusieurs reprises de grandes chaînes.

Étant donné que les chaînes sont immuables, chaque opération de concaténation de chaîne crée une chaîne. L’impact pour les petites chaînes, ou pour un petit nombre d’opérations de concaténation, est négligeable. Toutefois, pour les chaînes volumineuses 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 fragmentation de la mémoire, des performances médiocres et éventuellement des exceptions OutOfMemoryException.

Lors de la concaténation de chaînes volumineuses ou de l’exécution d’un grand nombre d’opérations de concaténation, vous devez utiliser la classe StringBuilder au lieu de la classe String. Lorsque vous avez fini de manipuler la chaîne, convertissez l’instance de StringBuilder en chaîne en appelant la méthode StringBuilder.ToString.

Vous épinglez un grand nombre d’objets en mémoire.

L’épinglage d’un grand nombre d’objets en mémoire pendant de longues périodes peut compliquer l’allocation de blocs de mémoire contigus. Si vous avez épinglé un grand nombre d’objets en mémoire, par exemple en utilisant l’instruction fixed en C# ou en appelant la méthode GCHandle.Alloc(Object, GCHandleType) avec un type de handle de GCHandleType.Pinned, vous pouvez effectuer les opérations suivantes pour traiter l’exception OutOfMemoryException.

Évaluez si chaque objet doit vraiment être épinglé,
Vérifiez que chaque objet n’est pas épinglé dès que possible.
Assurez-vous que chaque appel à la méthode GCHandle.Alloc(Object, GCHandleType) pour épingler la mémoire a un appel correspondant à la méthode GCHandle.Free pour désépiner cette mémoire.

Les instructions Microsoft intermediate (MSIL) suivantes lèvent une exception OutOfMemoryException :

boîte de
newarr
newobj

Constructeurs

OutOfMemoryException()	Initialise une nouvelle instance de la classe OutOfMemoryException.
OutOfMemoryException(SerializationInfo, StreamingContext)	Obsolète. Initialise une nouvelle instance de la classe OutOfMemoryException avec des données sérialisées.
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 qui est la cause de cette exception.
OutOfMemoryException(String)	Initialise une nouvelle instance de la classe OutOfMemoryException avec un message d’erreur spécifié.

Propriétés

Data	Obtient une collection de paires clé/valeur qui fournissent des informations supplémentaires définies par l’utilisateur sur l’exception. (Hérité de Exception)
HelpLink	Obtient ou définit un lien vers le fichier d’aide associé à cette exception. (Hérité de Exception)
HResult	Obtient ou définit HRESULT, valeur numérique codée affectée à une exception spécifique. (Hérité de Exception)
InnerException	Obtient l’instance Exception qui a provoqué l’exception actuelle. (Hérité de Exception)
Message	Obtient un message qui décrit l’exception actuelle. (Hérité de Exception)
Source	Obtient ou définit le nom de l’application ou de l’objet qui provoque l’erreur. (Hérité de Exception)
StackTrace	Obtient une représentation sous forme de chaîne des images immédiates sur la pile des appels. (Hérité de Exception)
TargetSite	Obtient la méthode qui lève l’exception actuelle. (Hérité de Exception)

Méthodes

Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
GetBaseException()	En cas de substitution dans une classe dérivée, retourne la Exception qui est la cause racine d’une ou plusieurs exceptions ultérieures. (Hérité de Exception)
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)	Obsolète. En cas de substitution dans une classe dérivée, définit l'SerializationInfo avec des informations sur l’exception. (Hérité de Exception)
GetType()	Obtient le type d’exécution de l’instance actuelle. (Hérité de Exception)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
ToString()	Crée et retourne une représentation sous forme de chaîne de l’exception actuelle. (Hérité de Exception)

Événements

SerializeObjectState

Obsolète.

Se produit lorsqu’une exception est sérialisée pour créer un objet d’état d’exception qui contient des données sérialisées sur l’exception.

(Hérité de Exception)

S’applique à

Voir aussi

Exception
gestion et levée des exceptions

Partager via