?? Koaleszenz für leere Schnur?

Etwas, das ich immer mehr mache, ist das Überprüfen einer Zeichenfolge auf Leerzeichen (wie in ""oder null) und einen bedingten Operator.

Ein aktuelles Beispiel:

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

Dies ist nur eine Erweiterungsmethode, die entspricht:

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

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

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

Es gibt keine eingebaute Möglichkeit, dies zu tun. Sie können Ihre Erweiterungsmethode jedoch dazu bringen, eine Zeichenfolge oder null zurückzugeben, damit der Koaleszenzoperator arbeiten kann. Dies wäre jedoch seltsam, und ich persönlich bevorzuge Ihren derzeitigen 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");

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

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

Erweiterungsklasse:

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

Ich weiß, dass dies eine alte Frage ist - aber ich suchte nach einer Antwort und keine der oben genannten Fragen entsprach meinen Bedürfnissen 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));

Ich habe einige Dienstprogrammerweiterungen, die ich gerne verwende:

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 von der Antwort von sfsr werde ich diese Variante von nun an zu meiner Toolbox hinzufügen:

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

Eine etwas schnellere Verlängerungsmethode als früher vorgeschlagen:

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

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 ausgewertet. Dies kann nützlich sein, wenn der Fallback eine teure Operation erfordert.

Am Ende hatte ich:

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);

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

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

Dies ermöglicht dann? Wird wie gewohnt verwendet und ist leicht zu lesen.

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

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 geben Sie null zurück, wenn die Zeichenfolge 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.

Ich verwende eine eigene String-Coalesce-Erweiterungsmethode. Da die hier LINQ verwenden und Ressourcen für zeitintensive Operationen verschwenden (ich verwende es in engen Schleifen), werde ich meine teilen:

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. Verwenden Sie 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 nach der ersten Verwendung nicht mehr verzichten können :-)

Ich mag die Kürze der folgenden Erweiterungsmethode QQQdafür, obwohl natürlich ein Operator wie? wäre besser. Wir können dies jedoch verbessern, indem wir nicht nur zwei, sondern drei Zeichenfolgenoptionswerte vergleichen lassen, auf die hin und wieder verzichtet werden muss (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