Coalesce vs concaténation de chaîne vide

StackOverflow https://stackoverflow.com/questions/416473

Question

Mon collègue est nouveau dans C # et ne connaissait pas l'opérateur de coalesce. Alors, je l'ai vu écrire une ligne de code comme ceci: 

string foo = "" + str;

L'idée étant que si str est null, cette expression renverrait une chaîne vide. Bien sûr, cela pourrait être réécrit comme ceci: 

string foo = str ?? "";

Et j'estime que cela serait plus lisible. Mais est-ce vraiment un si gros problème? Les avantages en termes de lisibilité sont-ils suffisants pour suggérer de revenir en arrière et de faire en sorte que ces lignes ressemblent à la seconde? Ou est-ce une de ces choses que je devrais apprendre à abandonner (à condition que mon collègue soit informé de la meilleure façon de le faire à l'avenir)?

MODIFIER : remarque: j'apprécie les commentaires sur l'efficacité, mais ils ne sont pas vraiment utilisés dans les situations où ces performances seraient critiques. Ainsi, bien que cette information soit intéressante, ce n'est pas nécessairement ce que je considère important.

Était-ce utile?

La solution

IMO, il est bien préférable de définir clairement une telle logique, c’est-à-dire, n'utilisez pas la concaténation de chaînes pour éviter une chaîne nulle et utilisez une instruction conditionnelle ou ?? opérateur.

En ce qui concerne les autres commentaires:

  

il y a aussi un avantage de performance à   en utilisant l'opérateur de coalescence nulle,   puisqu'aucune concaténation n'est nécessaire   (et, par conséquent, pas de chaîne supplémentaire   instance est en cours de création   inutilement)

Ce n'est pas vrai. Le compilateur C # compile " " + string2 au code à 100% identique à string1 ?? "" ;. De plus, le compilateur C # traduit l'opérateur + à appeler à la méthode string.Concat qui vérifie les arguments avec la fonction string.IsNullOrEmpty et n'alloue pas de nouvelle chaîne dans ce cas.

  

Aussi, je recommanderais l'utilisation de   String.Empty over " " comme c'est un   constante et ne nécessite pas la   création d'une nouvelle chaîne

Le framework .NET prend en charge les interner les chaînes afin que " " et string.Empty pointent vers la même région de mémoire

Autres conseils

Je ne pense pas que l'un soit plus lisible que l'autre personnellement. Je préfère ceci: 

string foo = str ?? "";

tout simplement parce que j'aime vraiment le ?? opérateur.

Si vous êtes un débutant, je pense que ce serait un peu plus facile à comprendre: 

string foo = str == null ? "" : str;

ou 

string foo = "";
if (str != null) foo = str;

Cependant, vous devez vous poser la question suivante: "Vous voulez vraiment être simple?"

Bien que je préfère la deuxième ligne du point de vue technique, la première ligne est en réalité plus lisible pour moi ...

La deuxième ligne me semble plus lisible, elle indique clairement l'intention de l'expression du côté droit.

Je préférerais que votre deuxième exemple soit le premier car il est plus proactif face à str qui est nul et qui est plus expressif. Aussi, je recommanderais l'utilisation de String.Empty par rapport à "" " car il s'agit d'une constante et ne nécessite pas la création d'un nouveau String. (et oui, c’est un nitpick extrême mais il est important de le noter).

J'utiliserais l'opérateur coalesce ou foo = str == null? " " : str; pour deux raisons:

  1. Le premier exemple n'a pas le même comportement dans d'autres langages à accolades (en particulier Java et JavaScript), où l'ajout d'une référence null à une chaîne vide donne une chaîne contenant le texte null . Par conséquent, le premier exemple nécessite beaucoup plus d'effort mental pour être sûr que le comportement dans la langue d'origine sera correct. Même en tenant compte d'autres indices, il s'agit de C # (tel que le type minuscule chaîne ), tout ce qui oblige le développeur à ralentir et à penser "quelle est l'intention de ce code" entraîne une perte de productivité. Cela pourrait également introduire des bugs lors du passage d'une langue à une autre.

  2. Le deuxième exemple exprime plus clairement l'intention du code, qui est décrit dans la question initiale comme suit:

    lorsque str est null, définissez foo sur une chaîne vide

    Contrairement au premier exemple, qui peut être lu comme suit:

    définit foo sur une chaîne vide avec str ajouté (ce qui peut avoir pour effet secondaire de définir foo sur une chaîne vide lorsque str est null)

En tant que programmeurs, nous devrions probablement essayer d’exprimer l’intention de notre code, plutôt que de nous fier aux effets secondaires d’autres opérations pour obtenir les résultats souhaités.

voici un article sur string.empty vs ""

"

http://blogs.msdn.com/brada /archive/2003/04/22/49997.aspx

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top