Foreach tanımlayıcısı ve kapatır

Question

Aşağıdaki iki snippet'te, birincisi güvenli mi yoksa ikincisini mi yapmalısınız?

Güvenli bir şekilde, her bir iş parçacığının, iş parçacığının oluşturulduğu aynı döngü yinelemesinden Foo'daki yöntemi çağırması garanti edilir.

Veya referansı, döngüdeki her yineleme için "yerel" yeni bir değişkene kopyalamanız gerekir mi?

var threads = new List<Thread>(); 
foreach (Foo f in ListOfFoo) 
{  
    Thread thread = new Thread(() => f.DoSomething()); 
    threads.Add(thread); 
    thread.Start(); 
} 

-

var threads = new List<Thread>(); 
foreach (Foo f in ListOfFoo) 
{  
    Foo f2 = f; 
    Thread thread = new Thread(() => f2.DoSomething()); 
    threads.Add(thread); 
    thread.Start(); 
} 

Güncelleme: olarak Jon Skeet yanıtında işaret, bu özel parçacığı ile ilgisi yoktur. aynı referansa

Answer 1

Düzenleme: değişkenin tanımlandığı yerde (derleyicinin gözünde) bir değişiklikle bu C# 5'deki tüm değişiklikler. C# 5'ten itibaren, onlar aynı.

---

İkincisi güvenlidir; ilk değil. yani

Foo f; 
while(iterator.MoveNext()) 
{ 
    f = iterator.Current; 
    // do something with f 
} 

Bu orada sadece 1 f kapatma kapsamı bakımından, ve ipler çok büyük olasılıkla karışık olabileceği anlamına gelir - - foreach ile

, değişken dışında döngü ilan edilir çağıran yöntem bazı durumlarda birden çok kez ve başkalarında hiç yoktur. Sen içinde ikinci değişken bildiriminde ile döngü bu düzeltebilirsiniz:

foreach(Foo f in ...) { 
    Foo tmp = f; 
    // do something with tmp 
} 

Bu daha sonra her kapatma kapsamında ayrı tmp vardır, bu yüzden bu konuda hiçbir riski yoktur.

static void Main() 
    { 
     int[] data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; 
     foreach (int i in data) 
     { 
      new Thread(() => Console.WriteLine(i)).Start(); 
     } 
     Console.ReadLine(); 
    } 

Çıkışlar (rastgele): Burada

sorunun basit bir kanıtı

1 
3 
4 
4 
5 
7 
7 
8 
9 
9 

geçici değişkeni ekleyin ve çalışır:

 foreach (int i in data) 
     { 
      int j = i; 
      new Thread(() => Console.WriteLine(j)).Start(); 
     } 

(her numara bir kez, ancak tabi ki sipariş garanti edilmez)

Answer 2

Foo f2 = f; 

puan

f 

Yani hiçbir şey kaybetmiş ve hiçbir şey elde ...

Answer 3

seçenek 2 kullanmak Senin ihtiyacını, kullanacağı değişen değişken etrafında bir kapatma oluşturmak Değişken kullanıldığında ve kapanma oluşturma süresinde değilken değişkenin değeri. The implementation of anonymous methods in C# and its consequences (part 2)

The implementation of anonymous methods in C# and its consequences (part 3)

Düzenleme

The implementation of anonymous methods in C# and its consequences (part 1): bir değişkenin değerini ancak değişken kendisini yakalamak yok anlamına gelen "sözcük kapanışları" dir C# kapanışları içinde, net olarak iletmek. Bu, değişen bir değişkenin kapanmasını yaratırken, kapağın aslında, değişkenin bir kopyasının değil, değişkenin bir referansı olduğu anlamına gelir.

Düzenleme2: herhangi bir kişi derleyici içselleri hakkında okumakla ilgileniyorsa, tüm blog yazılarına bağlantılar ekledi.

Answer 4

Pop Catalin ve Marc Gravell'in cevapları doğru. Tek eklemek istediğim, my article about closures (hem Java hem de C# hakkında konuşur) bir bağlantıdır. Sadece biraz değer katabileceğini düşündüm.

DÜZENLEME: Bence iş parçacığının öngörülemezliğine sahip olmayan bir örnek vermeye değer. İşte her iki yaklaşımı gösteren kısa ama eksiksiz bir program. "Kötü eylem" listesi 10 defa basıyor; "Iyi eylem" liste 0'dan 9.

using System; 
using System.Collections.Generic; 

class Test 
{ 
    static void Main() 
    { 
     List<Action> badActions = new List<Action>(); 
     List<Action> goodActions = new List<Action>(); 
     for (int i=0; i < 10; i++) 
     { 
      int copy = i; 
      badActions.Add(() => Console.WriteLine(i)); 
      goodActions.Add(() => Console.WriteLine(copy)); 
     } 
     Console.WriteLine("Bad actions:"); 
     foreach (Action action in badActions) 
     { 
      action(); 
     } 
     Console.WriteLine("Good actions:"); 
     foreach (Action action in goodActions) 
     { 
      action(); 
     } 
    } 
} 

Answer 5

Bu ilginç bir sorudur ve biz insanlar tüm çeşitli şekillerde cevap gördük gibi görünüyor için sayar. İkinci yolun tek güvenli yol olduğu izlenimi altındaydım. Eğer bu seçeneği 1 kesinlikle güvenli değildir göreceksiniz çalıştırırsanız

class Foo 
{ 
    private int _id; 
    public Foo(int id) 
    { 
     _id = id; 
    } 
    public void DoSomething() 
    { 
     Console.WriteLine(string.Format("Thread: {0} Id: {1}", Thread.CurrentThread.ManagedThreadId, this._id)); 
    } 
} 
class Program 
{ 
    static void Main(string[] args) 
    { 
     var ListOfFoo = new List<Foo>(); 
     ListOfFoo.Add(new Foo(1)); 
     ListOfFoo.Add(new Foo(2)); 
     ListOfFoo.Add(new Foo(3)); 
     ListOfFoo.Add(new Foo(4)); 


     var threads = new List<Thread>(); 
     foreach (Foo f in ListOfFoo) 
     { 
      Thread thread = new Thread(() => f.DoSomething()); 
      threads.Add(thread); 
      thread.Start(); 
     } 
    } 
} 

: Ben gerçek bir hızlı kanıtı şanti. Senin durumunda

Answer 6

, sen eşleyerek kopyalama hile kullanmadan sorunu önlemek edebilirsiniz ListOfFoo parçacığı dizisine:

var threads = ListOfFoo.Select(foo => new Thread(() => foo.DoSomething())); 
foreach (var t in threads) 
{ 
    t.Start(); 
} 

Answer 7

İkisi C# sürümü 5 (NET framework 4.5) itibariyle güvenlidir. Ayrıntılar için şu soruya bakın: Has foreach's use of variables been changed in C# 5?