?? Boş dize için birleşme?

Kendimi gittikçe daha fazla yaparken bulduğum bir şey, bir dizeyi boş (içinde ""veya boş) ve koşullu bir işleç için kontrol etmektir .

Mevcut bir örnek:

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

Bu sadece bir uzantı yöntemidir:

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

Boş olduğu ve boş ??olmadığı için hile yapmayacak. Bir string.IsNullOrEmpty()versiyonu ??mükemmel çözüm olacaktır. Bunu yapmanın daha temiz bir yolu olması gerektiğini düşünüyorum (umarım!), Ama onu bulmakta kayboldum.

Herkes sadece .Net 4.0'da olsa bile bunu yapmanın daha iyi bir yolunu biliyor mu?

Bunu yapmanın yerleşik bir yolu yok. Bununla birlikte, uzantı yönteminizin bir dize veya null döndürmesini sağlayabilirsiniz, bu da birleştirme operatörünün çalışmasına izin verir. Ancak bu garip olurdu ve ben şahsen mevcut yaklaşımınızı tercih ediyorum.

Zaten bir uzantı yöntemi kullandığınızdan, neden yalnızca değeri veya varsayılanı döndüren bir yöntem yapmıyorsunuz:

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

C # zaten değerleri nullile değiştirmemizi sağlar ??. Yani ihtiyacımız olan tek şey, boş bir dizeyi dönüştüren bir uzantı nullve bunu şu şekilde kullanıyoruz:

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

Uzantı sınıfı:

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

Bu eski bir soru olduğunu biliyorum - ama bir cevap arıyordum ve yukarıdakilerin hiçbiri benim ihtiyacım yanı sıra kullanarak sona erdi:

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

Kullanımı:

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

EDIT: Bu işlevi yazmanın daha da kompakt bir yolu şöyle olacaktır:

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

Kullanmak istediğim birkaç yardımcı program uzantısı var:

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

Düzenleme: sfsr'ın cevabından esinlenerek , şu andan itibaren bu varyantı araç kutuma ekleyeceğim:

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

Belki daha önce önerilenden biraz daha hızlı bir genişletme yöntemi:

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

Sıfır birleştirici operatörün avantajlarından biri, kısa devre yapmasıdır. İlk bölüm boş olmadığında, ikinci bölüm değerlendirilmez. Geri dönüş pahalı bir işlem gerektirdiğinde bu yararlı olabilir.

Sonunda:

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

Kullanımı:

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

Ben sadece dize izin veriyorsa boş her zaman null döndürecek bir NullIfEmpty uzatma yöntemi kullanın ?? (Boş Birleştirme Operatörü) normal olarak kullanılmalıdır.

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

Bu daha sonra izin verir ?? normal olarak kullanılmasını sağlar ve zincirin okunmasını kolaylaştırır.

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

ValueOrDefault () bir dize uzantısı yöntemi nasıl

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

veya dize Boş ise null değerini döndürür:

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

Yine de bu çözümleri denemedim.

Kendi dize Coalesce uzantısı yöntemi kullanıyorum. Burada olanlar LINQ kullanıyor ve zaman yoğun operasyonlar için mutlak kaynak israfı (sıkı döngülerde kullanıyorum), benim paylaşacağım:

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

Bence bu oldukça basit ve null dize değerleri ile uğraşmanıza bile gerek yok. Şöyle kullanın:

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

Onu çok kullanırım. İlk kez kullanmadan yaşayamayacağınız bu "faydalı" işlevlerden biri :-)

QQQTabii ki bir operatör olsa da, bunun için aşağıdaki uzatma yönteminin kısaca seviyorum? Daha iyi olurdu. Ancak bunu sadece iki değil üç dize seçenek değerinin karşılaştırılmasına izin vererek 1'e kadar yapabiliriz;

#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