Atama ifadeleri neden bir değer döndürür?

Buna izin verilir:

int a, b, c;
a = b = c = 16;

string s = null;
while ((s = "Hello") != null) ;

Anladığım kadarıyla, atama s = ”Hello”;yalnızca “Hello”atanmaya neden olmalı s, ancak işlem herhangi bir değer döndürmemelidir. Eğer bu doğru ((s = "Hello") != null)olsaydı, nullhiçbir şeyle kıyaslanamayacağı için bir hata üretirdi.

Atama ifadelerinin bir değer döndürmesine izin vermenin ardındaki mantık nedir?

Anladığım kadarıyla, atama s = "Merhaba"; e-postalara yalnızca "Merhaba" atanmasına neden olmalı, ancak işlem herhangi bir değer döndürmemelidir.

Anlayışınız% 100 yanlış. Bu yanlış şeye neden inandığınızı açıklayabilir misiniz?

Atama ifadelerinin bir değer döndürmesine izin vermenin ardındaki mantık nedir?

Öncelikle, atama ifadeleri bir değer üretmez. Atama ifadeleri bir değer üretir. Bir atama ifadesi yasal bir beyandır; C # 'da yasal ifadeler olan yalnızca bir avuç ifade vardır: bir ifadenin beklenmesi, örnek oluşturma, artırma, azaltma, çağırma ve atama ifadeleri bir ifadenin beklendiği yerde kullanılabilir.

C # 'da bir tür değer üretmeyen tek bir ifade türü vardır, yani geri dönen boşluk olarak yazılan bir şeyin çağrılması. (Ya da eşdeğer olarak, ilişkili sonuç değeri olmayan bir görevin beklenmesi.) Diğer her ifade türü, bir değer ya da değişken ya da başvuru ya da özellik erişimi ya da olay erişimi üretir ve bu böyle devam eder.

Beyan olarak yasal olan tüm ifadelerin yan etkileri için yararlı olduğuna dikkat edin . Buradaki temel fikir budur ve sanırım sezginizin nedeni, atamaların ifadeler değil ifadeler olması gerektiğidir. İdeal olarak, her ifade için tam olarak bir yan etkimiz olur ve bir ifadede hiçbir yan etkimiz olmaz. Bir yan etki kodu hiç bir ekspresyon bağlamında kullanılabileceğini biraz garip.

Bu özelliğe izin vermenin ardındaki mantık, (1) sıklıkla uygun olması ve (2) C benzeri dillerde deyimsel olmasıdır.

Sorunun sorulduğu not edilebilir: Bu neden C benzeri dillerde deyimseldir?

Ne yazık ki Dennis Ritchie artık sormaya müsait değil, ancak benim tahminime göre bir görev neredeyse her zaman bir sicilde atanmış olan değeri geride bırakıyor . C çok "makineye yakın" bir dil türüdür. Akla yatkın görünüyor ve C'nin tasarımına uygun olarak, temelde "az önce atadığım değeri kullanmaya devam et" anlamına gelen bir dil özelliği var. Bu özellik için bir kod üreteci yazmak çok kolaydır; atanan değeri depolayan kaydı kullanmaya devam edersiniz.

Cevabı vermedin mi? Tam olarak bahsettiğiniz yapı türlerini etkinleştirmek için.

Atama operatörünün bu özelliğinin kullanıldığı yaygın bir durum, satırları bir dosyadan okumaktır ...

string line;
while ((line = streamReader.ReadLine()) != null)
    // ...

Atama ifadelerinin en sevdiğim kullanımı, tembel olarak başlatılan özellikler içindir.

private string _name;
public string Name
{
    get { return _name ?? (_name = ExpensiveNameGeneratorMethod()); }
}

Birincisi, sizin örneğinizde olduğu gibi görevlerinizi zincirlemenize izin verir:

a = b = c = 16;

Bir diğeri için, bir sonucu tek bir ifadede atamanıza ve kontrol etmenize olanak tanır:

while ((s = foo.getSomeString()) != null) { /* ... */ }

Her ikisi de muhtemelen şüpheli nedenlerdir, ancak kesinlikle bu yapıları seven insanlar var.

Daha önce bahsedilen nedenlerin yanı sıra (atama zinciri, while döngüleri içinde ayarla ve test et, vb.), İfadeyi doğru şekilde kullanmak için usingbu özelliğe ihtiyacınız vardır:

using (Font font3 = new Font("Arial", 10.0f))
{
    // Use font3.
}

