Question

想象一下，我有这段代码：

public void Foo()
{
    // Do bar work
    // Do baz work
    // Do foobar work
}

而且我意识到我可以（并且应该因为它做了不止一件事）将其重构为：

public void Foo()
{
    bar();
    baz();
    foobar();
}

private void bar()    { /* do bar work */ }
private void baz()    { /* do baz work */ }
private void foobar() { /* do foobar work */ }

但后来我意识到我永远不会在Foo()之外使用这些功能，所以这些功能只会使主页和自动完成混乱。我可以逃脱这个：

public void Foo()
{
    bar();
    baz();
    foobar();

    void bar()    { /* do bar work */ }
    void baz()    { /* do baz work */ }
    void foobar() { /* do foobar work */ }
}

这会让事情更整洁，更简洁，但我现在所做的一切都是让方法更长而不是更短。

Answer 1

这会让事情更整洁，更简洁，但我现在所做的一切都是让方法更长而不是更短。

不，你没有。你基本上是在说类似于一个类与一个方法之间没有任何区别，这个方法可以完成很多东西，而一个类可以完成同样的工作但是有多个更短更容易保持方法。

你的本地函数就像方法一样，它们包含在另一种方法中的事实并不排除整体更容易维护;功能封装在明确定义的范围内。

Answer 2

我确实喜欢@Mark Benningfield使用部分文件的想法（当我的课程太大而且有一两个超级方法时，我会这样做）

我对本地函数的唯一问题是它们可以捕获变量，而且它是否正在执行它并不总是很清楚。因此，通过将“真实”方法“推广”为“本地”，您正在扩大其可见性。

Answer 3

本地函数提供优于匿名函数的优点，因为匿名函数只能通过委托来调用，除了代理的内存分配之外，委托也是一个更昂贵的调用。

本地函数可以递归，而不需要委托所需的技巧：

int f(int i) => i >= 1 ? i * f(i - 1) : 1;

Func<int,int> d = null;
d = (int i) => i >= 1 ? i * d(i - 1) : 1;

与匿名委托一样，本地函数与顶级方法不同，可以捕获局部变量。因为你是本地人，所以不能被其他职能所援引。

Answer 4

使用匿名函数：

public void Foo()
{
    Action bar = delegate () { /* do bar work */ };
    Action baz = delegate () { /* do baz work */ };
    Action foobar = delegate () { /* do foobar work */ };

    bar();
    baz();
    foobar();
}

或lambda表达式语法：

public void Foo()
{
    Action bar = () => { /* do bar work */ };
    Action baz = () => { /* do baz work */ };
    Action foobar = () => { /* do foobar work */ };

    bar();
    baz();
    foobar();
}

如果只使用一次，那么使用本地函数有什么意义吗？

4 个答案: