C# 是否将值传递给 Lambda？

发布于 2024-07-19 23:10:30 字数 368 浏览 4 评论 0原文

我有一些代码，

int count = 0;

list.ForEach(i => i.SomeFunction(count++));

这似乎不会增加计数。这里count是按值传递的吗？如果我在 lambda 中使用 {} 有什么区别吗？

int count = 0;

list.ForEach(i => 
            {
                    i.SomeFunction(count++);
            });

更新 1

抱歉，我的错误，它确实更新了原始计数。

原文

I have some code,

int count = 0;

list.ForEach(i => i.SomeFunction(count++));

This seems to not increment count. Is count passed by value here? Is there any difference if I use the {} in the lambda?

int count = 0;

list.ForEach(i => 
            {
                    i.SomeFunction(count++);
            });

Update 1

Sorry, my mistake, it does update the original count.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

美人如玉 2024-07-26 23:10:30

count 是一个 int，而 int 是值类型，这意味着它们确实是按值传递的。您的第一个示例和第二个示例之间没有语义差异。

（也就是说，在我看来它应该递增 count，因为它应该捕获原始引用直至闭包。澄清一下 - 尽管 count 将按值传递到 SomeFunction ，当您在表达式中使用它们时，事物不会“传递”到您的 lambda 表达式中——它们与外部变量是相同的引用。）

回复收藏 0 原文

水水月牙 2024-07-26 23:10:30

在这两种情况下，您都在创建所谓的闭包。本质上，count 被包装在一个类中，并且该类由 lambda 表达式使用。

Bill Wagner 有一本很棒的书，名为更有效的 C#，他有一篇博客文章更详细地描述了闭包。

回复收藏 0 原文

爱的故事 2024-07-26 23:10:30

在您的情况下，变量计数由 lambda 表达式捕获。对 count 的任何更改都将对调用者可见。因此，例如：

int count = 0;
list.ForEach(i => i.SomeFunction(count++));
Console.WriteLine(count);

将显示列表的大小，因为在每次迭代中您都会增加 count。

但是，对 SomeFunction 的调用会按 value< 传递 count++ 的计算值（即递增之前 count 的值） /em> 到 SomeFunction。换句话说，SomeFunction 无法更改 count 的值。

有关闭包和变量捕获的更多信息，请参阅我的闭包文章。

The variable count is captured by the lambda expression in your situation. Any changes to count will be visible to the caller. So, for instance:

int count = 0;
list.ForEach(i => i.SomeFunction(count++));
Console.WriteLine(count);

will display the size of the list, because on each iteration you're incrementing count.

However, the call to SomeFunction passes the evaluated value of count++ (which is the value of count before the increment) by value to SomeFunction. In other words, SomeFunction can't change the value of count.

For more on closures and variable capture, see my closures article.

回复收藏 0 原文

夏至、离别 2024-07-26 23:10:30

这应该增加，证明：

class Foo
{
    public void SomeFunction(int i) { }
}
static void Main()
{
    int count = 0;
    List<Foo> list = new List<Foo> {new Foo()};
    list.ForEach(i => i.SomeFunction(count++));
    Console.WriteLine(count); // 1
}

lambda 的作用（如前所述）“捕获”计数，本质上使代码如下：

class Foo
{
    public void SomeFunction(int i) { }
}
class CaptureScope
{
    public int count;
    public void AnonMethod(Foo foo)
    {
        foo.SomeFunction(count++);
    }
}
static void Main()
{
    CaptureScope scope = new CaptureScope();
    scope.count = 0;
    List<Foo> list = new List<Foo> {new Foo()};
    list.ForEach(scope.AnonMethod);
    Console.WriteLine(scope.count); // 1
}

上面是编译器如何解释委托 lambda 的粗略近似。正如您所看到的，count 是类中的一个字段，并且会递增。

That should increment, proof:

class Foo
{
    public void SomeFunction(int i) { }
}
static void Main()
{
    int count = 0;
    List<Foo> list = new List<Foo> {new Foo()};
    list.ForEach(i => i.SomeFunction(count++));
    Console.WriteLine(count); // 1
}

The lambda acts (as already stated) to "capture" count, essentially making the code like:

class Foo
{
    public void SomeFunction(int i) { }
}
class CaptureScope
{
    public int count;
    public void AnonMethod(Foo foo)
    {
        foo.SomeFunction(count++);
    }
}
static void Main()
{
    CaptureScope scope = new CaptureScope();
    scope.count = 0;
    List<Foo> list = new List<Foo> {new Foo()};
    list.ForEach(scope.AnonMethod);
    Console.WriteLine(scope.count); // 1
}

The above is a rough approximation of how the compiler interprets a delegate lambda. As you can see, the count is a field on a class, and is incremented.

回复收藏 0 原文