?? Coalesce na pusty sznurek?

Coś, co robię coraz częściej, to sprawdzanie ciągu znaków pod kątem pustego (jak in ""lub null) i operatora warunkowego.

Aktualny przykład:

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

To jest tylko metoda rozszerzenia, jest odpowiednikiem:

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

Ponieważ jest pusty i nie jest pusty, ??nie załatwi sprawy. string.IsNullOrEmpty()Wersja ??byłoby idealnym rozwiązaniem. Myślę, że musi być na to czystszy sposób (mam nadzieję!), Ale nie mogłem go znaleźć.

Czy ktoś zna lepszy sposób na zrobienie tego, nawet jeśli jest to tylko w .Net 4.0?

Nie ma na to wbudowanego sposobu. Możesz jednak sprawić, by metoda rozszerzenia zwracała ciąg lub wartość null, co pozwoliłoby na działanie operatora łączenia. Byłoby to jednak dziwne i osobiście wolę Twoje obecne podejście.

Ponieważ używasz już metody rozszerzającej, dlaczego nie utworzyć takiej, która zwraca wartość lub wartość domyślną:

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

C # już pozwala nam podstawiać wartości nullz ??. Potrzebujemy więc tylko rozszerzenia, które konwertuje pusty ciąg na null, a następnie używamy go w następujący sposób:

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

Klasa rozszerzenia:

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

Wiem, że to stare pytanie - ale szukałem odpowiedzi i żadne z powyższych nie pasowało do moich potrzeb, a także tego, z czego ostatecznie skorzystałem:

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

Stosowanie:

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

EDYCJA: Jeszcze bardziej zwarty sposób zapisu tej funkcji to:

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

Mam kilka rozszerzeń narzędzi, których lubię używać:

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

Edycja: Zainspirowany odpowiedzią sfsr , od teraz będę dodawać ten wariant do mojego zestawu narzędzi:

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

Być może nieco szybsza metoda rozszerzenia niż proponowana wcześniej:

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

Jedną z zalet operatora koalescencji zerowej jest to, że powoduje zwarcia. Gdy pierwsza część nie jest pusta, druga nie jest oceniana. Może to być przydatne, gdy powrót wymaga kosztownej operacji.

Skończyło się na:

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

Stosowanie:

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

Po prostu używam metody rozszerzenia NullIfEmpty, która zawsze zwraca wartość null, jeśli ciąg jest pusty, co pozwala? (Operator Null Coalescing) do normalnego użycia.

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

To pozwala? do normalnego użytku i sprawia, że ​​łańcuchy są łatwe do odczytania.

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

co powiesz na metodę rozszerzenia ciągu ValueOrDefault ()

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

or return null jeśli string jest Empty:

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

Nie próbowałem jednak tych rozwiązań.

Używam własnej metody rozszerzenia łańcucha Coalesce. Ponieważ ci tutaj używają LINQ i absolutnie marnują zasoby na czasochłonne operacje (używam go w ciasnych pętlach), udostępnię moje:

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

Myślę, że jest to dość proste i nie musisz nawet przejmować się pustymi wartościami łańcuchowymi. Użyj tego w ten sposób:

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

Często go używam. Jedna z tych "narzędziowych" funkcji, bez której nie możesz żyć po pierwszym użyciu :-)

Podoba mi się zwięzłość poniższej metody rozszerzenia QQQ, chociaż oczywiście operator lubi? byłoby lepiej. Ale możemy to zwiększyć, pozwalając na porównanie nie tylko dwóch, ale trzech łańcuchowych wartości opcji, z którymi od czasu do czasu trzeba sobie poradzić (patrz druga funkcja poniżej).

#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