Question

一般来说，我得到了C＃的lambda语法。但是匿名线程语法对我来说并不完全清楚。有人可以解释这样的线程创建实际上在做什么吗？请尽可能详细，我希望能够逐步实现使其发挥作用的魔力。

(new Thread(() => {
        DoLongRunningWork();
        MessageBox.Show("Long Running Work Finished!");
    })).Start();

我真正不理解的部分是Thread(() => ...

当我使用这种语法时，我似乎删除了传统ThreadStart的许多限制，例如必须在没有参数的方法上调用。

感谢您的帮助！

Answer 1

() => ...只表示lambda表达式不带参数。您的示例等同于以下内容：

void worker()
{
    DoLongRunningWork();
    MessageBox.Show("Long Running Work Finished!");
}

// ...

new Thread(worker).Start();

lambda中的{ ... }允许你在lambda体中使用多个语句，通常你只允许表达式。

此：

() => 1 + 2

相当于：

() => { return (1 + 2); }

Answer 2

由于在我开始之前有一些答案，我将写下额外参数如何进入lambda。

简而言之，这个叫做 closure 的东西。让我们用new Thread(() => _Transaction_Finalize_Worker(transId, machine, info, newConfigPath)).Start();分析你的例子。

对于闭包，类'字段和局部变量之间存在差异。因此，我们假设transId是类字段（因此可以通过this.transId访问），而其他只是局部变量。

如果在类编译器中使用lambda创建具有不可描述名称的嵌套类，则为了简单起见，将其命名为X，并将所有局部变量放在那里。它也在那里写lambda，所以它成为常规方法。然后编译器重写您的方法，以便它在某个时刻创建X并用machine，info替换对newConfigPath，x.machine和x.info的访问权限和x.newConfigPath分别。此外，X会收到对this的引用，因此lambda-method可以通过transId访问parentRef.transId。

嗯，它非常简化但接近现实。

UPD：

class A
{
    private int b;

    private int Call(int m, int n)
    {
        return m + n;
    }

    private void Method()
    {
        int a = 5;
        a += 5;
        Func<int> lambda = () => Call(a, b);
        Console.WriteLine(lambda());
    }

    #region compiler rewrites Method to RewrittenMethod and adds nested class X
    private class X
    {
        private readonly A _parentRef;
        public int a;

        public X(A parentRef)
        {
            _parentRef = parentRef;
        }

        public int Lambda()
        {
            return _parentRef.Call(a, _parentRef.b);
        }
    }

    private void RewrittenMethod()
    {
        X x = new X(this);
        x.a += 5;
        Console.WriteLine(x.Lambda());
    }
    #endregion
}

Answer 3

这是在C＃中创建线程的匿名方式，它只是启动线程（因为你使用的是Start（）;）以下两种方式是等效的。如果你需要Thread变量来做某事（例如通过调用thread0.join（）来阻塞调用线程），那么你使用第二个。

new Thread(() =>
{
    Console.WriteLine("Anonymous Thread job goes here...");
}).Start();

var thread0=  new Thread(() =>
{
    Console.WriteLine("Named Thread job goes here...");
});
thread0.Start();

现在是Thread方法的一部分。如果你看到Thread声明我们有以下内容（我省略了其他3个）。

public Thread(ThreadStart start);

Thread将一个委托作为参数。委托是指方法。所以Thread接受一个委托参数。 ThreadStart声明如下。

public delegate void ThreadStart();

这意味着你可以将任何方法传递给Thread，它返回void并且不带任何参数。以下示例是等效的。

ThreadStart del = new ThreadStart(ThreadMethod);
var thread3 = new Thread(del);
thread3.Start();

ThreadStart del2 = ThreadMethod;
var thread4 = new Thread(del2);
thread4.Start();

var thread5 = new Thread(ThreadMethod);
thread5.Start();

//This must be separate method
public static void ThreadMethod()
{
    Console.WriteLine("ThreadMethod doing important job...");
}

现在我们认为ThreadMethod方法做的很少，我们可以将它设置为本地和匿名。所以我们根本不需要ThreadMethod方法。

    new Thread( delegate () 
    {
        Console.WriteLine("Anonymous method Thread job goes here...");
    }).Start();

你看到委托给最后一个花括号后等同于我们的ThreadMethod（）。您可以通过引入Lambda语句进一步缩短以前的代码（请参阅MSDN）。这只是你正在使用并看到它如何结束如下。

new Thread( () =>
{
    Console.WriteLine("Lambda statements for thread goes here...");
}).Start();

带有Lambda语法的C＃匿名线程

3 个答案: