Null Coalescing operatörünü kullanmanın benzersiz yolları [kapalı]

C # Null birleştirici işleç kullanmanın standart yolunun varsayılan değerleri ayarlamak olduğunu biliyorum.

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

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

Ama başka ne ??için kullanılabilir? Üçlü operatör olarak, aşağıdakilerden daha özlü ve okunması kolay olmasının yanı sıra yararlı görünmüyor:

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

Böylece boş birleştirici operatör hakkında daha az bilgi sahibi olunca ...

• ??Başka bir şey için kullandın mı ?

• Mı ??gerekli, yoksa sadece (çoğu aşina olduğu) üçlü operatörü kullanmalıdır

Her şeyden önce, zincirlemek standart üçlüden çok daha kolaydır:

string anybody = parm1 ?? localDefault ?? globalDefault;

vs.

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

Boş olası nesne bir değişken değilse de iyi çalışır:

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

vs.

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

Tembel bir yük tek astar olarak kullandım:

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

Okunabilir? Kendin için karar ver.

Ben iki "biraz garip" şekilde yararlı buldum:

• Rutin outyazarken bir parametreye sahip olmak için bir alternatif olarak TryParse(örn. Ayrıştırma başarısız olursa null değerini döndürür)
• Karşılaştırmalar için "bilmiyorum" temsili olarak

İkincisi biraz daha fazla bilgiye ihtiyaç duyar. Genellikle birden çok öğeyle bir karşılaştırma oluşturduğunuzda, karşılaştırmanın ilk bölümünün (ör. Yaş) kesin bir yanıt verip vermediğini, ardından yalnızca ilk bölüm yardımcı olmadıysa sonraki bölümün (örneğin ad) olup olmadığını görmeniz gerekir. Null birleştirme operatörünün kullanılması, oldukça basit karşılaştırmalar yazabileceğiniz anlamına gelir (sipariş veya eşitlik için olsun). Örneğin, MiscUtil'de birkaç yardımcı sınıf kullanarak :

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

Kuşkusuz şimdi MiscUtil'de ProjectionComparer var, bu tür şeyleri daha da kolaylaştıran bazı uzantılarla birlikte - ama yine de temiz.

Aynı şey, Eşitliklerin uygulanmasının başlangıcında referans eşitliğini (veya geçersizliğini) kontrol etmek için de yapılabilir.

Bir başka avantaj, üçlü operatörün çifte değerlendirme veya geçici bir değişken gerektirmesidir.

Bunu düşünün, örneğin:

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

üçlü operatörle şunlardan biri ile kalırsınız:

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

MyMethod'u iki kez çağıran veya:

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

Her iki durumda da, boş birleştirme operatörü daha temiz ve sanırım daha verimlidir.

Dikkate alınması gereken başka bir şey, birleştirme operatörünün üçlü gibi bir özelliğin get yöntemini iki kez çağırmamasıdır.

Üçlü kullanmamanız gereken senaryolar var, örneğin:

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

Eğer kullanırsan:

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

alıcı iki kez çağrılır ve countdeğişken 2'ye eşit olur ve kullanırsanız:

var b = a.Prop ?? 0

countolması gerektiği gibi değişken 1'e eşittir olacaktır.

??Operatöre bulduğum en büyük avantaj, nullable değer türlerini nullable olmayan türlere kolayca dönüştürebilmenizdir:

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

Bunu sık sık Linq sorgularında kullanıyorum:

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

Kullandım ?? IDataErrorInfo uygulamamda:

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

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

Herhangi bir bireysel özellik "hata" durumunda ise, bu hatayı alıyorum, aksi takdirde null olsun. Gerçekten iyi çalışıyor.

İsteğe bağlı bir parametrenin ayarlanmadığı durumu işlemeyi biraz daha temiz hale getirmek için null birleştirme operatörünü kullanabilirsiniz:

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

Belirli özellikleri tembel yüklemek için null birleştirme operatörünü kullanmayı seviyorum.

Sadece benim açımdan örnek vermek için çok basit bir örnek.

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

Dır-dir ?? ya da sadece üçlü operatörü (en çok tanıdık olan)

Aslında, benim deneyimim, çok az insanın üçlü operatörle (veya daha doğru bir şekilde, koşullu operatörle) aşina ?:olması ||, ikili veya ikili veya ikili olarak aynı anlamda "üçlü" olmasıdır +; yalnızca birçok dilde üçlü operatör), dolayısıyla en azından bu sınırlı örnekte ifadeniz burada başarısız olur.

Ayrıca, daha önce de belirtildiği gibi, boş birleştirme operatörünün çok faydalı olduğu önemli bir durum vardır ve bu, değerlendirilecek ifadenin herhangi bir yan etkisi olduğu zaman ortaya çıkar. Bu durumda, olamaz uygulamanın fiili mantığının değiştirilmesi geçici bir değişken, veya (b) tanıtan ya (a) olmadan koşullu operatörü kullanabilirsiniz. (b) hiçbir koşulda açıkça uygun değildir ve kişisel bir tercih olsa da, kısa ömürlü bile olsa, bildirim kapsamını çok fazla yabancı ile karıştırmaktan hoşlanmam, bu nedenle (a) özel senaryo.

Tabii ki, sonuç üzerinde birden fazla kontrol yapmanız gerekiyorsa, koşullu operatör veya bir dizi ifblok muhtemelen iş için bir araçtır. Ama basit olarak "bu null ise, bunu kullanın, aksi takdirde kullanın", null birleştirme operatörü ??mükemmeldir.

Son zamanlarda çok şey yaptığım şey, yedeklemeler için null birleştirme kullanmaktır as. Örneğin:

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

Console.WriteLine(i); // Prints 4

Her ?.birinin başarısız olabileceği uzun zincirleri yedeklemek için de yararlıdır

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

Tek sorun, boş değer birleştirme işlecinin boş dizeleri algılamamasıdır.

yani

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

string result2 = null ?? "coalesced!";

ÇIKTI:

result1 = ""

result2 = coalesced!

Şu anda? operatör bu sorunu çözmek için. Bunu Çerçeve içine yerleştirmek faydalı olacaktır.

Düşünceler?

Dır-dir ?? ya da sadece üçlü operatörü (en çok tanıdık olan)

Niyetinizi en iyi ifade eden şeyi kullanmalısınız. Orada bu yana ise boş kaynaşabilecek operatörü kullanabilirsiniz .

Öte yandan, bu kadar uzmanlaşmış olduğu için, başka kullanımları olduğunu düşünmüyorum. ||Diğer diller gibi operatörün de aşırı yüklenmesini tercih ederdim . Bu, dil tasarımında daha cimri olacaktır. Ama iyi…

Güzel! Beni sıfır birleştirici operatör hakkında bilmeyen biri olarak say - bu oldukça şık şeyler.

Üçlü operatörden okumayı çok daha kolay buluyorum.

Aklıma gelen ilk yer, tüm varsayılan parametrelerimi tek bir yerde tutmaktır.

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
}

Biraz garip bir kullanım durumu, ancak bir IDisposablenesnenin potansiyel olarak bir arg olarak geçtiği (ve dolayısıyla ebeveyn tarafından atılan) bir yöntemim vardı , ancak aynı zamanda boş da olabilir (ve böylece yerel yöntemde oluşturulmalı ve atılmalıdır)

Kullanmak için, kod ya

Channel channel;
Authentication authentication;

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

Ama boş bir birleşim çok daha temiz olur

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

Ben böyle kullandım:

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