วิธีที่ไม่ซ้ำในการใช้ตัวดำเนินการ Null Coalescing [ปิด]

ฉันรู้วิธีมาตรฐานในการใช้ตัวดำเนินการรวม Null ใน C # คือการตั้งค่าเริ่มต้น

string nobody = null;
string somebody = "Bob Saget";
string anybody = "";

anybody = nobody   ?? "Mr. T"; // returns Mr. T
anybody = somebody ?? "Mr. T"; // returns "Bob Saget"

แต่มีอะไรอีกบ้างที่สามารถ??ใช้เพื่อ? ดูเหมือนว่าจะไม่มีประโยชน์เท่าโอเปอร์เรเตอร์ที่ประกอบไปด้วยนอกจากจะกระชับและอ่านง่ายกว่า:

nobody = null;
anybody = nobody == null ? "Bob Saget" : nobody; // returns Bob Saget

เนื่องจากน้อยกว่าที่รู้เกี่ยวกับตัวดำเนินการรวมศูนย์ว่าง ...

• คุณเคยใช้??อย่างอื่นใช่ไหม

• เป็น??สิ่งที่จำเป็นหรือคุณก็ควรจะใช้ประกอบ ternary (ว่าส่วนใหญ่มีความคุ้นเคยกับ)

ก่อนอื่นเลยมันง่ายกว่าการเชื่อมโยงแบบมาตรฐานทั่วไป:

string anybody = parm1 ?? localDefault ?? globalDefault;

เมื่อเทียบกับ

string anyboby = (parm1 != null) ? parm1 
               : ((localDefault != null) ? localDefault 
               : globalDefault);

นอกจากนี้ยังทำงานได้ดีถ้าวัตถุที่เป็นไปได้ null ไม่ได้เป็นตัวแปร:

string anybody = Parameters["Name"] 
              ?? Settings["Name"] 
              ?? GlobalSetting["Name"];

เมื่อเทียบกับ

