Định danh foreach và đóng

Trong hai đoạn mã sau, đoạn đầu tiên là an toàn hay bạn phải làm đoạn thứ hai?

Ý tôi là mỗi luồng có được đảm bảo gọi phương thức trên Foo từ cùng một lần lặp vòng lặp mà luồng được tạo không?

Hay bạn phải sao chép tham chiếu đến một biến mới "cục bộ" cho mỗi lần lặp của vòng lặp?

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

Cập nhật: Như đã chỉ ra trong câu trả lời của Jon Skeet, điều này không liên quan cụ thể đến luồng.

Chỉnh sửa: tất cả những thay đổi này trong C # 5, với sự thay đổi đối với nơi biến được xác định (trong mắt của trình biên dịch). Từ C # 5 trở đi, chúng giống nhau .

Trước C # 5

Thứ hai là an toàn; đầu tiên thì không.

Với foreach, biến được khai báo bên ngoài vòng lặp - tức là

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

Điều này có nghĩa là chỉ có 1 fvề phạm vi đóng và các luồng rất có thể bị nhầm lẫn - gọi phương thức nhiều lần trên một số trường hợp chứ không phải trên các trường hợp khác. Bạn có thể sửa lỗi này bằng một khai báo biến thứ hai bên trong vòng lặp:

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

Điều này sau đó có một sự riêng biệt tmptrong mỗi phạm vi đóng, vì vậy không có rủi ro về vấn đề này.

Đây là một bằng chứng đơn giản về vấn đề:

    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ết quả đầu ra (ngẫu nhiên):

1
3
4
4
5
7
7
8
9
9

Thêm một biến tạm thời và nó hoạt động:

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

(mỗi số một lần, nhưng tất nhiên thứ tự không được đảm bảo)

Câu trả lời của Pop Catalin và Marc Gravell là đúng. Tất cả những gì tôi muốn thêm là một liên kết đến bài viết của tôi về các bao đóng (nói về cả Java và C #). Chỉ nghĩ rằng nó có thể thêm một chút giá trị.

CHỈNH SỬA: Tôi nghĩ rằng nó đáng để đưa ra một ví dụ không có sự khó đoán của luồng. Đây là một chương trình ngắn nhưng đầy đủ cho thấy cả hai cách tiếp cận. Danh sách "hành động xấu" in ra 10 lần; danh sách "hành động tốt" được tính từ 0 đến 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();
        }
    }
}

Bạn cần sử dụng tùy chọn 2, việc tạo bao đóng xung quanh một biến đang thay đổi sẽ sử dụng giá trị của biến khi biến được sử dụng chứ không phải tại thời điểm tạo bao đóng.

Việc triển khai các phương thức ẩn danh trong C # và hậu quả của nó (phần 1)

Việc triển khai các phương thức ẩn danh trong C # và hậu quả của nó (phần 2)

Việc triển khai các phương thức ẩn danh trong C # và hậu quả của nó (phần 3)

Chỉnh sửa: để làm rõ hơn, trong C # các bao đóng là "bao đóng từ vựng " nghĩa là chúng không nắm bắt giá trị của một biến mà là chính biến đó. Điều đó có nghĩa là khi tạo một bao đóng cho một biến đang thay đổi, bao đóng thực sự là một tham chiếu đến biến không phải là bản sao của giá trị đó.

Edit2: đã thêm liên kết vào tất cả các bài đăng trên blog nếu bất kỳ ai quan tâm đến việc đọc về nội bộ trình biên dịch.

Đây là một câu hỏi thú vị và có vẻ như chúng ta đã thấy mọi người trả lời theo nhiều cách khác nhau. Tôi có ấn tượng rằng cách thứ hai sẽ là cách an toàn duy nhất. Tôi lấy một bằng chứng nhanh chóng thực sự:

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

nếu bạn chạy nó, bạn sẽ thấy tùy chọn 1 được xác định là không an toàn.

Trong trường hợp của bạn, bạn có thể tránh sự cố mà không cần sử dụng thủ thuật sao chép bằng cách ánh xạ của bạn ListOfFootới một chuỗi các chuỗi:

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

Cả hai đều an toàn kể từ phiên bản C # 5 (.NET framework 4.5). Xem câu hỏi này để biết chi tiết: Việc sử dụng các biến của foreach có bị thay đổi trong C # 5 không?

Foo f2 = f;

trỏ đến cùng một tham chiếu như

f 

Vì vậy, không có gì mất và không có gì được ...