.NET a un moyen de résoudre une chaîne vide à String.Empty?

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

  •  12-09-2019
  •  | 
  •  

Question

J'ai une méthode d'une ligne qui résout une chaîne vide à string.Empty que je pensais peut-être utile en tant que méthode d'extension -. Mais je ne peux pas trouver un moyen utile de faire si

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ée à une instance comme l'instance est nulle, ce qui provoque une erreur de compilation. [Edit: Erreur de compilation est due à une variable non initialisée que je mal interprété]

Je pensais à l'ajouter à une classe d'aide mais juste ajoute une complexité inutile du point de vue de découvrir la preuve.

Je suppose donc cette question est en deux parties:

  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 du chemin?
  2. Si elle ne fonctionne pas - personne ne sait d'une façon d'ajouter cette méthode comme une extension statique de la classe string
    3. ?

Vive à l'avance

Edit:

D'accord, je suppose que je devrais avoir été un peu plus clair - je suis déjà bien au courant de coallescing nulle et que j'utilisais ce dans un endroit où j'ai une douzaine de chaînes inspectée pour le calcul d'une le code de hachage.

Comme vous pouvez l'imaginer, 12 lignes de code suivant de près les uns des autres tout contenant la syntaxe coallescing nulle est une source de pollution visuelle, alors je me suis déplacé l'opération de coallescing nulle sur une méthode pour faciliter les choses plus facile 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 du compilateur quand 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.

Était-ce utile?

La solution

  

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ée à une instance comme l'instance est nulle et cela provoquerait une erreur d'exécution.

C # 3.0 méthodes d'extension peuvent être appelés récepteurs nuls (car ils sont statiques dans la pratique), mais se comportent comme des méthodes d'instance. Il suffit donc de faire une méthode d'extension.

Autres conseils

Je ne pense pas qu'il y ait quoi que ce soit 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;

someExpressionInvolving (s ?? "");

Il n'y a pas de point encore plus hâte de string.Empty vs "" - il y a une différence négligeable: 

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

Méthode d'extension: 

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

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

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

Vous pouvez utiliser le ?? (Opérateur null-coalescent) en C # - est-ce que vous voulez dire? Ou ai-je mal compris?

par exemple. 

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

y aurait = String.Empty; 

string abc = s ?? string.Empty;

Je dirais que la mise en œuvre cela comme une méthode d'extension se sentirait un peu comme ce que nous appelons la 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 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 en cela n'a pas été un problème.

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

retour s ?? string.Emtpy;

Il suffit d'ajouter string.Empty à une variable chaîne et vous serez assuré 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

Je jeté cela dans LINQPad, d'où le .dump () s '

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 cette 

string b = null + "";

génère ce 

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

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