Bir iade ifadesi bir kilidin içinde mi yoksa dışında mı olmalıdır?

Ben sadece benim kod bazı yerlerde kilit içinde ve bazen dışında iade ifadesi olduğunu fark ettim. Hangisi en iyisi?

1)

void example()
{
    lock (mutex)
    {
    //...
    }
    return myData;
}

2)

void example()
{
    lock (mutex)
    {
    //...
    return myData;
    }

}

Hangisini kullanmalıyım?

Temel olarak, kod hiç bu kadar kolay olmamıştı. Tek çıkış noktası güzel bir idealdir, ancak kodu sadece elde etmek için şekilden bükmezdim ... Ve alternatif yerel bir değişken (kilit dışında) bildiriyorsa, (kilidin içinde) ve sonra geri (kilit dışında), sonra kilit içinde basit bir "dönüş foo" çok daha basit olduğunu söyleyebilirim.

IL'deki farkı göstermek için, şu kodu girelim:

static class Program
{
    static void Main() { }

    static readonly object sync = new object();

    static int GetValue() { return 5; }

    static int ReturnInside()
    {
        lock (sync)
        {
            return GetValue();
        }
    }

    static int ReturnOutside()
    {
        int val;
        lock (sync)
        {
            val = GetValue();
        }
        return val;
    }
}

(mutlu bir şekilde ReturnInsideC # daha basit / temiz bir bit olduğunu iddia ediyorum unutmayın )

Ve IL'ye bakın (serbest bırakma modu vb.):

.method private hidebysig static int32 ReturnInside() cil managed
{
    .maxstack 2
    .locals init (
        [0] int32 CS$1$0000,
        [1] object CS$2$0001)
    L_0000: ldsfld object Program::sync
    L_0005: dup 
    L_0006: stloc.1 
    L_0007: call void [mscorlib]System.Threading.Monitor::Enter(object)
    L_000c: call int32 Program::GetValue()
    L_0011: stloc.0 
    L_0012: leave.s L_001b
    L_0014: ldloc.1 
    L_0015: call void [mscorlib]System.Threading.Monitor::Exit(object)
    L_001a: endfinally 
    L_001b: ldloc.0 
    L_001c: ret 
    .try L_000c to L_0014 finally handler L_0014 to L_001b
} 

method private hidebysig static int32 ReturnOutside() cil managed
{
    .maxstack 2
    .locals init (
        [0] int32 val,
        [1] object CS$2$0000)
    L_0000: ldsfld object Program::sync
    L_0005: dup 
    L_0006: stloc.1 
    L_0007: call void [mscorlib]System.Threading.Monitor::Enter(object)
    L_000c: call int32 Program::GetValue()
    L_0011: stloc.0 
    L_0012: leave.s L_001b
    L_0014: ldloc.1 
    L_0015: call void [mscorlib]System.Threading.Monitor::Exit(object)
    L_001a: endfinally 
    L_001b: ldloc.0 
    L_001c: ret 
    .try L_000c to L_0014 finally handler L_0014 to L_001b
}

Yani IL seviyesinde [bazı isimler verin veya alın] aynıdır (bir şey öğrendim ;-p). Bu nedenle, tek mantıklı karşılaştırma, yerel kodlama stilinin (oldukça öznel) yasasıdır ... ReturnInsideBasitliği tercih ederim , ama ikisinden de heyecanlanmam.

Hiçbir fark yaratmaz; ikisi de derleyici tarafından aynı dile çevrilir.

Açıklığa kavuşturmak için, ya etkili bir şekilde aşağıdaki semantik ile bir şeye çevrilir:

T myData;
Monitor.Enter(mutex)
try
{
    myData= // something
}
finally
{
    Monitor.Exit(mutex);
}

return myData;

Kesinlikle kilit içinde dönüş koymak istiyorum. Aksi takdirde, başka bir iş parçacığının kilide girip dönüş ifadesinden önce değişkeninizi değiştirmesi riskini alırsınız, bu nedenle orijinal arayanın beklenenden farklı bir değer almasını sağlarsınız.

Değişir,

Buradaki tahıllara karşı gideceğim. Genellikle kilidin içine dönecekti.

Genellikle değişken verilerim yerel bir değişkendir. Yerel değişkenleri başlatırken bildirmeyi çok seviyorum. Nadiren kilitlerimin dışında dönüş değerimi başlatmak için verilerim var.

Yani karşılaştırmanız aslında hatalı. İdeal olarak, iki seçenek arasındaki fark, yazdığınız gibi olacaktır, ki bu da durum 1'e başını veriyor gibi görünüyor, pratikte biraz daha çirkin.

void example() { 
    int myData;
    lock (foo) { 
        myData = ...;
    }
    return myData
}

vs.

void example() { 
    lock (foo) {
        return ...;
    }
}

Özellikle kısa parçacıklar için 2. durumun okunması çok daha kolay ve daha zor vidalanması olduğunu düşünüyorum.

Dışarıdaki kilidin daha iyi göründüğünü düşünüyorsanız, ancak kodu şu şekilde değiştirirseniz dikkatli olun:

return f(...)

Eğer f () kilit basılıyken çağrılmaya ihtiyaç duyulursa, açık bir şekilde kilidin içinde olması gerekir;

Değeri ne olursa olsun , MSDN'deki belgelerin kilidin içinden dönme örneği var. Buradaki diğer cevaplardan, oldukça benzer IL gibi görünüyor, ancak bana göre, kilidin içinden geri dönmek daha güvenli görünüyor, çünkü o zaman başka bir iş parçacığı tarafından bir dönüş değişkeninin üzerine yazılma riskini çalıştırmıyorsunuz.

Diğer geliştiricilerin kodu okumasını kolaylaştırmak için ilk alternatifi öneririm.

lock() return <expression> ifadeler her zaman:

1) kilidi girin

