C# 7 局部函数剖析

局部函数是C# 7中的一个新功能，允许在一个函数中定义另一个函数。

何时使用局部函数？

局部函数的主要功能与匿名方法非常相似：在某些情况下，创建一个命名函数在读者的认知负担方面代价太大。有时，函数本身就是另一个函数的部分逻辑，因此用一个单独的命名实体来污染“外部”范围是毫无意义的。

您可能认为此功能是多余的，因为匿名委托或Lambda表达式可以实现相同的行为。但事实并非如此，匿名函数有一定的限制，其特征可能不适合您的场景。

用例1：迭代器中的先决条件

这是一个简单的函数，逐行读取一个文件。您知道什么时候ArgumentNullException会被抛出来吗？

    public static IEnumerable<string> ReadLineByLine(string fileName)
    {
        if (string.IsNullOrEmpty(fileName)) throw new ArgumentNullException(nameof(fileName));
        foreach (var line in File.ReadAllLines(fileName))
        {
            yield return line;
        }
    }

    // 什么时候发生错误？
    string fileName = null;
    // 这里?
    var query = ReadLineByLine(fileName).Select(x => $"\t{x}").Where(l => l.Length > 10);
    // 还是这里?
    ProcessQuery(query);

包含yield return的方法很特殊。它们叫做 迭代器块（Iterator Blocks），它们很懒。这意味着这些方法的执行是“按需”发生的，只有当方法的客户端调用MoveNext生成迭代器时，才会执行它们中的第一个代码块。在我们的例子中，这意味着错误只会在ProcessQuery方法中发生，因为所有的LINQ操作符都是懒惰的。

显然，该行为是不可取的，因为该ProcessQuery方法抛出的异常ArgumentNullException将不具有关于该上下文的足够信息。所以最好尽早抛出异常 - 客户端调用ReadLineByLine时，而不是当客户端处理结果时。

为了解决这个问题，我们需要将验证逻辑提取到一个单独的方法中。匿名函数是最佳候选，但匿名委托和Lambda表达式不支持迭代器块：

VB.NET中的 Lambda表达式支持迭代器块。

    public static IEnumerable<string> ReadLineByLine(string fileName)
    {
        if (string.IsNullOrEmpty(fileName)) throw new ArgumentNullException(nameof(fileName));

        return ReadLineByLineImpl();

        IEnumerable<string> ReadLineByLineImpl()
        {
            foreach (var line in File.ReadAllLines(fileName))
            {
                yield return line;
            }
        }
    }

用例2：异步方法中的先决条件

异步方法与异常处理有类似的问题，在标记有async关键字的方法中抛出的任何异常，会在一个失败的Task中显现：

    public static async Task<string> GetAllTextAsync(string fileName)
    {
        if (string.IsNullOrEmpty(fileName)) throw new ArgumentNullException(nameof(fileName));
        var result = await File.ReadAllTextAsync(fileName);
        Log($"Read {result.Length} lines from '{fileName}'");
        return result;
    }

    string fileName = null;
    // 无异常
    var task = GetAllTextAsync(fileName);
    // 以下行将抛出异常
    var lines = await task;

从技术上说，async是一个上下文关键字，但这并不改变我的观点。

您可能认为错误发生时没有太大差异，但这远非如此。失败的Task意味着该方法本身未能做到应该做的事情，问题出在方法本身或方法所依赖的某一个构建块中。

在系统中传递结果Task时，急切的先决条件验证尤为重要。在这种情况下，很难理解什么时候出现什么问题。局部函数可以解决这个问题：

    public static Task<string> GetAllTextAsync(string fileName)
    {
        // 提前参数验证
        if (string.IsNullOrEmpty(fileName)) throw new ArgumentNullException(nameof(fileName));
        return GetAllTextAsync();

        async Task<string> GetAllTextAsync()
        {
            var result = await File.ReadAllTextAsync(fileName);
            Log($"Read {result.Length} lines from '{fileName}'");
            return result;
        }
    }

用例3：迭代器块的局部函数

不能在Lambda表达式中使用迭代器是一个非常麻烦的问题。这是一个简单的例子：如果要获取类型层次结构中的所有字段（包括私有的），则必须手动遍历继承层次结构。但遍历逻辑是特定方法的，应尽可能保持局部可用：

    public static FieldInfo[] GetAllDeclaredFields(Type type)
    {
        var flags = BindingFlags.Instance | BindingFlags.Public |
                    BindingFlags.NonPublic | BindingFlags.DeclaredOnly;
        return TraverseBaseTypeAndSelf(type)
            .SelectMany(t => t.GetFields(flags))
            .ToArray();

        IEnumerable<Type> TraverseBaseTypeAndSelf(Type t)
        {
            while (t != null)
            {
                yield return t;
                t = t.BaseType;
            }
        }
    }

