Quelle est la meilleure façon d'améliorer l'utilisation de la mémoire lorsque vous collectez un grand ensemble de données avant de le traiter? (.NET)

Question

Lorsque je dois obtenir des Go de données, les enregistrer sur une collection et les traiter, j'ai des débordements de mémoire. Ainsi, au lieu de:

public class Program 
{ 
    public IEnumerable<SomeClass> GetObjects() 
    { 
     var list = new List<SomeClass>(); 
     while(// get implementation 
      list.Add(object); 
     } 
     return list; 
    } 

    public void ProcessObjects(IEnumerable<SomeClass> objects) 
    { 
     foreach(var object in objects) 
      // process implementation 
    } 

    void Main() 
    { 
     var objects = GetObjects(); 
     ProcessObjects(objects); 
    } 
} 

J'ai besoin de:

public class Program 
{ 
    void ProcessObject(SomeClass object) 
    { 
     // process implementation 
    } 

    public void GetAndProcessObjects() 
    { 
     var list = new List<SomeClass>(); 
     while(// get implementation 
      Process(object); 
     } 
     return list; 
    } 

    void Main() 
    { 
     var objects = GetAndProcessObjects(); 
    } 
} 

Il y a une meilleure façon?

Answer 1

Vous devez tirer parti de la déclaration C# 's iterator blocks et utiliser le yield return faire quelque chose comme ceci:

public class Program 
{ 
    public IEnumerable<SomeClass> GetObjects() 
    { 
     while(// get implementation 
      yield return object; 
     } 
    } 

    public void ProcessObjects(IEnumerable<SomeClass> objects) 
    { 
     foreach(var object in objects) 
      // process implementation 
    } 

    void Main() 
    { 
     var objects = GetObjects(); 
     ProcessObjects(objects); 
    } 
} 

Cela vous permettra de diffuser chaque objet et non garder la séquence entière en mémoire - vous ne devez Gardez un objet en mémoire à la fois.

Answer 2

N'utilisez pas de liste, qui nécessite que toutes les données soient présentes en même temps dans la mémoire. Utilisez IEnumerable<T> et produisez les données à la demande, ou mieux, utilisez IQueryable<T> et faites différer l'exécution complète de la requête jusqu'à ce que les données soient requises.

Sinon, ne gardez pas du tout les données en mémoire, mais enregistrez les données dans une base de données pour traitement. Une fois le traitement terminé, interrogez la base de données pour connaître les résultats.

Answer 3

Vous voulez yield!

Retarder le traitement de votre énumération. Construire une méthode qui renvoie un IEnumerable mais ne renvoie qu'un enregistrement à la fois en utilisant l'instruction yield.

Answer 4

public IEnumerable<SomeClass> GetObjects() 
    { 

     foreach(var obj in GetIQueryableObjects 
      yield return obj 
    } 

Answer 5

La meilleure méthode dans ce cas serait d'obtenir et de traiter en blocs. Vous devrez déterminer la taille d'un bloc à obtenir et à traiter par essais et erreurs. Ainsi, le code serait quelque chose comme:

public class Program 

{ IEnumerable publics getObjects (ancrage int, int chunkSize) { liste var = new List(); while (// obtenir la mise en œuvre pour l'ancre donnée et chunkSize list.Add (objet);} liste de retour;? }

public void ProcessObjects(IEnumerable<SomeClass> objects) 
{ 
    foreach(var object in objects) 
     // process implementation 
} 

void Main() 
{ 
    int chunkSize = 5000; 
    int totalSize = //Get Total Number of rows; 
    int anchor = //Get first row to process as anchor; 
    While (anchor < totalSize) 
    (
     var objects = GetObjects(anchor, chunkSize); 
     ProcessObjects(objects); 
     anchor += chunkSize; 
    } 
} 

}