Comparer deux chaînes, en ignorant la casse en C #
Duplicate possible:
Quelle est la différence entre différentes méthodes de comparaison de chaînes
Lequel des deux suivants est le plus efficace? (Ou peut-être y a-t-il une troisième option qui est encore meilleure?)
string val = "AStringValue";
if (val.Equals("astringvalue", StringComparison.InvariantCultureIgnoreCase))
OR
if (val.ToLowerCase() == "astringvalue")
?
Le premier est le bon, et IMHO le plus efficace, puisque le second 'solution' instancie une nouvelle instance de chaîne.
Si vous recherchez l'efficacité, utilisez ceci:
string.Equals(val, "astringvalue", StringComparison.OrdinalIgnoreCase)
Les comparaisons ordinales peuvent être beaucoup plus rapides que les comparaisons tenant compte de la culture.
ToLowerCase peut être la meilleure option si vous faites beaucoup de comparaisons avec la même chaîne, cependant.
Comme pour toute optimisation de performance: mesurez-le, puis décidez!
La version .ToLowerCase ne sera pas plus rapide - elle implique une allocation de chaîne supplémentaire (qui doit ensuite être collectée), etc.
Personnellement, j'utiliserais
string.Equals(val, "astringvalue", StringComparison.OrdinalIgnoreCase)
cela évite tous les problèmes de chaînes sensibles à la culture, mais en conséquence, il évite tous les problèmes de chaînes sensibles à la culture. Seulement vous savez si cela vous convient dans votre contexte.
L'utilisation de la méthode string.Equals statique évite tout problème avec val étant null.
Ma réponse générale à ce type de question sur "l'efficacité" est presque toujours: quelle que soit la version du code la plus lisible, elle est la plus efficace.
Cela étant dit, je pense que (val.ToLowerCase() == "astringvalue") est assez compréhensible d'un coup d'œil par la plupart des gens.
L’efficacité à laquelle je me réfère n’est pas nécessairement liée à l’exécution du code, mais bien à la maintenance et à la lisibilité générale du code en question.
J'oserais dire que le plus sûr est d'utiliser String.Equals pour atténuer la possibilité que val soit null.
Le premier est le plus rapide. Il s'avère que val est immuable, et un nouvel objet string est créé avec String.ToLowerCase (), plutôt qu'une simple comparaison directe avec le comparateur de chaînes. La création d'un nouvel objet chaîne peut être coûteuse si vous le faites plusieurs fois par seconde.
1st est plus efficace (et la meilleure option possible) car val.ToLowerCase() crée un nouvel objet puisque les chaînes sont immuables.
vous voudrez peut-être aussi regarder la question déjà répondue Différences dans les méthodes de comparaison de chaînes en C #