MSDN, kullanıldıktan sonra atıldıktan sonra bile kapsamda kalacağından, tek kullanımlık nesneyi kullanma ifadesi dışında bildirmekten vazgeçirir (bağladığım MSDN makalesine bakın).

Eric Lippert'in cevabında belirttiği belirli bir noktayı ayrıntılandırmak ve kimsenin hiç değinmediği belirli bir olaya dikkat çekmek istiyorum. Eric dedi:

[...] bir atama hemen hemen her zaman bir kayıt defterinde atanmış olan değeri geride bırakır.

Atamanın her zaman sol operandımıza atamaya çalıştığımız değeri geride bırakacağını söylemek isterim. Sadece "neredeyse her zaman" değil. Ancak bilmiyorum çünkü bu konuyu belgelerde yorumlanmış olarak bulamadım. Teorik olarak "geride bırakmak" ve sol işleneni yeniden değerlendirmek için çok etkili uygulanan bir prosedür olabilir, ancak verimli mi?

Bu konudaki yanıtlarda şimdiye kadar oluşturulmuş tüm örnekler için 'Etkili' evet. Ancak get ve set erişimcilerini kullanan özellikler ve dizinleyiciler söz konusu olduğunda verimli mi? Bir şey değil. Bu kodu düşünün:

class Test
{
    public bool MyProperty { get { return true; } set { ; } }
}

Burada, özel bir değişken için sarmalayıcı bile olmayan bir özelliğimiz var. Ne zaman çağrılsa, yerine geri dönecek, değerini belirlemeye çalıştığı zaman hiçbir şey yapmayacak. Dolayısıyla, bu mülk değerlendirildiği her zaman, doğru olacaktır. Bakalım ne olacak:

Test test = new Test();

if ((test.MyProperty = false) == true)
    Console.WriteLine("Please print this text.");

else
    Console.WriteLine("Unexpected!!");

Tahmin et ne basar? Yazdırır Unexpected!!. Görünüşe göre, set erişimcisi gerçekten çağrılıyor ve bu hiçbir şey yapmıyor. Ancak bundan sonra, erişimci hiçbir zaman çağrılmaz. Görev, mülkümüze atamaya falseçalıştığımız değeri geride bırakıyor . Ve bu falsedeğer, if ifadesinin değerlendirdiği şeydir.

Bu konuyu araştırmamı sağlayan gerçek dünya örneğiyle bitireceğim . List<string>Bir sınıfımın özel değişken olarak sahip olduğu bir koleksiyon ( ) için uygun bir sarmalayıcı olan bir indeksleyici yaptım .

Dizin oluşturucuya gönderilen parametre, koleksiyonumda bir değer olarak ele alınacak bir dizeydi. Get erişimcisi, bu değer listede mevcut olsa da olmasa da doğru veya yanlış döndürür. Böylece get erişimcisi, List<T>.Containsyöntemi kullanmanın başka bir yoluydu .

Dizinleyicinin set erişimcisi, argüman olarak bir dizeyle çağrıldıysa ve doğru işlenen bir bool ise true, o parametreyi listeye eklerdi. Ancak erişimciye aynı parametre gönderilmişse ve doğru işlenen bir bool ise false, onun yerine öğeyi listeden silerdi. Böylece set erişimcisi, hem List<T>.Addve hem de için uygun bir alternatif olarak kullanıldı List<T>.Remove.

Ağ geçidi olarak uygulanan kendi mantığımla listeyi saran düzgün ve kompakt bir "API" ye sahip olduğumu düşündüm. Yalnızca bir indeksleyicinin yardımıyla, birkaç tuş vuruşuyla birçok şey yapabilirim. Örneğin, listeme nasıl bir değer eklemeyi deneyebilirim ve onun içinde olduğunu nasıl doğrulayabilirim? Bunun gerekli olan tek kod satırı olduğunu sanıyordum:

if (myObject["stringValue"] = true)
    ; // Set operation succeeded..!

Ancak daha önceki örneğimin gösterdiği gibi, değerin gerçekten listede olup olmadığını görmesi gereken get erişimcisi çağrılmadı bile. trueDeğeri her zaman arkasında etkili şekilde get erişimcisine uygulanan etmişti ne olursa olsun mantığı yok bırakıldı.

Atama bir değer döndürmediyse, satır a = b = c = 16da çalışmayacaktır.

Ayrıca böyle şeyler yazabilmek while ((s = readLine()) != null)de bazen faydalı olabilir.

