Cara unik untuk menggunakan operator Null Coalescing [ditutup]

Saya tahu cara standar menggunakan operator penggabungan Null di C # adalah dengan menetapkan nilai default.

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

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

Tapi untuk apa lagi bisa ??digunakan? Tampaknya tidak berguna seperti operator ternary, selain lebih ringkas dan lebih mudah dibaca daripada:

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

Jadi mengingat bahwa lebih sedikit yang tahu tentang operator penggabungan nol ...

• Apakah Anda pernah menggunakan yang ??lain?

• Apakah ??diperlukan, atau jika Anda hanya menggunakan operator ternary (yang paling akrab dengan)

Pertama-tama, ini jauh lebih mudah untuk dirantai daripada terner standar:

string anybody = parm1 ?? localDefault ?? globalDefault;

vs.

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

Ini juga berfungsi dengan baik jika objek null-mungkin bukan variabel:

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

vs.

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

Saya telah menggunakannya sebagai pemuat satu baris yang malas:

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

Dibaca? Putuskan sendiri.

Saya menemukan ini berguna dalam dua cara "sedikit aneh":

• Sebagai alternatif untuk memiliki outparameter saat menulis TryParserutinitas (yaitu mengembalikan nilai nol jika parsing gagal)
• Sebagai representasi "tidak tahu" untuk perbandingan

Yang terakhir membutuhkan sedikit lebih banyak informasi. Biasanya ketika Anda membuat perbandingan dengan beberapa elemen, Anda perlu melihat apakah bagian pertama dari perbandingan (misalnya usia) memberikan jawaban yang pasti, kemudian bagian berikutnya (misalnya nama) hanya jika bagian pertama tidak membantu. Menggunakan operator penggabungan nol berarti Anda dapat menulis perbandingan yang cukup sederhana (baik untuk pemesanan atau kesetaraan). Misalnya, menggunakan beberapa kelas pembantu di 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;
}

Memang sekarang saya memiliki ProjectionComparer di MiscUtil, bersama dengan beberapa ekstensi, yang membuat hal semacam ini lebih mudah - tetapi masih rapi.

Hal yang sama dapat dilakukan untuk memeriksa kesetaraan referensi (atau nullity) pada awal penerapan Equals.

Keuntungan lain adalah bahwa operator ternary memerlukan evaluasi ganda atau variabel sementara.

Pertimbangkan ini, misalnya:

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

sementara dengan operator ternary Anda dibiarkan:

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

yang memanggil MyMethod dua kali, atau:

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

Either way, operator penggabungan nol lebih bersih dan, saya kira, lebih efisien.

Satu hal yang perlu dipertimbangkan adalah bahwa operator gabungan tidak memanggil metode get properti dua kali, seperti yang dilakukan ternary.

Jadi ada skenario di mana Anda tidak boleh menggunakan ternary, misalnya:

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

Jika Anda menggunakan:

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

pengambil akan dipanggil dua kali dan countvariabel akan sama dengan 2, dan jika Anda menggunakan:

var b = a.Prop ?? 0

yang countvariabel akan sama dengan 1, sebagaimana mestinya.

Keuntungan terbesar yang saya temukan kepada ??operator adalah Anda dapat dengan mudah mengkonversi tipe nilai yang dapat dibatalkan menjadi tipe yang tidak dapat dibatalkan:

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

Saya sering menggunakan ini dalam permintaan 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?

Saya sudah menggunakan ?? dalam implementasi IDataErrorInfo saya:

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

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

Jika ada properti individu dalam keadaan "kesalahan" saya mendapatkan kesalahan itu, kalau tidak saya akan null. Bekerja dengan sangat baik.

Anda dapat menggunakan operator penggabungan nol untuk membuatnya sedikit lebih bersih untuk menangani case di mana parameter opsional tidak diatur:

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

Saya suka menggunakan operator penggabungan nol untuk malas memuat properti tertentu.

Contoh yang sangat sederhana (dan dibuat-buat) hanya untuk mengilustrasikan poin saya:

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

Adalah ?? diperlukan, atau sebaiknya Anda hanya menggunakan operator ternary (yang paling akrab)

Sebenarnya, pengalaman saya adalah bahwa terlalu sedikit orang yang akrab dengan operator ternary (atau lebih tepatnya, operator kondisional ; ?:adalah "ternary" dalam arti yang sama yaitu ||biner atau +unary atau binary; itu memang kebetulan hanya operator ternary dalam banyak bahasa), jadi setidaknya dalam sampel terbatas itu, pernyataan Anda gagal di sana.

Juga, seperti yang disebutkan sebelumnya, ada satu situasi besar ketika operator penggabungan nol sangat berguna, dan saat itulah ekspresi yang akan dievaluasi memiliki efek samping sama sekali. Dalam hal itu, Anda tidak dapat menggunakan operator kondisional tanpa (a) memperkenalkan variabel sementara, atau (b) mengubah logika aplikasi yang sebenarnya. (B) jelas tidak sesuai dalam keadaan apa pun, dan sementara itu adalah preferensi pribadi, saya tidak suka mengacaukan ruang lingkup deklarasi dengan banyak variabel asing, bahkan jika berumur pendek, sehingga (a) terlalu dalam bahwa skenario tertentu.

Tentu saja, jika Anda perlu melakukan beberapa pemeriksaan pada hasilnya, operator bersyarat, atau serangkaian ifblok, mungkin merupakan alat untuk pekerjaan itu. Tetapi untuk sederhana "jika ini nol, gunakan itu, kalau tidak gunakan itu", operator penggabungan nol ??sempurna.

Satu hal yang banyak saya lakukan belakangan ini adalah menggunakan null coalescing untuk backup as. Sebagai contoh:

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

Console.WriteLine(i); // Prints 4

Ini juga berguna untuk membackup rantai panjang ?.yang masing-masing bisa gagal

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

Satu-satunya masalah adalah operator null-coalesce tidak mendeteksi string kosong.

yaitu

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

string result2 = null ?? "coalesced!";

KELUARAN:

result1 = ""

result2 = coalesced!

Saya sedang mencari untuk mengesampingkan ?? operator untuk mengatasi ini. Ini tentu akan berguna untuk memiliki ini dibangun ke dalam Kerangka.

Pikiran?

Adalah ?? diperlukan, atau sebaiknya Anda hanya menggunakan operator ternary (yang paling akrab)

Anda harus menggunakan apa yang terbaik mengekspresikan niat Anda. Karena ada adalah operator menyatu null, menggunakannya .

Di sisi lain, karena sangat khusus, saya tidak berpikir itu memiliki kegunaan lain. Saya lebih suka ||operator yang kelebihan beban , seperti bahasa lainnya. Ini akan lebih pelit dalam desain bahasa. Tapi yah ...

Keren! Anggap saya sebagai seseorang yang tidak tahu tentang operator penggabungan nol - itu hal yang sangat bagus.

Saya merasa jauh lebih mudah dibaca daripada operator ternary.

Tempat pertama yang terlintas dalam pikiran di mana saya mungkin menggunakannya adalah untuk menyimpan semua parameter default saya di satu tempat.

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
}

Sedikit kasus penggunaan yang aneh, tapi saya punya metode di mana IDisposableobjek berpotensi dilewatkan sebagai argumen (dan karena itu dibuang oleh orang tua), tetapi juga bisa menjadi nol (dan karenanya harus dibuat dan dibuang dalam metode lokal)

Untuk menggunakannya, kodenya terlihat seperti

Channel channel;
Authentication authentication;

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

Tetapi dengan nol bersatu menjadi jauh lebih rapi

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

Saya telah menggunakan seperti ini:

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