Boş değerleri kontrol etmenin doğru yolu nedir?

Boş birleştirme operatörünü seviyorum çünkü null yapılabilir türler için varsayılan bir değer atamayı kolaylaştırıyor.

 int y = x ?? -1;

Basit bir şey yapmam gerekmedikçe bu harika x. Örneğin, kontrol etmek istersem Session, genellikle daha ayrıntılı bir şeyler yazmak zorunda kalırım.

Keşke bunu yapabilseydim:

string y = Session["key"].ToString() ?? "none";

Ama yapamazsınız çünkü .ToString()null kontrolden önce çağrılır, bu yüzden Session["key"]null ise başarısız olur . Bunu yapıyorum:

string y = Session["key"] == null ? "none" : Session["key"].ToString();

Bence işe yarıyor ve üç satırlık alternatiften daha iyi:

string y = "none";
if (Session["key"] != null)
    y = Session["key"].ToString();

Bu işe yarasa da daha iyi bir yol olup olmadığını hala merak ediyorum. Neye her zaman Session["key"]iki kez başvurmak zorunda olduğum önemli değil gibi görünüyor ; bir kez kontrol için ve tekrar ödev için. Herhangi bir fikir?

Ne dersin

string y = (Session["key"] ?? "none").ToString();

Bunu sık sık özellikleToString() yapıyorsanız , bir uzatma yöntemi yazabilirsiniz:

public static string NullPreservingToString(this object input)
{
    return input == null ? null : input.ToString();
}

...

string y = Session["key"].NullPreservingToString() ?? "none";

Ya da elbette varsayılanı alan bir yöntem:

public static string ToStringOrDefault(this object input, string defaultValue)
{
    return input == null ? defaultValue : input.ToString();
}

...

string y = Session["key"].ToStringOrDefault("none");

Ayrıca kullanabilirsiniz as, hangi verim nulldönüşüm başarısız olursa:

Session["key"] as string ?? "none"

Bu dönecekti "none"birisi bir dolma bile intin Session["key"].

Her zaman bir olacaksa string, şunları yapabilirsiniz:

string y = (string)Session["key"] ?? "none";

Bu, birisi bir intşey doldurursa, hatayı gizlemek yerine şikayet etme avantajına sahiptir Session["key"]. ;)

Önerilen tüm çözümler iyidir ve soruyu yanıtlar; bu yüzden bu sadece onu biraz genişletmek içindir. Şu anda yanıtların çoğu yalnızca boş doğrulama ve dize türleriyle ilgilenir. StateBagNesneyi GetValueOrDefault, Jon Skeet tarafından gönderilen cevaba benzer şekilde genel bir yöntemi içerecek şekilde genişletebilirsiniz .

Bir dizeyi anahtar olarak kabul eden ve ardından yazılan basit bir genel uzantı yöntemi, oturum nesnesini kontrol eder. Nesne boşsa veya aynı türde değilse, varsayılan döndürülür, aksi takdirde oturum değeri güçlü bir şekilde yazılan döndürülür.

Bunun gibi bir şey

/// <summary>
/// Gets a value from the current session, if the type is correct and present
/// </summary>
/// <param name="key">The session key</param>
/// <param name="defaultValue">The default value</param>
/// <returns>Returns a strongly typed session object, or default value</returns>
public static T GetValueOrDefault<T>(this HttpSessionState source, string key, T defaultValue)
{
    // check if the session object exists, and is of the correct type
    object value = source[key]
    if (value == null || !(value is T))
    {
        return defaultValue;
    }

    // return the session object
    return (T)value;
}

Adlı bir yöntem kullanıyoruz NullOr.

kullanım

// Call ToString() if it’s not null, otherwise return null
var str = myObj.NullOr(obj => obj.ToString());

// Supply default value for when it’s null
var str = myObj.NullOr(obj => obj.ToString()) ?? "none";

// Works with nullable return values, too —
// this is properly typed as “int?” (nullable int)
// even if “Count” is just int
var count = myCollection.NullOr(coll => coll.Count);

// Works with nullable input types, too
int? unsure = 47;
var sure = unsure.NullOr(i => i.ToString());

Kaynak

/// <summary>Provides a function delegate that accepts only value types as return types.</summary>
/// <remarks>This type was introduced to make <see cref="ObjectExtensions.NullOr{TInput,TResult}(TInput,FuncStruct{TInput,TResult})"/>
/// work without clashing with <see cref="ObjectExtensions.NullOr{TInput,TResult}(TInput,FuncClass{TInput,TResult})"/>.</remarks>
public delegate TResult FuncStruct<in TInput, TResult>(TInput input) where TResult : struct;