Öyleyse, atamanın atanan değeri döndürmesine izin vermenin ardındaki neden, bunları yapmanıza izin vermektir.

Ayrıştırıcının bu sözdizimini nasıl yorumlayacağını yanlış anladığınızı düşünüyorum. Atama değerlendirilecek ilk ve sonuç daha sonra NULL karşılaştırılacak, yani deyim eşdeğerdir:

s = "Hello"; //s now contains the value "Hello"
(s != null) //returns true.

Diğerlerinin de belirttiği gibi, bir atamanın sonucu, atanan değerdir. Sahip olmanın avantajını hayal etmekte zorlanıyorum

((s = "Hello") != null)

ve

s = "Hello";
s != null;

eşdeğer değil ...

Bence ana neden C ++ ve C ile (kasıtlı) benzerliktir. Atama operatörünün (ve diğer birçok dil yapısının) C ++ muadilleri gibi davranmasını sağlamak, en az sürpriz ilkesini izler ve herhangi bir programcı başka bir kıvrımdan gelir. parantez dili fazla düşünmeden bunları kullanabilir. C ++ programcıları için öğrenmesi kolay olmak, C # için ana tasarım hedeflerinden biriydi.

Gönderinize dahil ettiğiniz iki nedenden dolayı
1) böylece yapabilirsiniz a = b = c = 16
2) bir ödevin başarılı olup olmadığını test edebilirsiniz if ((s = openSomeHandle()) != null)

'A ++' veya 'printf ("foo")' ifadesinin kendi kendine yeten bir ifade olarak veya daha büyük bir ifadenin parçası olarak yararlı olabileceği gerçeği, C'nin ifade sonuçlarının olabileceği veya olmayabileceği olasılığına izin vermesi gerektiği anlamına gelir. Kullanılmış. Buna göre, yararlı bir şekilde bir değeri 'döndüren' ifadelerin de bunu yapabileceği genel bir görüş vardır. Atama zincirleme, C'de biraz "ilginç" olabilir ve söz konusu tüm değişkenler tam olarak aynı türe sahip değilse, C ++ için daha da ilginç olabilir. Bu tür kullanımlardan muhtemelen kaçınılması en iyisidir.

Başka bir harika örnek kullanım örneği, bunu her zaman kullanıyorum:

var x = _myVariable ?? (_myVariable = GetVariable());
//for example: when used inside a loop, "GetVariable" will be called only once

Buradaki cevaplarda görmediğim ekstra bir avantaj, atama için sözdiziminin aritmetiğe dayalı olmasıdır.

Şimdi x = y = b = c = 2 + 3aritmetikte C tarzı bir dilden farklı bir şey anlamına geliyor; aritmetik onun bir iddianın içinde, biz devlet o x o bir talimat var y vb ve C tarzı dilinde eşittir markaları yürütüldüğünde sonra x y vb eşittir.

Bununla birlikte, aritmetik ve kod arasında, iyi bir neden olmadıkça aritmetikte doğal olana izin vermemenin bir anlam ifade etmeyecek kadar yeterli ilişki olduğunu söyledi. (C-stili dillerin eşittir sembolünün kullanımından aldığı diğer bir şey de == eşitlik karşılaştırması için kullanılmasıdır. Burada yine de en sağdaki == bir değer döndürdüğü için bu tür zincirleme imkansız olacaktır.)

Bir grup şeyi güncellemem ve herhangi bir değişiklik olup olmadığına bakmam gerektiğinde atama dönüş değerini kullanmayı seviyorum:

bool hasChanged = false;

hasChanged |= thing.Property != (thing.Property = "Value");
hasChanged |= thing.AnotherProperty != (thing.AnotherProperty = 42);
hasChanged |= thing.OneMore != (thing.OneMore = "They get it");

return hasChanged;

Yine de dikkatli olun. Bunu kısaltabileceğinizi düşünebilirsiniz:

return thing.Property != (thing.Property = "Value") ||
    thing.AnotherProperty != (thing.AnotherProperty = 42) ||
    thing.OneMore != (thing.OneMore = "They get it");

Ancak bu aslında ilk doğruyu bulduktan sonra veya ifadelerini değerlendirmeyi bırakacaktır. Bu durumda bu, farklı olan ilk değeri atadığında sonraki değerleri atamayı durdurduğu anlamına gelir.

Bununla oynamak için https://dotnetfiddle.net/e05Rh8 adresine bakın