用例4：递归匿名方法

默认情况下，匿名函数无法引用自身。要解决此限制，您应该声明一个委托类型的局部变量，然后在Lambda表达式或匿名委托中使用该局部变量：

    public static List<Type> BaseTypesAndSelf(Type type)
    {
        Action<List<Type>, Type> addBaseType = null;
        addBaseType = (lst, t) =>
        {
            lst.Add(t);
            if (t.BaseType != null)
            {
                addBaseType(lst, t.BaseType);
            }
        };

        var result = new List<Type>();
        addBaseType(result, type);
        return result;
    }

这种方法可读性不强，类似的解决方案，局部函数感觉会更自然：

    public static List<Type> BaseTypesAndSelf(Type type)
    {
        return AddBaseType(new List<Type>(), type);

        List<Type> AddBaseType(List<Type> lst, Type t)
        {
            lst.Add(t);
            if (t.BaseType != null)
            {
                AddBaseType(lst, t.BaseType);
            }
            return lst;
        }
    }

用例5：内存分配

如果您曾经开发过一个性能要求非常高的的应用程序，应该知道匿名方法的开销也不小：

• 委托调用的开销（非常小，但确实存在）;
• 如果Lambda捕获本地变量或封闭方法的参数，则需要分配2个堆内存（一个用于闭包实例，另一个用于委托本身）;
• 如果Lambda捕获一个封闭的实例状态，则需要分配1个堆内存（只是分配委托）;
• 只有当Lambda没有捕获任何东西或捕获静态时，分配0个堆内存。

但是局部函数的分配模式不同。

    public void Foo(int arg)
    {
        PrintTheArg();
        return;
        void PrintTheArg()
        {
            Console.WriteLine(arg);
        }
    }

如果一个局部函数捕获一个局部变量或一个参数，那么C#编译器会生成一个特殊的闭包结构，实例化它并通过引用传递给一个生成的静态方法：

    internal struct c__DisplayClass0_0
    {
        public int arg;
    }

    public void Foo(int arg)
    {
        // Closure instantiation
        var c__DisplayClass0_ = new c__DisplayClass0_0() { arg = arg };
        // Method invocation with a closure passed by ref
        Foo_g__PrintTheArg0_0(ref c__DisplayClass0_);
    }

    internal static void Foo_g__PrintTheArg0_0(ref c__DisplayClass0_0 ptr)
    {
        Console.WriteLine(ptr.arg);
    }

（编译器生成无效字符的名称，例如<和>。为了提高可读性，我更改了名称并简化了代码。）

局部函数可以捕获实例状态、局部变量或参数，不会发生堆内存分配。

局部函数中使用的局部变量应该在局部函数声明站点中明确指定。

堆内存分配将发生的情况很少：

• 局部函数被明确地或隐式地转换为委托。

如果局部函数捕获静态/实例字段但不捕获局部变量/参数，则只会发生委托分配。

    public void Bar()
    {
        // Just a delegate allocation
         //只是一个委托分配
        Action a = EmptyFunction;
        return;
        void EmptyFunction() { }
    }

如果局部函数捕获局部变量/参数，将发生闭包分配和委托分配：

    public void Baz(int arg)
    {
        // Local function captures an enclosing variable.
        // The compiler will instantiate a closure and a delegate
        //本地函数捕获一个封闭的变量。
        //编译器将实例化一个闭包和一个委托
        Action a = EmptyFunction;
        return;
        void EmptyFunction() { Console.WriteLine(arg); }
    }

• 本地函数捕获局部变量/参数，匿名函数从同一范围捕获变量/参数。

这种情况更为微妙。

C#编译器为每个词法范围生成一个不同的闭包类型（方法参数和顶级局部变量驻留在同一个顶级范围内）。在以下情况中，编译器将生成两个闭包类型：

    public void DifferentScopes(int arg)
    {
        {
            int local = 42;
            Func<int> a = () => local;
            Func<int> b = () => local;
        }

        Func<int> c = () => arg;
    }

两个不同的Lambda表达式如果它们从同一范围捕获局部变量，将使用相同的闭包类型，Lambda a和b驻留在同一闭包：

    private sealed class c__DisplayClass0_0
    {
        public int local;

        internal int DifferentScopes_b__0()
        {
            // Body of the lambda 'a'
            return this.local;
        }

        internal int DifferentScopes_b__1()
        {
            // Body of the lambda 'a'
            return this.local;
        }
    }

    private sealed class c__DisplayClass0_1
    {
        public int arg;

        internal int DifferentScopes_b__2()
        {
            // Body of the lambda 'c'
            return this.arg;
        }
    }

    public void DifferentScopes(int arg)
    {
        var closure1 = new c__DisplayClass0_0 { local = 42 };
        var closure2 = new c__DisplayClass0_1() { arg = arg };
        var a = new Func<int>(closure1.DifferentScopes_b__0);
        var b = new Func<int>(closure1.DifferentScopes_b__1);
        var c = new Func<int>(closure2.DifferentScopes_b__2);
    }

