c# - operator - ?? ¿Se unen para una cadena vacía?

operador null c#

Question

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

Un ejemplo actual:

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

Esto 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 hará el truco Una versión de string.IsNullOrEmpty() de ?? sería la solución perfecta. Estoy pensando que tiene que haber una manera más limpia de hacerlo (¡espero!), Pero no he podido encontrarlo.

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

Answer 1

¿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 devuelve 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.

Answer 2

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

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

Answer 3

Estoy usando un método de extensión Coalesce de cadena propio. Dado que los que están aquí están usando LINQ, y desperdiciando recursos por completo para operaciones que requieren mucho tiempo (lo estoy usando en bucles estrechos), 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 los valores de cadena nula. Ú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 :-)

Answer 4

Me gusta la brevedad del siguiente método de extensión QQQ para 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 opción de cadena, con lo que uno debe enfrentarse cada tanto (consulte 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

Answer 5

No hay una forma incorporada de hacer esto. Sin embargo, podría hacer que su método de extensión devuelva una cadena o nulo, lo que permitiría que el operador coalescente funcione. Sin embargo, esto sería extraño, y yo 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");

Answer 6

Sé que esta es una vieja pregunta, pero estaba buscando una respuesta y ninguna de las anteriores se ajustaba a mi necesidad, así como a 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));

Answer 7

Simplemente uso un método de extensión NullIfEmpty que siempre devolverá null si la cadena está vacía, lo que permite ?? (Operador coalescente nulo) para ser utilizado como normal.

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

Esto luego permite? para ser utilizado como normal y hace que el encadenamiento sea fácil de leer.

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

Answer 8

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 , a partir de ahora voy a 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));
}

Answer 9

Un método de extensión ligeramente más rápido que el propuesto anteriormente tal vez:

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

Answer 10

Una de las ventajas del operador de fusión nula es que provoca cortocircuitos. Cuando la primera parte no es nula, la segunda parte no se evalúa. Esto puede ser útil cuando la alternativa 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);