string anybody = (Parameters["Name"] != null ? Parameters["Name"] 
                 : (Settings["Name"] != null) ? Settings["Name"]
                 :  GlobalSetting["Name"];

ฉันเคยใช้เป็นสายการบินหนึ่งซับขี้เกียจ:

public MyClass LazyProp
{
    get { return lazyField ?? (lazyField = new MyClass()); }
}

สามารถอ่านได้? ตัดสินใจด้วยตัวเอง

ฉันพบว่ามีประโยชน์ในสองวิธี "แปลกเล็กน้อย":

• เป็นทางเลือกสำหรับการมีoutพารามิเตอร์เมื่อเขียนรูทีนTryParse(เช่นส่งคืนค่า null หากการแยกวิเคราะห์ล้มเหลว)
• ในฐานะตัวแทน "ไม่รู้" สำหรับการเปรียบเทียบ

หลังต้องการข้อมูลเพิ่มเติมเล็กน้อย โดยทั่วไปเมื่อคุณสร้างการเปรียบเทียบกับองค์ประกอบหลายรายการคุณต้องดูว่าส่วนแรกของการเปรียบเทียบ (เช่นอายุ) ให้คำตอบที่ชัดเจนจากนั้นส่วนถัดไป (เช่นชื่อ) เฉพาะในกรณีที่ส่วนแรกไม่ได้ช่วย การใช้ตัวดำเนินการรวมศูนย์ว่างหมายความว่าคุณสามารถเขียนการเปรียบเทียบที่ค่อนข้างง่าย (ไม่ว่าจะเป็นการสั่งซื้อหรือความเท่าเทียมกัน) ตัวอย่างเช่นการใช้คลาสตัวช่วยสองตัวในMiscUtil :

public int Compare(Person p1, Person p2)
{
    return PartialComparer.Compare(p1.Age, p2.Age)
        ?? PartialComparer.Compare(p1.Name, p2.Name)
        ?? PartialComparer.Compare(p1.Salary, p2.Salary)
        ?? 0;
}

เป็นที่ยอมรับตอนนี้ฉันมี ProjectionComparer ใน MiscUtil พร้อมด้วยส่วนขยายบางอย่างซึ่งทำให้สิ่งนี้ง่ายยิ่งขึ้น - แต่ก็ยังเรียบร้อย

เดียวกันสามารถทำได้สำหรับการตรวจสอบความเท่าเทียมกันอ้างอิง (หรือเป็นโมฆะ) ที่จุดเริ่มต้นของการดำเนินการเท่ากับ

ข้อดีอีกประการคือผู้ประกอบการที่ต้องใช้การประเมินสองครั้งหรือตัวแปรชั่วคราว

ลองพิจารณาสิ่งนี้เช่น:

string result = MyMethod() ?? "default value";

ขณะที่อยู่กับผู้ประกอบการที่คุณอยู่ด้วย:

string result = (MyMethod () != null ? MyMethod () : "default value");

ซึ่งเรียก MyMethod สองครั้งหรือ:

string methodResult = MyMethod ();
string result = (methodResult != null ? methodResult : "default value");

ไม่ว่าจะด้วยวิธีใดตัวดำเนินการรวมศูนย์ว่างจะสะอาดกว่าและฉันคิดว่ามีประสิทธิภาพมากกว่า

สิ่งที่ต้องพิจารณาอีกประการหนึ่งคือผู้ประกอบการรวมตัวกันไม่ได้เรียกวิธีการรับทรัพย์สินสองครั้งเช่นเดียวกับที่ประกอบไปด้วย

ดังนั้นจึงมีสถานการณ์ที่คุณไม่ควรใช้ไตรภาคเช่น:

public class A
{
    var count = 0;
    private int? _prop = null;
    public int? Prop
    {
        get 
        {
            ++count;
            return _prop
        }
        set
        {
            _prop = value;
        }
    }
}

ถ้าคุณใช้:

var a = new A();
var b = a.Prop == null ? 0 : a.Prop;

ทะเยอทะยานจะถูกเรียกสองครั้งและcountตัวแปรจะเท่ากับ 2 และถ้าคุณใช้:

var b = a.Prop ?? 0

countตัวแปรจะเท่ากับ 1 เท่าที่ควร

ข้อได้เปรียบที่ใหญ่ที่สุดที่ฉันพบกับ??โอเปอเรเตอร์คือคุณสามารถแปลงประเภทของค่าที่ไม่สามารถเปลี่ยนเป็นชนิดที่ไม่เป็นโมฆะได้อย่างง่ายดาย:

int? test = null;
var result = test ?? 0; // result is int, not int?

ฉันมักใช้สิ่งนี้ในการค้นหา Linq:

Dictionary<int, int?> PurchaseQuantities;
// PurchaseQuantities populated via ASP .NET MVC form.
var totalPurchased = PurchaseQuantities.Sum(kvp => kvp.Value ?? 0);
// totalPurchased is int, not int?

ฉันเคยใช้ ในการใช้งาน IDataErrorInfo ของฉัน:

public string Error
{
    get
    {
        return this["Name"] ?? this["Address"] ?? this["Phone"];
    }
}

public string this[string columnName]
{
    get { ... }
}

หากคุณสมบัติส่วนบุคคลใด ๆ อยู่ในสถานะ "ข้อผิดพลาด" ฉันได้รับข้อผิดพลาดนั้นมิฉะนั้นฉันจะได้รับ null ทำงานได้ดีจริงๆ

คุณสามารถใช้ตัวดำเนินการรวมศูนย์ว่างเปล่าเพื่อทำให้เป็นบิตที่สะอาดกว่าเพื่อจัดการเคสที่ไม่ได้ตั้งค่าพารามิเตอร์เพิ่มเติม:

public void Method(Arg arg = null)
{
    arg = arg ?? Arg.Default;
    ...

ฉันชอบที่จะใช้ตัวดำเนินการรวมศูนย์เป็นโมฆะเพื่อโหลดคุณสมบัติบางอย่าง

ตัวอย่างที่ง่ายมาก (และวางแผน) เพียงเพื่อแสดงให้เห็นถึงจุดของฉัน:

public class StackOverflow
{
    private IEnumerable<string> _definitions;
    public IEnumerable<string> Definitions
    {
        get
        {
            return _definitions ?? (
                _definitions = new List<string>
                {
                    "definition 1",
                    "definition 2",
                    "definition 3"
                }
            );
        }
    } 
}

คือ ?? จำเป็นหรือคุณควรใช้ผู้ประกอบการที่ประกอบไปด้วย (ที่คุ้นเคยกับ)

ที่จริงแล้วประสบการณ์ของฉันคือว่ามีคนไม่กี่คนที่คุ้นเคยกับผู้ประกอบการที่สาม (หรือมากกว่านั้นอย่างถูกต้องผู้ดำเนินการตามเงื่อนไข?:คือ " ผู้ประกอบการ" ในความหมายเดียวกับที่||เป็นเลขฐานสองหรือไม่คู่หรือ+ทั้งคู่ เฉพาะผู้ประกอบการที่ประกอบไปด้วยสามภาษา) อย่างน้อยในตัวอย่างที่ จำกัด คำสั่งของคุณจะล้มเหลว

นอกจากนี้ดังที่กล่าวไว้ก่อนหน้านี้มีสถานการณ์ที่สำคัญอย่างหนึ่งเมื่อตัวดำเนินการรวมศูนย์ว่างมีประโยชน์มากและนั่นคือเมื่อใดก็ตามที่นิพจน์ที่จะประเมินมีผลข้างเคียงใด ๆ เลย ในกรณีดังกล่าวคุณไม่สามารถใช้โอเปอเรเตอร์ที่มีเงื่อนไขโดยไม่มี (a) แนะนำตัวแปรชั่วคราวหรือ (b) เปลี่ยนตรรกะจริงของแอปพลิเคชัน (b) เห็นได้ชัดว่าไม่เหมาะสมในสถานการณ์ใด ๆ และในขณะที่เป็นการตั้งค่าส่วนตัวฉันไม่ชอบที่จะทำให้ขอบเขตการประกาศมีจำนวนมากเกินขอบเขตแม้ว่าตัวแปรอายุสั้นดังนั้นตัวแปร (a) ก็เช่นกัน สถานการณ์เฉพาะ

แน่นอนถ้าคุณต้องทำการตรวจสอบหลายครั้งเกี่ยวกับผลลัพธ์ตัวดำเนินการตามเงื่อนไขหรือชุดของifบล็อกอาจเป็นเครื่องมือสำหรับงาน แต่สำหรับง่ายๆ "ถ้านี่เป็นโมฆะให้ใช้วิธีนั้นมิฉะนั้นแล้วใช้มัน" ตัวดำเนินการรวมศูนย์ว่าง??จะสมบูรณ์แบบ

สิ่งหนึ่งที่ผมได้รับการทำมากเมื่อเร็ว ๆ นี้โดยใช้ coalescing null asสำหรับการสำรองข้อมูลเพื่อ ตัวอย่างเช่น:

object boxed = 4;
int i = (boxed as int?) ?? 99;

Console.WriteLine(i); // Prints 4

นอกจากนี้ยังมีประโยชน์ในการสำรองโซ่ยาว ๆ?.ที่อาจล้มเหลวได้

int result = MyObj?.Prop?.Foo?.Val ?? 4;
string other = (MyObj?.Prop?.Foo?.Name as string)?.ToLower() ?? "not there";

ปัญหาเพียงอย่างเดียวคือตัวดำเนินการ null-coalesce ไม่พบสตริงว่าง

กล่าวคือ

string result1 = string.empty ?? "dead code!";

string result2 = null ?? "coalesced!";

เอาท์พุท:

result1 = ""

result2 = coalesced!

ฉันกำลังมองหาที่เอาชนะ? ผู้ประกอบการที่จะหลีกเลี่ยงปัญหานี้ มันจะเป็นประโยชน์หากมีสิ่งนี้อยู่ใน Framework

คิด?

คือ ?? จำเป็นหรือคุณควรใช้ผู้ประกอบการที่ประกอบไปด้วย (ที่คุ้นเคยกับ)

คุณควรใช้สิ่งที่บ่งบอกความตั้งใจของคุณได้ดีที่สุด เนื่องจากมีเป็นผู้ประกอบการ null รวมกัน, ใช้มัน

ในทางกลับกันเนื่องจากเป็นผู้เชี่ยวชาญฉันจึงไม่คิดว่ามันมีประโยชน์อื่น ฉันต้องการเลือก||โอเปอเรเตอร์ที่เหมาะสมเช่นเดียวกับภาษาอื่น ๆ นี่จะเป็นการเพิ่มความสำคัญในการออกแบบภาษา แต่ ...

เย็น! นับฉันเป็นคนที่ไม่รู้เกี่ยวกับตัวดำเนินการรวมศูนย์ว่าง - นั่นเป็นสิ่งที่น่าสนใจ

ฉันพบว่าอ่านง่ายกว่าผู้ประกอบการที่ประกอบไปด้วย

สถานที่แรกที่นึกได้ว่าฉันควรใช้ที่ใดคือเก็บพารามิเตอร์เริ่มต้นไว้ในที่เดียว

public void someMethod( object parm2, ArrayList parm3 )
{ 
  someMethod( null, parm2, parm3 );
}
public void someMethod( string parm1, ArrayList parm3 )
{
  someMethod( parm1, null, parm3 );
}
public void someMethod( string parm1, object parm2, )
{
  someMethod( parm1, parm2, null );
}
public void someMethod( string parm1 )
{
  someMethod( parm1, null, null );
}
public void someMethod( object parm2 )
{
  someMethod( null, parm2, null );
}
public void someMethod( ArrayList parm3 )
{
  someMethod( null, null, parm3 );
}
public void someMethod( string parm1, object parm2, ArrayList parm3 )
{
  // Set your default parameters here rather than scattered through the above function overloads
  parm1 = parm1 ?? "Default User Name";
  parm2 = parm2 ?? GetCurrentUserObj();
  parm3 = parm3 ?? DefaultCustomerList;

  // Do the rest of the stuff here
}

บิตของกรณีการใช้งานที่แปลก แต่ฉันมีวิธีการที่IDisposableวัตถุอาจถูกส่งผ่านเป็น ARG (และถูกกำจัดโดยผู้ปกครอง) แต่อาจเป็นโมฆะ (และควรสร้างและกำจัดด้วยวิธีท้องถิ่น)

หากต้องการใช้งานรหัสก็ดูเหมือนว่า

Channel channel;
Authentication authentication;

if (entities == null)
{
    using (entities = Entities.GetEntities())
    {
        channel = entities.GetChannelById(googleShoppingChannelCredential.ChannelId);
        [...]
    }
}
else
{
    channel = entities.GetChannelById(googleShoppingChannelCredential.ChannelId);
    [...]
}

แต่ด้วยการรวมกันเป็นโมฆะกลายเป็น neater มาก

using (entities ?? Entities.GetEntities())
{
    channel = entities.GetChannelById(googleShoppingChannelCredential.ChannelId);
    [...]
}

ฉันเคยใช้สิ่งนี้:

for (int i = 0; i < result.Count; i++)
            {
                object[] atom = result[i];

                atom[3] = atom[3] ?? 0;
                atom[4] = atom[4] != null ? "Test" : string.Empty;
                atom[5] = atom[5] ?? "";
                atom[6] = atom[6] ?? "";
                atom[7] = atom[7] ?? "";
                atom[8] = atom[8] ?? "";
                atom[9] = atom[9] ?? "";
                atom[10] = atom[10] ?? "";
                atom[12] = atom[12] ?? false; 
            }