?? ¿Coalesce por una cadena vacía?

Algo que me encuentro haciendo más y más es verificar que una cadena esté vacía (como en ""o nula) y un operador condicional.

Un ejemplo actual:

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

Este es solo un método de extensión, es equivalente a:

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

Como está vacío y no es nulo, ??no funcionará. Una string.IsNullOrEmpty()versión de ??sería la solución perfecta. Estoy pensando que tiene que haber una forma más limpia de hacerlo (¡espero!), Pero no he podido encontrarlo.

¿Alguien sabe de una mejor manera de hacer esto, incluso si es solo en .Net 4.0?

No hay una forma integrada de hacer esto. Sin embargo, puede hacer que su método de extensión devuelva una cadena o un valor nulo, lo que permitiría que el operador de fusión funcione. Sin embargo, esto sería extraño, y personalmente prefiero su enfoque actual.

Como ya está utilizando un método de extensión, ¿por qué no hacer uno que devuelva el valor o un valor predeterminado?

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

C # ya nos permite sustituir valores por nullcon ??. Entonces, todo lo que necesitamos es una extensión que convierta una cadena vacía en null, y luego la usamos así:

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

Clase de extensión:

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

Sé que esta es una vieja pregunta, pero estaba buscando una respuesta y nada de lo anterior se ajustaba a mi necesidad, así como lo que terminé usando:

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

Uso:

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

EDITAR: Una forma aún más compacta de escribir esta función sería:

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

Tengo un par de extensiones de utilidad que me gusta usar:

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

Editar: Inspirado por la respuesta de sfsr, de ahora en adelante agregaré esta variante a mi caja de herramientas:

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

Un método de extensión un poco más rápido que el propuesto anteriormente quizás:

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

Una de las ventajas del operador de fusión nula es que cortocircuita. Cuando la primera parte no es nula, la segunda parte no se evalúa. Esto puede ser útil cuando la recuperación requiere una operación costosa.

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

Simplemente uso un método de extensión NullIfEmpty que siempre devolverá nulo si la cadena está vacía permitiendo ?? (Operador de fusión nula) que se utilizará normalmente.

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

Entonces esto permite ?? se usa normalmente y hace que el encadenamiento sea fácil de leer.

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

¿qué tal un método de extensión de cadena ValueOrDefault ()

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

o devolver nulo si la cadena está vacía:

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

Sin embargo, no probé estas soluciones.

Estoy usando un método de extensión Coalesce de cadena propio. Dado que los que están aquí están usando LINQ y están desperdiciando recursos para operaciones que requieren mucho tiempo (lo estoy usando en ciclos cerrados), compartiré el mío:

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

Creo que es bastante simple, y ni siquiera necesita molestarse con valores de cadena nulos. Úselo así:

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

Lo uso mucho. Una de esas funciones de "utilidad" sin las que no puedes vivir después de usarla por primera vez :-)

Me gusta la brevedad del siguiente método de extensión QQQpara esto, aunque, por supuesto, ¿un operador como? seria mejor. Pero podemos aumentar esto al permitir que se comparen no solo dos, sino tres valores de opciones de cadena, que encuentra la necesidad de manejar de vez en cuando (vea la segunda función a continuación).

#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