Hat .NET eine Möglichkeit, eine leere Zeichenfolge zu String.Empty lösen?

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

  •  12-09-2019
  •  | 
  •  

Frage

Ich habe eine einzeilige Methode, die eine Null-Zeichenfolge zu string.Empty löst die ich dachte, vielleicht als Erweiterung Methode nützlich sein -. Aber ich kann nicht eine nützliche Art und Weise macht es so finden

Der einzige Weg, ich sehe, könnte es nützlich sein, ist als statische Methode auf der String-Klasse, weil offensichtlich kann es nicht zu einer Instanz zugeschrieben werden, wie die Instanz null ist und dies führt zu einem Compiler-Fehler. [Edit: Compilerfehler war aufgrund nicht initialisierten Variablen, die ich falsch interpretiert]

Ich dachte darüber nach zu einer Hilfsklasse Hinzufügen aber das kommt noch hinzu, unnötige Komplexität von einem Auffindbarkeit Standpunkt aus.

Also diese Frage in zwei Teilen nehme ich an:

  1. Ist das .NET Framework eine eingebaute haben in Art und Weise eine leere Zeichenfolge zu string.Empty der Lösung, die allgemein bekannt ist, dass ich irgendwo auf dem Weg verpasst haben?
  2. Wenn dies nicht der Fall - nicht kennt jemand eine Möglichkeit, diese Methode als statische Erweiterung der String-Klasse hinzuzufügen
    3. ?

Prost im Voraus

Edit:

Okay, ich denke, ich sollte ein wenig mehr klar waren - ich bin schon sehr wohl bewusst null coallescing und ich wurde mit dieser an einem Ort, wo ich ein Dutzend oder so Saiten haben wird, für die Berechnung eines inspizierten Hash-Code.

Wie Sie sich vorstellen können, 12 Zeilen Code folgenden eng einander alle null coallescing Syntax enthält, ist ein Dorn im Auge, so zog ich die Null coallescing Operation, um ein Verfahren Dinge einfacher zu machen einfacher auf den Augen. Was perfekt ist, aber es wäre eine perfekte Ergänzung zu dem String-Objekt sein: 

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

über ein Dutzend Linie ist viel einfacher zu lesen als: 

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

Ich lief in Compiler Probleme, wenn ich nicht explizit meine String-Werte als null erklären, sondern verließ sich auf die implizite: 

 string s;

Wenn Sie jedoch explizit definiert werden: 

string s = null;

Sie können ganz einfach anrufen: 

s.ResolveNull();

Danke allen für Ihre Eingabe.

War es hilfreich?

Lösung

  

Der einzige Weg, ich sehe, könnte es nützlich sein, ist als statische Methode auf der String-Klasse, weil offensichtlich kann es nicht zu einer Instanz zugeschrieben werden, wie die Instanz null ist und dies einen Laufzeitfehler verursachen würde.

C # 3.0 Erweiterungsmethoden können auf null Empfänger genannt werden (da sie in der Praxis sind statisch), sondern als Instanzmethoden verhalten. So ist es nur machen eine Erweiterungsmethode.

Andere Tipps

Ich glaube nicht, dass es etwas für diese eingebaut. Mein erster Gedanke, und was ich tun oft, ist die coalesce Operator verwenden: 

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

someExpressionInvolving (s ?? "");

Es hat keinen Sinn, sich aufzuregen über string.Empty vs "" - es gibt vernachlässigbaren Unterschied: 

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

Erweiterungsmethode: 

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

Natürlich können Sie genauso einfach instance ?? String.Empty in Orte schreiben, wo Sie brauchen, anstatt null String.Empty zu verwenden. 

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

Sie können die Verwendung ?? Operator (null-Koaleszenz-Operator) in C # - ist das, was Sie meinen? Oder habe ich das falsch verstanden?

zB. 

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

y würde = String.Empty; 

string abc = s ?? string.Empty;

Ich würde sagen, dass dies als eine Erweiterung Verfahren implementiert ein bisschen fühlen würde, wie das, was wir in Schweden Anruf „auf die anderen Seite des Baches reisen Wasser zu holen“ . Wenn ich, um sicherzustellen, muss ich einen leeren String bekommen statt null oft ich verketten nur mit string.Empty: 

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

Sicher, dies zu einer zusätzlichen String-Instanz führen wird erstellt, aber in den meisten realen Situationen Ich habe in dieser gewesen war kein Problem.

Es gibt keine Build-in-Funktion dafür. Aber Sie können eine kleine Erweiterung Methode (oder eine statische menthod) für den String-Typen mit einer Aussage wie schreiben:

Rückkehr s ?? string.Emtpy;

Fügen Sie einfach string.Empty auf jeden String-Variable und Sie werden garantiert werden nie null bekommen 

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

Ich warf diese in LinqPad, daher der .dump () 's

Ein Blick auf Ihre Optionen ...

Diese Technik 

string b = null + string.Empty;

erzeugt 

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

Die andere beliebte Option: 

string b = null ?? string.empty

erzeugt 

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

und das 

string b = null + "";

erzeugt dieses 

IL_0001:  ldstr       ""
IL_0006:  stloc.0

ich immer noch bevorzugen 

string b = null + "";

Aber wirklich, IMO, sollten Sie nur bereit sein null zu handhaben, wenn Sie die Zeichenfolge verdauen

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top