webentwicklung-frage-antwort-db.com.de

?? Für leere Zeichenfolge verschmelzen?

Etwas, was ich immer öfter tue, ist, eine Zeichenfolge auf leer (wie in "" Oder null) und einen bedingten Operator zu prüfen.

Ein aktuelles Beispiel:

s.SiteNumber.IsNullOrEmpty() ? "No Number" : s.SiteNumber;

Dies ist nur eine Erweiterungsmethode, sie entspricht:

string.IsNullOrEmpty(s.SiteNumber) ? "No Number" : s.SiteNumber;

Da es leer und nicht null ist, reicht ?? Nicht aus. Eine string.IsNullOrEmpty() -Version von ?? Wäre die perfekte Lösung. Ich denke, es muss einen saubereren Weg dafür geben (hoffe ich!), Aber ich war ratlos, ihn zu finden.

Kennt jemand einen besseren Weg, um dies zu tun, auch wenn es nur in .Net 4.0 ist?

151
Nick Craver

Es gibt keine eingebaute Möglichkeit, dies zu tun. Sie können jedoch festlegen, dass Ihre Erweiterungsmethode eine Zeichenfolge oder null zurückgibt, wodurch der Koaleszenzoperator funktionieren kann. Dies wäre jedoch seltsam, und ich persönlich bevorzuge Ihren aktuellen Ansatz.

Da Sie bereits eine Erweiterungsmethode verwenden, können Sie eine erstellen, die den Wert oder einen Standardwert zurückgibt:

string result = s.SiteNumber.ConvertNullOrEmptyTo("No Number");
69
Reed Copsey

In C # können wir bereits Werte für null durch ?? Ersetzen. Wir brauchen also nur eine Erweiterung, die eine leere Zeichenfolge in null konvertiert, und dann verwenden wir sie wie folgt:

s.SiteNumber.NullIfEmpty() ?? "No Number";
117
RedFilter

Ich weiß, dass dies eine alte Frage ist - aber ich habe nach einer Antwort gesucht und keine der oben genannten Fragen passt zu meinem Bedarf und dem, was ich letztendlich verwendet habe:

private static string Coalesce(params string[] strings)
{
    return strings.FirstOrDefault(s => !string.IsNullOrEmpty(s));
}

Verwendung:

string result = Coalesce(s.SiteNumber, s.AltSiteNumber, "No Number");

EDIT: Eine noch kompaktere Art, diese Funktion zu schreiben, wäre:

static string Coalesce(params string[] strings) => strings.FirstOrDefault(s => !string.IsNullOrEmpty(s));
38
sfsr

Ich habe ein paar Utility-Erweiterungen, die ich gerne benutze:

public static string OrDefault(this string str, string @default = default(string))
{
    return string.IsNullOrEmpty(str) ? @default : str;
}

public static object OrDefault(this string str, object @default)
{
    return string.IsNullOrEmpty(str) ? @default : str;
}

Bearbeiten: Inspiriert durch die Antwort von sfsr füge ich diese Variante ab sofort zu meiner Toolbox hinzu:

public static string Coalesce(this string str, params string[] strings)
{
    return (new[] {str})
        .Concat(strings)
        .FirstOrDefault(s => !string.IsNullOrEmpty(s));
}
15
Justin Morgan

Eine etwas schnellere Erweiterungsmethode als früher vorgeschlagen:

public static string Fallback(this string @this, string @default = "")
{
    return (@this == null || @this.Trim().Length == 0) ? @default : @this;
}
6
Chilidog

Einer der Vorteile des Null-Koaleszenz-Operators besteht darin, dass er kurzschließt. Wenn der erste Teil nicht null ist, wird der zweite Teil nicht bewertet. Dies kann nützlich sein, wenn der Fallback einen teuren Vorgang erfordert.

Ich endete mit:

public static string Coalesce(this string s, Func<string> func)
{
    return String.IsNullOrEmpty(s) ? func() : s;
}

Verwendung:

string navigationTitle = model?.NavigationTitle.
    Coalesce(() => RemoteTitleLookup(model?.ID)). // Expensive!
    Coalesce(() => model?.DisplayName);
6
wensveen

Ich verwende einfach eine NullIfEmpty-Erweiterungsmethode, die immer null zurückgibt, wenn der String leer ist. (Null Coalescing Operator) wird wie gewohnt verwendet.

public static string NullIfEmpty(this string s)
{
    return s.IsNullOrEmpty() ? null : s;
}

Dies erlaubt dann ?? wird wie gewohnt verwendet und erleichtert das Ablesen der Verkettung.

string string1 = string2.NullIfEmpty() ?? string3.NullIfEmpty() ?? string4;
4
jjr2000

wie wäre es mit einer String-Erweiterungsmethode ValueOrDefault ()

public static string ValueOrDefault(this string s, string sDefault)
{
    if (string.IsNullOrEmpty(s))
        return sDefault;
    return s;
}

oder null zurückgeben, wenn der String leer ist:

public static string Value(this string s)
{
    if (string.IsNullOrEmpty(s))
        return null;
    return s;
}

Ich habe diese Lösungen jedoch nicht ausprobiert.

3
devio

Ich verwende eine eigene String-Coalesce-Erweiterungsmethode. Da die hier LINQ verwenden und Ressourcen für zeitintensive Vorgänge absolut verschwenden (ich verwende es in engen Schleifen), teile ich meine:

public static class StringCoalesceExtension
{
    public static string Coalesce(this string s1, string s2)
    {
        return string.IsNullOrWhiteSpace(s1) ? s2 : s1;
    }
}

Ich denke, es ist ganz einfach, und Sie müssen sich nicht einmal mit Null-String-Werten beschäftigen. Benutze es so:

string s1 = null;
string s2 = "";
string s3 = "loudenvier";
string s = s1.Coalesce(s2.Coalesce(s3));
Assert.AreEqual("loudenvier", s);

Ich benutze es oft. Eine dieser "Utility" -Funktionen, auf die Sie nicht verzichten können, nachdem Sie sie zum ersten Mal verwendet haben :-)

3
Loudenvier

Ich mag die Kürze der folgenden Erweiterungsmethode QQQ, obwohl natürlich ein Operator wie? wäre besser. Aber wir können dies verbessern, indem wir nicht nur zwei, sondern auch drei String-Optionswerte vergleichen lassen, bei denen man hin und wieder auf die Notwendigkeit stößt, damit umzugehen (siehe zweite Funktion unten).

#region QQ

[DebuggerStepThrough]
public static string QQQ(this string str, string value2)
{
    return (str != null && str.Length > 0)
        ? str
        : value2;
}

[DebuggerStepThrough]
public static string QQQ(this string str, string value2, string value3)
{
    return (str != null && str.Length > 0)
        ? str
        : (value2 != null && value2.Length > 0)
            ? value2
            : value3;
}


// Following is only two QQ, just checks null, but allows more than 1 string unlike ?? can do:

[DebuggerStepThrough]
public static string QQ(this string str, string value2, string value3)
{
    return (str != null)
        ? str
        : (value2 != null)
            ? value2
            : value3;
}

#endregion
0