?? Coalesce per stringa vuota?

Qualcosa che mi ritrovo a fare sempre di più è il controllo di una stringa per vuoto (come in ""o null) e un operatore condizionale.

Un esempio attuale:

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

Questo è solo un metodo di estensione, è equivalente a:

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

Dal momento che è vuoto e non nullo, ??non farà il trucco. Una string.IsNullOrEmpty()versione di ??sarebbe la soluzione perfetta. Sto pensando che ci debba essere un modo più pulito di farlo (spero!), Ma non sono riuscito a trovarlo.

Qualcuno conosce un modo migliore per farlo, anche se è solo in .Net 4.0?

Non esiste un modo integrato per farlo. Tuttavia, è possibile che il metodo di estensione restituisca una stringa o null, che consentirebbe all'operatore di coalescenza di funzionare. Questo sarebbe strano, tuttavia, e personalmente preferisco il tuo approccio attuale.

Poiché stai già utilizzando un metodo di estensione, perché non crearne uno che restituisca il valore o un valore predefinito:

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

C # ci consente già di sostituire i valori nullcon ??. Quindi tutto ciò di cui abbiamo bisogno è un'estensione che converte una stringa vuota in null, e quindi la usiamo in questo modo:

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

Classe di estensione:

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

So che questa è una vecchia domanda, ma stavo cercando una risposta e nessuna delle precedenti è adatta alle mie esigenze e a ciò che ho finito per usare:

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

Uso:

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

EDIT: un modo ancora più compatto di scrivere questa funzione sarebbe:

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

Ho un paio di estensioni di utilità che mi piace usare:

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

Modifica: Ispirato dalla risposta di sfsr , aggiungerò questa variante alla mia cassetta degli attrezzi da ora in poi:

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

Un metodo di estensione leggermente più veloce di quello proposto forse in precedenza:

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

Uno dei vantaggi dell'operatore a coalescenza nulla è il cortocircuito. Quando la prima parte non è nulla, la seconda parte non viene valutata. Ciò può essere utile quando il fallback richiede un'operazione costosa.

Ho finito con:

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

Uso:

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

Uso semplicemente un metodo di estensione NullIfEmpty che restituirà sempre null se la stringa è vuota permettendo ?? (Null Coalescing Operator) da utilizzare normalmente.

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

Questo quindi permette ?? essere usato normalmente e rende il concatenamento di facile lettura.

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

che ne dite di un metodo di estensione stringa ValueOrDefault ()

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

o restituisce null se la stringa è vuota:

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

Non ho provato queste soluzioni però.

Sto usando un mio metodo di estensione Coalesce per stringa. Dal momento che quelli qui stanno usando LINQ e sprecando assolutamente risorse per operazioni che richiedono molto tempo (lo sto usando in cicli ristretti), condividerò il mio:

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

Penso che sia abbastanza semplice e non devi nemmeno preoccuparti di valori di stringa nulli. Usalo in questo modo:

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

Lo uso molto. Una di quelle funzioni di "utilità" di cui non puoi vivere senza averlo usato per la prima volta :-)

Mi piace la brevità del seguente metodo di estensione QQQper questo, anche se ovviamente un operatore piace? sarebbe meglio. Ma possiamo farcela 1 consentendo di confrontare non solo due ma tre valori di opzioni di stringa, che si incontrano la necessità di gestire di tanto in tanto (vedere la seconda funzione di seguito).

#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