Impact de Multiple .ToUpper() 'ing

Question

Il ne s'agit pas d'une optimisation prématurée en soi. Sur le garbage collector et la mémoire en général, que feraient des centaines d'opérations (beaucoup pourraient être dupliquées) à un programme, principalement en ce qui concerne l'immuabilité des chaînes de caractères?

Answer 1

Chaque appel à ToUpper créera une nouvelle instance de chaîne, même si le contenu est identique à l'original et même si la chaîne existe déjà en tant que chaîne de caractères interne. Par conséquent, l'impact de centaines d'appels ToUpper est que vous créez des centaines d'instances de chaîne. Si les chaînes sont courtes, ce n'est pas un problème, surtout si vous n'utilisez que les chaînes pendant une courte période. Le ramasse-miettes est conçu pour gérer efficacement de petits objets de courte durée.

Exemple:

// Interned string literals are the same instance: 
string a = "asdf"; 
string b = "asdf"; 
Console.WriteLine(Object.ReferenceEquals(a, b)); // True 

// ToUpper naturally creates a new instance if the content is changed: 
string c = b.ToUpper(); 
Console.WriteLine(Object.ReferenceEquals(b, c)); // False 

// ToUpper creates a new instance even if the content is unchanged: 
string d = c.ToUpper(); 
Console.WriteLine(Object.ReferenceEquals(c, d)); // False 

// ToUpper will not intern strings: 
string e = "ASDF"; 
string f = e.ToUpper(); 
Console.WriteLine(Object.ReferenceEquals(e, f)); // False 

// Dynamically created strings can be interned manually: 
string g = String.Intern(f); 
Console.WriteLine(Object.ReferenceEquals(e, g)); // True 

Answer 2

Chaque appel .ToUpper() crée une nouvelle chaîne. Ainsi, des appels supplémentaires sont définitivement inefficaces. Il est prudent et professionnel d'essayer de minimiser autant d'appels inutiles et dupliqués que possible.

string Nacho = "cheesy" 
Nacho = Nacho.ToUpper() 
Nacho = Nacho.Trim().ToUpper() 

. . . crée beaucoup de déchets de chaîne. Cependant, si ce code n'a pas besoin d'être extrêmement rapide, vous n'avez pas besoin d'être trop paranoïaque. Bien que chacune de ces chaînes orphelines doive être collectée, ces petites chaînes locales sont presque toujours récupérées dans les collections partielles du GC, et la mémoire est renvoyée très rapidement. Assurez-vous que vos chaînes sont déclarées dans la portée la plus limitée possible (par exemple, dans une routine plutôt que dans la classe).

Answer 3

Des centaines? Presque rien dans la plupart des cas, en supposant qu'ils ne sont pas des chaînes énormes et que vous avez une quantité raisonnable de mémoire. Des centaines de millions pourraient bien avoir un impact.

Fondamentalement, chaque appel devra créer une nouvelle chaîne (je ne ai pas pense .NET détecte que c'est déjà majuscule). À moins que ce soit la majeure partie de ce que vous faites, je ne m'attendrais pas à ce que ce soit un goulot d'étranglement - mais le profilage aidera à vérifier cela.