2) belirtilen türün değeri için yerel (iş parçacığı açısından güvenli) depo yapar,

3) mağazayı döndürdüğü değerle doldurur <expression>,

4) çıkış kilidi

5) mağaza iade.

Bu, kilit ifadesinden döndürülen ve dönüşten önce her zaman "pişirilen" değerin anlamına gelir.

Endişelenme lock() return, burada kimseyi dinleme))

^{Not: Bu cevabın gerçekten doğru olduğuna inanıyorum ve umarım bu da yardımcı olur, ancak her zaman somut geri bildirimlere dayanarak geliştirmekten memnuniyet duyarım.}

Mevcut cevapları özetlemek ve tamamlamak için:

• Kabul cevap bakılmaksızın hangi sözdizimi biçimi size seçtiğiniz, gösteriler C # zamanında ve dolayısıyla - - IL kodunda, kod returnkadar olmaz sonra kilit serbest bırakılır.

  • Hatta yerleştirilmesi rağmen return içlock saptıran, kontrol akışını kesinlikle, blok nedenle, bu yöntem ^{: [1]} , bu sözdizimsel olan uygun bir aux dönüş değeri saklamak için ihtiyacı ortadan kaldırmaktadır olmasıyla. yerel değişken (blok dışında bildirilir, böylece blok dışında kullanılabilir return) - Edward KMETT'nin cevabına bakınız .

• Ayrı olarak - ve bu yön soruya rastlantısaldır , ancak yine de ilgi çekici olabilir ( Ricardo Villamil'in cevabı buna hitap etmeye çalışır, ancak yanlış, sanırım) - bir lockifadeyi bir ifadeyle birleştirmek return- yani, returnkorunan bir blokta değer elde etmek eşzamanlı erişim - yalnızca bir kez elde edildikten sonra korumaya ihtiyaç duymadığında , aşağıdaki senaryolarda geçerli olan , arayanın kapsamındaki döndürülen değeri anlamlı bir şekilde "korur" :

  • Döndürülen değer, bir öğeden yalnızca öğe ekleme ve kaldırma açısından korunmaya ihtiyaç duyan bir öğeyse, öğelerin kendilerinin modifikasyonları ve / veya ...

  • ... döndürülen değer bir değer türünün veya dizenin örneğiyse .

    • Bu durumda, arayanın değerin bir anlık görüntüsünü (kopyasını) ^[2] aldığını unutmayın; bu durum, arayanı incelerken artık kaynak veri yapısındaki geçerli değer olmayabilir.

  • Başka bir durumda, kilitleme , yöntemin içinde (sadece) değil , arayan tarafından yapılmalıdır .

^{[1] Theodor Zoulias bu teknik, aynı zamanda doğru yerleştirmek için olduğuna işaret returniçindeki try, catch, using, if, while, for, ... ifadeleri; bununla birlikte, lockbu sorunun sorulduğu ve çok ilgi gördüğü gibi, gerçek kontrol akışının incelenmesini davet etmesi muhtemel olan ifadenin özel amacıdır .}

^{[2] Değer türü bir örneğe erişmek, her zaman yığının yerel, yığın halinde bir kopyasını oluşturur; dizeler teknik olarak başvuru türü örnekler olsa da, etkin şekilde benzer değer türü örnekler olarak davranırlar.}