Ce qui est plus rapide: clair de collection ou d'instancier de nouveaux
J'ai un certain nombre de génériques, listes dans mon code, qui ont des dizaines ou des centaines d'éléments.
Parfois j'ai besoin de remplir cette liste avec d'autres objets, donc, la question est: ce sera plus rapide, à l'appel Clear()
méthode ou la création d'un new List<T>()
?
- OMI StackOverflow experts n'est pas exactement "des inconnus sur internet". Si quelqu'un a déjà étudié la question, il sera en mesure de répondre facilement. Mais vous avez un bon point que si vous voulez savoir pour sûr, vous devez calculer vous-même.
- Jason, je crois, qu'il y a beaucoup de théorie, que je devrais savoir, pour n'importe quelle situation, non seulement pour mon cas.
- Je ne vois pas en quoi ça change un peu ma réponse: mesurer vous-même.
- Le problème est que la "théorie commune" dépend de beaucoup de facteurs, dont beaucoup dépendent de votre scénario d'utilisation. Sans en connaître beaucoup d'autres informations, il n'y a aucun moyen de dire qu'une version est meilleure que l'autre, comme ils l'ont différentes caractéristiques de performance - et chacun d'eux peut être mieux/plus rapide/utiliser moins de mémoire/etc dans des scénarios spécifiques.
- +1 parce que cette question est en demandant des réponses qui permettent aux gens de faire des estimations sur les résultats escomptés, même avant l'essai.
- S'il vous plaît dites-moi si je me trompe, mais si vous avez à "Effacer" les tableaux, très souvent, vous devez Effacer le tableau existant pas réaffecter les fonds. Je considère que la Collecte des Ordures un processus lent et je l'éviter dans ma critique pour les performances des applications.
- Connexes: what-are-the-key-differences-between-dictionary-clear-and-new
InformationsquelleAutor Mrimsh | 2012-06-05
Vous devez vous connecter pour publier un commentaire.
C'est impossible de répondre. Cela dépend vraiment de beaucoup de facteurs, y compris combien de temps la collection existe.
La meilleure option serait ici:
Profil de l'application, et de voir si cela est vraiment important. Il ne sera probablement pas faire de différence perceptible, dans ce cas, je préfère utiliser la méthode qui fait le plus de sens en termes de la façon dont vous pensez de cet objet.
Si il n'est question, écrire à la fois des jeux de code, et de mesurer la différence de vitesse (le cas échéant).
À partir d'un point de vue pratique, l'appel de
Clear()
ne sera pas réellement réduire la mémoire (utilisé par laList<T>
lui-même), qu'il ne recule pas devant la liste de la capacité, seulement élimine les valeurs contenues en son sein. La création d'une nouvelleList<T>
sera la cause d'une nouvelle liste à répartir, qui sera à son tour causer plus de dotations avec la croissance.Ceci, cependant, ne signifie pas qu'il sera plus lent - dans de nombreux cas, de la réaffectation sera plus rapide que vous êtes moins susceptibles de promouvoir les tableaux de grande taille en un accroissement de la collecte des ordures générations, qui à son tour peut garder la GC processus beaucoup plus rapide.
Sans connaître votre scénario précis et mesure dans un profiler, il n'y a aucun moyen de savoir qui est le meilleur à votre scénario.
Clear()
etnew List<T>
autant que GC et l'allocation de mémoire va.J'ai fait ce test:
Ma conclusion sur la base des résultats de mon ordinaire core i3 processeur:
Dans le cas de milliers d'éléments, il est préférable d'effacer la liste. Il est rapide et efficace en terme de mémoire.
Si la collecte a plus de 100 000 éléments - la réinitialisation devient de plus en plus attrayant. Si après avoir établi le profil que vous pensez qu'il y a un goulot d'étranglement ici, l'utiliser. Ré-initialisation sera très rapide, mais comme troisième méthode de test de la montre, l'avenir de la collecte des ordures sera aussi lent que juste la suppression de la liste.
Donc à réponse courte est: si vous n'avez pas profilé de votre application, utilisez
Clear
. Réutiliser les objets est bon. Si vous ne les avez - vous déjà savoir quoi faire.Cela va dépendre de beaucoup de facteurs, et dans le long terme, il ne sera probablement pas question (assez pour compter) dans votre programme.
De la msdn docs
.Clear()
est un O(n) opérations.De l'initialisation d'une nouvelle instance aura ses propres frais généraux ainsi que (si vous gardez la collection de la même longueur, un O(n) opération: c'est à dire n
Add()
appels).Vraiment le seul moyen de tester cela est de mettre en place des chronomètres dans votre programme et voir ce que l'effet en est si vous pensez vraiment cela vaut le détour. Selon toute vraisemblance, ce n'est pas la peine.
Ma pensée serait que si vous avez déjà créé une collection,
Clear()
, c'est pourquoi il y a unClear()
méthode en premier lieu.Même si cela peut être frustrant, la réponse est vraiment qu'il ne devrait pas d'importance. La différence de temps entre les deux va être si faible qu'il ne sera probablement pas faire une différence pour votre application. Faire ce qui conduit à plus propre, plus compréhensible code, et essayez de ne pas programme pour les micro-optimisations.
Peut-être que je suis en train de faire quelque chose de fondamentalement mauvais ici, mais pendant le développement d'un ASP.NET application en C# je rencontre tout à fait une différence lors de l'utilisation de Clear() par rapport aux nouveaux.
Je suis de la création d'une page de statistiques avec des graphiques, qui ont des données de la série.
Pour chaque graphique, j'ai une section où je fais ceci:
puis un autre tableau qui suit.
Cela fonctionne bien avec
series
réaffectés avecnew
, mais quand je faisau lieu de cela j'ai fait l'entrée à l'intérieur
chart.Series
etchartistLineCharts
donc la page des statistiques finit par récupérer uniquement le dernier graphique de la série. Je suppose que il y a un lien, comme un pointeur de mémoire, ici, et c'est un problème différent que ce qui est à l'origine discutée, mais c'est au moins une raison de choisirnew
surClear()
. Peut-être il ya un moyen de l'éviter si..Clear
est la mutation de la référence d'origine, il peut avoir des répercussions à l'extérieur de la variable que vous êtes actuellement intéressés.Clear()
va supprimer tous les éléments, et de maintenir la capacité existante, alors que la création d'une nouvelle Liste aura besoin d'au moins une allocation dès le tas managé (peut-être plus que des éléments sont ajoutés si la capacité initiale est de petite taille).Si vous avez un grand nombre d'éléments et le nombre d'éléments est à peu près le même à chaque itération, puis à l'aide
Clear
est potentiellement un peu plus rapide.Si vous avez un nombre exceptionnellement élevé d'éléments sur une itération, puis un nombre beaucoup plus restreint sur les itérations suivantes, puis à l'aide
Clear
est potentiellement plus coûteux, parce que vous serez en gardant en mémoire une liste avec un inutilement de grande capacité.Bien sûr, dans de nombreux (la plupart?) les scénarios de la différence sera négligeable.
J'ai fait plusieurs tests pour moi-même. Les résultats (de vitesse) sont:
Mais à la fin, c'est mieux de le profil de l'application et de trouver les goulots d'étranglement pour l'ensemble de l'application.
Si vos objets de valeur sont les types que j'avais utiliser Clear() pour réduire la mémoire avenir allocations. Sinon, les deux approches sont presque identiques.