/// <summary>Provides a function delegate that accepts only reference types as return types.</summary>
/// <remarks>This type was introduced to make <see cref="ObjectExtensions.NullOr{TInput,TResult}(TInput,FuncClass{TInput,TResult})"/>
/// work without clashing with <see cref="ObjectExtensions.NullOr{TInput,TResult}(TInput,FuncStruct{TInput,TResult})"/>.</remarks>
public delegate TResult FuncClass<in TInput, TResult>(TInput input) where TResult : class;

/// <summary>Provides extension methods that apply to all types.</summary>
public static class ObjectExtensions
{
    /// <summary>Returns null if the input is null, otherwise the result of the specified lambda when applied to the input.</summary>
    /// <typeparam name="TInput">Type of the input value.</typeparam>
    /// <typeparam name="TResult">Type of the result from the lambda.</typeparam>
    /// <param name="input">Input value to check for null.</param>
    /// <param name="lambda">Function to apply the input value to if it is not null.</param>
    public static TResult NullOr<TInput, TResult>(this TInput input, FuncClass<TInput, TResult> lambda) where TResult : class
    {
        return input == null ? null : lambda(input);
    }

    /// <summary>Returns null if the input is null, otherwise the result of the specified lambda when applied to the input.</summary>
    /// <typeparam name="TInput">Type of the input value.</typeparam>
    /// <typeparam name="TResult">Type of the result from the lambda.</typeparam>
    /// <param name="input">Input value to check for null.</param>
    /// <param name="lambda">Function to apply the input value to if it is not null.</param>
    public static TResult? NullOr<TInput, TResult>(this TInput input, Func<TInput, TResult?> lambda) where TResult : struct
    {
        return input == null ? null : lambda(input);
    }

    /// <summary>Returns null if the input is null, otherwise the result of the specified lambda when applied to the input.</summary>
    /// <typeparam name="TInput">Type of the input value.</typeparam>
    /// <typeparam name="TResult">Type of the result from the lambda.</typeparam>
    /// <param name="input">Input value to check for null.</param>
    /// <param name="lambda">Function to apply the input value to if it is not null.</param>
    public static TResult? NullOr<TInput, TResult>(this TInput input, FuncStruct<TInput, TResult> lambda) where TResult : struct
    {
        return input == null ? null : lambda(input).Nullable();
    }
}

Bir kereye mahsus tercihim, anahtarla depolanan nesnenin bir olmaması durumunda dizeye güvenli bir atama kullanmak olacaktır. Kullanmak ToString()istediğiniz sonuçları vermeyebilir.

var y = Session["key"] as string ?? "none";

@Jon Skeet'in dediği gibi, eğer bunu çok fazla bir uzatma yöntemi veya daha iyisi, güçlü bir şekilde yazılmış bir SessionWrapper sınıfı ile birlikte bir uzatma yöntemi yaparken bulursanız. Uzantı yöntemi olmasa bile, güçlü bir şekilde yazılmış sarmalayıcı iyi bir fikir olabilir.

public class SessionWrapper
{
    private HttpSessionBase Session { get; set; }

    public SessionWrapper( HttpSessionBase session )
    {
        Session = session;
    }

    public SessionWrapper() : this( HttpContext.Current.Session ) { }

    public string Key
    {
         get { return Session["key"] as string ?? "none";
    }

    public int MaxAllowed
    {
         get { return Session["maxAllowed"] as int? ?? 10 }
    }
}

Olarak kullanıldı

 var session = new SessionWrapper(Session);

 string key = session.Key;
 int maxAllowed = session.maxAllowed;

yardımcı bir işlev yaratmak

public static String GetValue( string key, string default )
{
    if ( Session[ key ] == null ) { return default; }
    return Session[ key ].toString();
}


string y = GetValue( 'key', 'none' );

Skeet'in cevabı en iyisidir - özellikle de onun ToStringOrNull() oldukça zarif olduğunu ve ihtiyacınıza en uygun . Uzantı yöntemleri listesine bir seçenek daha eklemek istedim:

Null için orijinal nesneyi veya varsayılan dize değerini döndür :

// Method:
public static object OrNullAsString(this object input, string defaultValue)
{
    if (defaultValue == null)
        throw new ArgumentNullException("defaultValue");
    return input == null ? defaultValue : input;
}

// Example:
var y = Session["key"].OrNullAsString("defaultValue");

varDöndürülen değer için kullanın , çünkü orijinal girdinin türü olarak geri dönecektir, yalnızca varsayılan dize olaraknull

Bu, .NET'in?

public class IsNull
{
    public static O Substitute<I,O>(I obj, Func<I,O> fn, O nullValue=default(O))
    {
        if (obj == null)
            return nullValue;
        else
            return fn(obj);
    }
}

İlk argüman test edilen nesnedir. İkincisi, işlevdir. Üçüncüsü boş değerdir. Yani davanız için:

IsNull.Substitute(Session["key"],s=>s.ToString(),"none");

Null yapılabilir türler için de çok kullanışlıdır. Örneğin:

decimal? v;
...
IsNull.Substitute(v,v.Value,0);
....