Est-ce que .NET a un moyen de résoudre une chaîne nulle en String.Empty?

Question

J'ai une méthode d'une ligne qui résout une chaîne nulle à string.Empty que je pensais être utile comme méthode d'extension - mais je ne trouve pas de moyen utile de le faire. La seule façon de le voir utile est une méthode statique sur la classe de chaînes, car il est évident qu'elle ne peut pas être attribuée à une instance car l'instance est nulle, ce qui provoque une erreur de compilateur. [Edit: l'erreur du compilateur était due à une variable non initialisée, que j'ai mal interprétée]

J'ai pensé à l'ajouter à une classe d'aide mais cela ajoute juste une complexité inutile du point de vue de la découvrabilité.

Donc, cette question est en deux parties, je suppose:

1. Est-ce que le framework .NET ont construit dans le moyen de résoudre une chaîne vide à string.Empty qui est de notoriété publique que j'ai manqué quelque part le long de la façon?
2. Si ce n'est pas le cas, quelqu'un connaît-il un moyen d'ajouter cette méthode en tant qu'extension statique de la classe de chaînes?

Vive à l'avance

Edit:

D'accord, je pense que j'aurais été un peu plus clair - je suis déjà bien au courant de coallescing nulle et j'utilisais ce dans un endroit où j'ai une douzaine de cordes inspectées pour le calcul d'un code de hachage. Comme vous pouvez l'imaginer, 12 lignes de code se suivant étroitement et contenant la syntaxe null coallescing est une horreur, donc j'ai déplacé l'opération null coallescing sur une méthode pour faciliter les choses sur les yeux. Ce qui est parfait, cependant, ce serait une extension parfaite à l'objet chaîne:

int hashcode = 
FirstValue.ResolveNull().GetHashCode()^
SecondValue.ResolveNull().GetHashCode()^
... 

plus d'une douzaine de lignes est beaucoup plus facile à lire que:

int hashcode = 
(FirstValue ?? String.Empty).GetHashCode()^
(SecondValue ?? String.Empty).GetHashCode()^
... 

je courais dans les problèmes de compilateur lorsque Je ne déclare explicitement mes valeurs de chaîne comme nulle mais comptais sur l'implicite:

string s; 

Si toutefois, vous définissez explicitement:

string s = null; 

Vous pouvez appeler facilement:

s.ResolveNull(); 

Merci à tous pour vos commentaires.

Answer 1

La seule façon que je pouvais le voir être utile est une méthode statique de la classe de chaîne car il est évident qu'il ne peut pas être attribué à une instance car l'instance est null et cela provoquerait une erreur d'exécution.

Les méthodes d'extension C# 3.0 peuvent être appelées sur des récepteurs nuls (puisqu'elles sont statiques en pratique), mais se comportent comme des méthodes d'instance. Donc en faire une méthode d'extension.

Answer 2

Il suffit d'ajouter string.Empty à une variable de chaîne et vous serez garanti de ne plus jamais nulle

string a = null; 
string b = null + string.Empty; 
string c = "a" + string.Empty; 

(a == string.Empty).Dump(); // False 
(b == string.Empty).Dump(); // True 
(c == "a").Dump(); // True 

J'ai jeté cela dans LINQPad, où l '

le .dump() En regardant vos options ...

Cette technique

string b = null + string.Empty; 

génère

IL_0001: ldsfld  System.String.Empty 
IL_0006: dup   
IL_0007: brtrue.s IL_000F 
IL_0009: pop   
IL_000A: ldstr  "" 
IL_000F: stloc.0  

L'autre option populaire:

string b = null ?? string.empty 

génère

IL_0001: ldsfld  System.String.Empty 
IL_0006: stloc.0  

et ce

string b = null + ""; 

génère cette

IL_0001: ldstr  "" 
IL_0006: stloc.0  

Je suis en faveur encore

string b = null + ""; 

Mais vraiment, l'OMI, vous devriez juste être prêt à gérer les valeurs NULL lorsque vous digérez la chaîne

Answer 3

Je ne pense pas qu'il y ait quelque chose de construit pour cela . Ma première pensée, et ce que je fais souvent, est d'utiliser l'opérateur coalesce:

string s = null; 
string x = s ?? string.Empty; 

Answer 4

someExpressionInvolving (s ?? "");

Il n'y a pas de point être excité à propos string.Empty vs "" - il y a une différence négligeable:

Console.WriteLine(ReferenceEquals(string.Empty, "")); // true 

Answer 5

méthode d'extension:

public static class StringExtensions 
{ 
    public static String EmptyIfNull(this String instance) 
    { 
     return instance ?? String.Empty; 
    } 
} 

bien sûr, vous pouvez tout aussi facilement écrire instance ?? String.Empty dans des endroits où vous devez utiliser String.Empty au lieu de null.

Answer 6

string test = CouldReturnNull() ?? string.Empty; 

Answer 7

Je dirais que la mise en œuvre cela comme une méthode d'extension se sentirait un peu comme ce que nous appelons en Suède « pour se rendre à l'autre côté du ruisseau pour chercher de l'eau ». Quand je dois assurer que je reçois une chaîne vide au lieu de null je souvent juste concaténer avec string.Empty:

public void SomeMethod(string param) 
{ 
    string notNull = param + string.Empty; 
} 

Bien sûr, cela peut conduire à une instance de chaîne supplémentaire en cours de création, mais dans la plupart des situations réelles que je suis dans ce n'a pas été un problème.

Answer 8

Vous pouvez utiliser le ?? Operator (null-coalescing operator) en C# - c'est ce que vous voulez dire?Ou ai-je mal compris?

par ex.

string n = null; 
string y = n ?? String.Empty; 

y est = String.Empty;

Answer 9

string abc = s ?? string.Empty; 

Answer 10

Il n'y a pas de fonction intégrée pour cela. Mais vous pouvez écrire une petite méthode d'extension (ou un menthod statique) pour le type de chaîne avec une instruction comme:

return s ?? string.Emtpy;