วิธีที่เหมาะสมในการตรวจสอบค่าว่างคืออะไร?

ฉันชอบตัวดำเนินการการรวมกันเป็นโมฆะเพราะทำให้ง่ายต่อการกำหนดค่าเริ่มต้นสำหรับประเภทที่ว่าง

 int y = x ?? -1;

ที่ดี xแต่ถ้าฉันต้องทำบางสิ่งบางอย่างที่เรียบง่ายด้วย ตัวอย่างเช่นถ้าฉันต้องการตรวจสอบSessionฉันมักจะต้องเขียนอะไรที่ละเอียดกว่านี้

ฉันหวังว่าฉันจะทำได้:

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

แต่คุณทำไม่ได้เนื่องจาก.ToString()ถูกเรียกก่อนการตรวจสอบค่าว่างจึงล้มเหลวหากSession["key"]เป็นโมฆะ ฉันจะทำสิ่งนี้:

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

มันใช้งานได้และดีกว่าในความคิดของฉันมากกว่าทางเลือกสามบรรทัด:

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

แม้ว่าจะได้ผล แต่ฉันก็ยังอยากรู้ว่ามีวิธีที่ดีกว่านี้หรือไม่ ดูเหมือนว่าไม่ว่าอะไรก็ตามที่ฉันต้องอ้างอิงSession["key"]สองครั้งเสมอ หนึ่งครั้งสำหรับการตรวจสอบและอีกครั้งสำหรับงานที่มอบหมาย ความคิดใด ๆ ?

แล้ว

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

หากคุณทำสิ่งนี้บ่อยโดยเฉพาะToString()คุณสามารถเขียนวิธีการขยาย:

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

...

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

หรือวิธีการที่เป็นค่าเริ่มต้นแน่นอน:

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

...

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

คุณยังสามารถใช้asซึ่งให้ผลnullหากการแปลงล้มเหลว:

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

นี้จะกลับมา"none"แม้ว่าบางคนยัดในintSession["key"]

หากเป็นเสมอstringคุณสามารถส่ง:

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

นี้มีประโยชน์บ่นแทนจากที่ซ่อนความผิดพลาดถ้ามีคนยัดหรือสิ่งที่อยู่ในint Session["key"];)

วิธีแก้ปัญหาที่แนะนำทั้งหมดนั้นดีและตอบคำถามได้ ดังนั้นนี่เป็นเพียงการขยายออกไปเล็กน้อย ปัจจุบันคำตอบส่วนใหญ่จัดการเฉพาะการตรวจสอบความถูกต้องและประเภทสตริงเท่านั้น คุณสามารถขยายStateBagวัตถุเพื่อรวมGetValueOrDefaultวิธีการทั่วไปคล้ายกับคำตอบที่โพสต์โดย Jon Skeet

วิธีการขยายทั่วไปอย่างง่ายที่ยอมรับสตริงเป็นคีย์จากนั้นพิมพ์ตรวจสอบวัตถุเซสชัน ถ้าออบเจ็กต์เป็นโมฆะหรือไม่ใช่ประเภทเดียวกันค่าดีฟอลต์จะถูกส่งกลับไม่เช่นนั้นค่าเซสชันจะถูกพิมพ์อย่างรุนแรง

อะไรทำนองนี้

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

เราใช้วิธีที่เรียกว่าNullOr.

การใช้

// 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());

แหล่ง

/// <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();
    }
}

สิ่งที่ฉันต้องการคือการใช้เซฟคาสต์กับสตริงในกรณีที่วัตถุที่เก็บด้วยคีย์ไม่ใช่วัตถุ การใช้ToString()อาจไม่ได้ผลลัพธ์ที่คุณต้องการ

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

ดังที่ @Jon Skeet กล่าวถ้าคุณพบว่าตัวเองใช้วิธีนี้เป็นจำนวนมากหรือดีกว่า แต่อาจเป็นวิธีการขยายร่วมกับคลาส SessionWrapper ที่พิมพ์อย่างรุนแรง แม้ว่าจะไม่มีวิธีการขยาย แต่ Wrapper ที่พิมพ์แน่นหนาก็อาจเป็นความคิดที่ดี

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

ใช้เป็น

 var session = new SessionWrapper(Session);

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

สร้างฟังก์ชันเสริม

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


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

คำตอบของ Skeet นั้นดีที่สุด - โดยเฉพาะฉันคิดว่าเขา ToStringOrNull()ค่อนข้างสง่างามและเหมาะกับความต้องการของคุณมากที่สุด ฉันต้องการเพิ่มอีกหนึ่งตัวเลือกในรายการวิธีการขยาย:

ส่งคืนวัตถุดั้งเดิมหรือค่าสตริงเริ่มต้นสำหรับnull :

// 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");

ใช้varสำหรับค่าที่ส่งคืนเนื่องจากจะกลับมาเป็นประเภทอินพุตดั้งเดิมเป็นสตริงเริ่มต้นเมื่อnull

นี่คือ "ตัวดำเนินการเอลวิส" ที่ปลอดภัยสำหรับรุ่นของ. NET ที่ไม่รองรับ?

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

อาร์กิวเมนต์แรกคือวัตถุที่ทดสอบ ประการที่สองคือฟังก์ชัน และที่สามคือค่า null ดังนั้นสำหรับกรณีของคุณ:

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

มันมีประโยชน์มากสำหรับประเภทที่เป็นโมฆะด้วย ตัวอย่างเช่น:

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