Quand est-il acceptable d'appeler GC.Recueillir?

Si vous avez de bonnes raisons de croire qu'un important ensemble d'objets - en particulier ceux que vous soupçonnez d'être dans les générations 1 et 2 sont maintenant admissibles pour la collecte des ordures, et qui maintenant serait un bon moment pour recueillir en termes de performances de petite frappe.

Un bon exemple de ceci est que si vous avez juste fermé une grande forme. Vous savez que tous les contrôles de l'INTERFACE utilisateur peut maintenant être nettoyée, et une très courte pause que le formulaire est fermé ne sera probablement pas perceptible pour l'utilisateur.

Mise à JOUR 2.7.2018

Comme de .NET 4.5 - il y a GCLatencyMode.LowLatency et GCLatencyMode.SustainedLowLatency. Lors de la saisie et laissant l'autre de ces modes, il est recommandé que vous forcez un full GC avec GC.Collect(2, GCCollectionMode.Forced).

Comme de .NET 4.6 - il est le GC.TryStartNoGCRegion méthode (utilisée pour définir la valeur en lecture seule GCLatencyMode.NoGCRegion). Cela peut, d'effectuer un blocage complet de collecte des ordures dans une tentative pour libérer suffisamment de mémoire, mais étant donné que nous sommes en interdisant GC pour une période, je dirais que c'est aussi une bonne idée d'effectuer des GC avant et après.

Source: Microsoft ingénieur Ben Watson: Écrit Haute Performance .NET Code, 2e Ed. 2018.

Voir:

• https://msdn.microsoft.com/en-us/library/system.runtime.gclatencymode(v=vs. 110).aspx
• https://msdn.microsoft.com/en-us/library/dn906204(v=vs. 110).aspx

