?? Coalesce pour une chaîne vide?

Quelque chose que je fais de plus en plus est de vérifier une chaîne pour vide (comme in ""ou null) et un opérateur conditionnel.

Un exemple actuel:

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

Ceci est juste une méthode d'extension, c'est équivalent à:

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

Comme il est vide et non nul, ??cela ne fera pas l'affaire. Une string.IsNullOrEmpty()version de ??serait la solution parfaite. Je pense qu'il doit y avoir un moyen plus propre de faire cela (j'espère!), Mais j'ai été incapable de le trouver.

Quelqu'un connaît-il une meilleure façon de faire cela, même si ce n'est que dans .Net 4.0?

Il n'y a pas de moyen intégré de le faire. Vous pouvez cependant faire en sorte que votre méthode d'extension renvoie une chaîne ou une valeur nulle, ce qui permettrait à l'opérateur de fusion de fonctionner. Ce serait étrange, cependant, et je préfère personnellement votre approche actuelle.

Puisque vous utilisez déjà une méthode d'extension, pourquoi ne pas en créer une qui renvoie la valeur ou une valeur par défaut:

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

C # nous permet déjà de remplacer des valeurs par nullavec ??. Donc, tout ce dont nous avons besoin est une extension qui convertit une chaîne vide en null, puis nous l'utilisons comme ceci:

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

Classe d'extension:

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

Je sais que c'est une vieille question - mais je cherchais une réponse et aucune des réponses ci-dessus ne correspondait à mes besoins ainsi qu'à ce que j'ai fini par utiliser:

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

Usage:

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

EDIT: Une manière encore plus compacte d'écrire cette fonction serait:

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

J'ai quelques extensions utilitaires que j'aime utiliser:

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

Edit: Inspiré par la réponse de sfsr , je vais désormais ajouter cette variante à ma boîte à outils:

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

Une méthode d'extension légèrement plus rapide que celle proposée précédemment peut-être:

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

L'un des avantages de l'opérateur à fusion nulle est qu'il court-circuite. Lorsque la première partie n'est pas nulle, la deuxième partie n'est pas évaluée. Cela peut être utile lorsque la solution de secours nécessite une opération coûteuse.

J'ai fini avec:

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

Usage:

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

J'utilise simplement une méthode d'extension NullIfEmpty qui retournera toujours null si la chaîne est vide permettant ?? (Null Coalescing Operator) à utiliser normalement.

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

Cela permet alors ?? à utiliser normalement et facilite la lecture du chaînage.

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

que diriez-vous d'une méthode d'extension de chaîne ValueOrDefault ()

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

ou retourne null si la chaîne est vide:

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

Je n'ai pas essayé ces solutions cependant.

J'utilise ma propre méthode d'extension de chaîne Coalesce. Puisque ceux-ci utilisent LINQ et gaspillent absolument des ressources pour des opérations gourmandes en temps (je l'utilise en boucles serrées), je vais partager le mien:

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

Je pense que c'est assez simple et que vous n'avez même pas besoin de vous soucier des valeurs de chaîne nulles. Utilisez-le comme ceci:

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

Je l'utilise beaucoup. Une de ces fonctions "utilitaires" dont vous ne pouvez pas vous passer après l'avoir utilisée pour la première fois :-)

J'aime la brièveté de la méthode d'extension suivante QQQpour cela, bien que bien sûr un opérateur comme? serait mieux. Mais nous pouvons augmenter cela en permettant non seulement de comparer deux mais trois valeurs d'options de chaîne, ce que l'on rencontre le besoin de gérer de temps en temps (voir la deuxième fonction ci-dessous).

#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