在某些情况下，这种行为可能会导致一些非常严重的内存相关问题。这是一个例子：

    private Func<int> func;
    public void ImplicitCapture(int arg)
    {
        var o = new VeryExpensiveObject();
        Func<int> a = () => o.GetHashCode();
        Console.WriteLine(a());

        Func<int> b = () => arg;
        func = b;
    }

在委托调用a()之后，变量o似乎应该符合垃圾回收的条件，但事实并非如此，两个Lambda表达式共享相同的闭包类型：

    private sealed class c__DisplayClass1_0
    {
        public VeryExpensiveObject o;
        public int arg;

        internal int ImplicitCapture_b__0()
            => this.o.GetHashCode();

        internal int ImplicitCapture_b__1()
            => this.arg;
    }

    private Func<int> func;

    public void ImplicitCapture(int arg)
    {
        var c__DisplayClass1_ = new c__DisplayClass1_0()
        {
            arg = arg,
            o = new VeryExpensiveObject()
        };
        var a = new Func<int>(c__DisplayClass1_.ImplicitCapture_b__0);
        Console.WriteLine(func());
        var b = new Func<int>(c__DisplayClass1_.ImplicitCapture_b__1);
        this.func = b;
    }

这意味着闭包实例的生命周期将被绑定到func字段的生命周期：闭包保持活动，直到应用程序到达委托func。这可以延长VeryExpensiveObject生命周期，这基本上会导致内存泄漏。

当局部函数和Lambda表达式捕获来自同一范围的变量时，会发生类似的问题。即使捕获不同的变量，封闭类型将被共享，导致堆分配：

    public int ImplicitAllocation(int arg)
    {
        if (arg == int.MaxValue)
        {
            // This code is effectively unreachable
            Func<int> a = () => arg;
        }

        int local = 42;
        return Local();

        int Local() => local;
    }

编译为：

    private sealed class c__DisplayClass0_0
    {
        public int arg;
        public int local;

        internal int ImplicitAllocation_b__0()
            => this.arg;

        internal int ImplicitAllocation_g__Local1()
            => this.local;
    }

    public int ImplicitAllocation(int arg)
    {
        var c__DisplayClass0_ = new c__DisplayClass0_0 { arg = arg };
        if (c__DisplayClass0_.arg == int.MaxValue)
        {
            var func = new Func<int>(c__DisplayClass0_.ImplicitAllocation_b__0);
        }
        c__DisplayClass0_.local = 42;
        return c__DisplayClass0_.ImplicitAllocation_g__Local1();
    }

正如您可以看到，顶层作用域中的所有局部变量现在都成为封闭类的一部分，即使当局部函数和Lambda表达式捕获不同的变量时也会导致关闭分配。

总结

以下是C#中关于局部函数的最重要特性：

1. 局部函数可以定义迭代器；
2. 局部函数对异步方法和迭代器块的预先验证非常有用；
3. 局部函数可以递归；
4. 如果没有向委托进行转换，局部函数是免分配的；
5. 由于缺少委托调用开销，局部函数的效率比匿名函数稍高；
6. 局部函数可以在返回语句之后声明，它将主逻辑与辅助函数分开；
7. 局部函数可以“隐藏”在外部范围中声明的具有相同名称的函数；
8. 局部函数可以使用async和/或unsafe修饰符，不允许使用其它修饰符；
9. 局部函数无法使用属性；
10. 局部函数在IDE中还不是非常友好：没有“提取局部函数重构”（目前为止），如果一个局部函数的代码被破坏了，您将在IDE中收到很多“波浪线”。

这是Benchmark测试结果：

    private static int n = 42;

    [Benchmark]
    public bool DelegateInvocation()
    {
        Func<bool> fn = () => n == 42;
        return fn();
    }

    [Benchmark]
    public bool LocalFunctionInvocation()
    {
        return fn();
        bool fn() => n == 42;
    }

Method	Mean	Error	StdDev	Allocated

  DelegateInvocation | 2.3035 ns | 0.0847 ns | 0.0869 ns |       0 B

LocalFunctionInvocation | 0.0142 ns | 0.0176 ns | 0.0137 ns | 0 B

不要因为差异而感到困惑，它看起来很大，但我几乎从来没有看到委托调用开销造成的真正问题。

原文：《Dissecting the local functions in C# 7》https://blogs.msdn.microsoft.com/seteplia/2017/10/03/dissecting-the-local-functions-in-c-7/

翻译：Sweet Tang

本文地址：http://www.cnblogs.com/tdfblog/p/dissecting-the-local-functions-in-c-7.html

欢迎转载，请在明显位置给出出处及链接。