La meilleure pratique est de ne pas forcer une collecte des ordures dans la plupart des cas. (Chaque système, j'ai travaillé sur de qui avait forcé la collecte des poubelles, avait en soulignant les problèmes qui, si elle est résolue aurait supprimé le besoin de forcé la collecte des ordures, et accéléré le système grandement.)

Il y a un quelques cas quand vous en savoir plus sur l'utilisation de la mémoire alors que le garbage collector ne. C'est peu probable dans un multi-utilisateur de l'application ou un service qui répond à plus d'une demande à la fois.

Toutefois, dans certains lot de traitement de type vous ne savez plus que le GC. E. g. imaginez une application.

• Est donné une liste de noms de fichier sur la ligne de commande
• Processus en un seul fichier, puis écrire le résultat vers un fichier de résultats.
• Pendant le traitement du fichier, crée beaucoup de l'interdépendance des objets qui ne peuvent pas être collectées jusqu'à ce que le traitement du dossier complet (par exemple, un arbre d'analyse)
• Ne garde pas de correspondance entre les fichiers qu'il a traitées.

Vous peut être en mesure de faire une affaire (après mûre) les tests que vous devez forcer un plein de collecte des ordures après avoir traiter chaque fichier.

Un autre cas est un service qui se réveille toutes les quelques minutes pour traiter de certains éléments, et ne pas garder en l'état pendant qu'il est endormi. Alors forcement une collection complète juste avant d'aller dormir peut la peine.

Le seul moment où je considère forcer
une collection, c'est quand je sais que beaucoup
de l'objet a été créé récemment
et très peu d'objets sont actuellement
référencé.

Je préférerais avoir un garbage collection API quand j'ai pu lui donner des conseils sur ce type de chose, sans avoir à forcer un GC mon auto.

Voir aussi "Rico Mariani Performances de Friandises"

Dans les grandes 24/7 ou 24/6 systèmes-systèmes qui réagissent aux messages, les requêtes RPC ou que l'interrogation d'une base de données ou un processus continu -- il est utile d'avoir un moyen d'identifier les fuites de mémoire. Pour cela, j'ai tendance à ajouter un mécanisme pour l'application de suspendre temporairement le traitement et ensuite effectuer la collecte des ordures. Cela permet de mettre le système dans un état de repos où la mémoire restante est soit légitimement longue durée de vie de la mémoire (caches, de configuration, &c.) ou bien est - 'fuite' (objets qui ne sont pas prévus ou souhaitée pour être enracinée mais sont en réalité).

Avoir ce mécanisme rend beaucoup plus facile pour le profil de l'utilisation de la mémoire que les rapports ne seront pas obscurcie par des bruits de traitement actif.

Pour être sûr que vous obtenez toutes les ordures, vous devez effectuer deux collections:

GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();

Comme la première collection sera la cause de tous les objets avec les finaliseurs être finalisé (mais pas réellement de déchets collecter ces objets). La deuxième GC ordures recueillir ces finalisé objets.

Vous pouvez appeler GC.Collect() lorsque vous savez quelque chose sur la nature de l'application sur le garbage collector n'est pas. Il est tentant de penser que, comme l'auteur, c'est très probable. Cependant, la vérité est que le GC montants pour un assez bien écrit et testé système expert, et il est rare que vous savez quelque chose sur le code bas-niveau des chemins qu'il n'a pas.

Le meilleur exemple que je peux penser de l'endroit où vous pourriez avoir quelques informations supplémentaires est une application que les cycles entre les périodes d'inactivité et de la période très chargée. Vous voulez le meilleur rendement possible pour les périodes de pointe, et donc voulez utiliser le temps d'attente pour faire un peu de ménage en place.

Cependant, la plupart du temps, le GC est assez intelligent pour faire cela de toute façon.

Je faisais des tests de performance sur le tableau et de liste:

private static int count = 100000000;
private static List<int> GetSomeNumbers_List_int()
{
var lstNumbers = new List<int>();
for(var i = 1; i <= count; i++)
{
lstNumbers.Add(i);
}
return lstNumbers;
}
private static int[] GetSomeNumbers_Array()
{
var lstNumbers = new int[count];
for (var i = 1; i <= count; i++)
{
lstNumbers[i-1] = i + 1;
}
return lstNumbers;
}
private static int[] GetSomeNumbers_Enumerable_Range()
{
return  Enumerable.Range(1, count).ToArray();
}
static void performance_100_Million()
{
var sw = new Stopwatch();
sw.Start();
var numbers1 = GetSomeNumbers_List_int();
sw.Stop();
//numbers1 = null;
//GC.Collect();
Console.WriteLine(String.Format("\"List<int>\" took {0} milliseconds", sw.ElapsedMilliseconds));
sw.Reset();
sw.Start();
var numbers2 = GetSomeNumbers_Array();
sw.Stop();
//numbers2 = null;
//GC.Collect();
Console.WriteLine(String.Format("\"int[]\" took {0} milliseconds", sw.ElapsedMilliseconds));
sw.Reset();
sw.Start();
//getting System.OutOfMemoryException in GetSomeNumbers_Enumerable_Range method
var numbers3 = GetSomeNumbers_Enumerable_Range();
sw.Stop();
//numbers3 = null;
//GC.Collect();
Console.WriteLine(String.Format("\"int[]\" Enumerable.Range took {0} milliseconds", sw.ElapsedMilliseconds));
}

et j'ai eu OutOfMemoryException dans GetSomeNumbers_Enumerable_Range méthode, la seule solution est de libérer la mémoire par:

numbers = null;
GC.Collect();

Une instance où il est presque nécessaire de faire appel à GC.Collect() est pour l'automatisation de Microsoft Office grâce à l'Interopérabilité. COM objets pour le Bureau n'aime pas pour libérer automatiquement et peut entraîner, dans le cas de l'Office produit en prenant de très grandes quantités de mémoire. Je ne suis pas sûr si c'est un problème ou pas. Il y a beaucoup de messages sur ce sujet autour de l'internet, donc je ne vais pas trop entrer dans les détails.

Lors de la programmation de l'aide de l'Interopérabilité, chaque objet doit être manuellement publié, généralement, bien que l'utilisation du Maréchal.ReleseComObject(). En outre, l'appel de la Collecte des Ordures manuellement peut aider à "nettoyer" un peu. Appeler le code suivant lorsque vous avez terminé avec l'Interopérabilité des objets semble aider un peu:

GC.Collect()
GC.WaitForPendingFinalizers()
GC.Collect()

Dans mon expérience personnelle, en utilisant une combinaison de ReleaseComObject et manuellement l'appel de la collecte des ordures grandement réduit l'utilisation de la mémoire de produits Office, plus particulièrement Excel.

La réponse courte est: jamais!!!!

Il y a des situations où il vaut mieux prévenir que guérir.

Ici est un exemple de situation.

Il est possible de créer un non géré une DLL en C# à l'aide de l'IL réécrit (parce qu'il y a des situations où cela est nécessaire).

Maintenant, supposons, par exemple, la DLL crée un tableau d'octets au niveau de la classe - parce que beaucoup de fonctions exportées ont besoin d'accéder à ces. Ce qui se passe lorsque la DLL est déchargée? Est le garbage collector qui est automatiquement appelé à ce point? Je ne sais pas, mais étant non géré DLL il est tout à fait possible de le GC n'est pas appelé. Et ce serait un gros problème si elle n'était pas appelée. Lorsque la DLL est déchargée aussi être le garbage collector - alors, qui va être responsable de la collecte des éventuels déchets et comment pourraient-ils le faire? Préférable de faire appel à C#'s garbage collector. Ont une fonction de nettoyage (disponible à la DLL du client) où le niveau de la classe de variables sont null et le garbage collector appelé.

Mieux sécurisé que désolé.

Scott Holden l'entrée de blog sur les cas où (et quand) appel GC.Recueillir est spécifique à la .NET Compact Framework, mais les règles qui s'appliquent généralement à tous gérés de développement.

Ce n'est pas la question, mais pour XSLT transforme en .NET (XSLCompiledTranform) alors vous n'avez pas le choix. Un autre candidat est le contrôle MSHTML.

une bonne raison pour appeler GC est sur les petits BRAS ordinateurs avec peu de mémoire, comme le Raspberry PI (en cours d'exécution avec mono).
Si non alloué de la mémoire des fragments d'utiliser trop de la RAM du système, puis le système d'exploitation Linux peut se instable.
J'ai une application dans laquelle j'ai appeler GC chaque seconde (!) pour se débarrasser des problèmes de débordement de la mémoire.

Une autre bonne solution est de disposer d'objets lorsqu'ils ne sont plus nécessaires. Malheureusement, ce n'est pas si facile, dans de nombreux cas.