.NET Lambda表达式最节省的部分

使用Lambda表达式还可以节省许多代码（相信您从第一个示例中也可以看出来了）。不过我认为，最省代码的部分更应该可能是其“分组”和“字典转化”等功能。因此，我们来看下一个示例。

这个示例可能更加贴近现实。不知您是否关注过某些书籍后面的“索引”，它其实就是“列出所有的关键字，根据其首字母进行分组，并且要求对每组内部的关键字进行排序”。简单说来，我们需要的其实是这么一个方法：

static Dictionary< char, List< string>> GetIndex(IEnumerable< string> keywords) { ... }  

想想看，您会怎么做？其实不难（作为示例，我们这里只关注小写英文，也不关心重复关键字这种特殊情况）：

static Dictionary< char, List< string>> GetIndex(IEnumerable< string> keywords)  
{  
    // 定义字典  
    var result = new Dictionary< char, List< string>>();  
 
    // 填充字典  
    foreach (var kw in keywords)  
    {  
        var firstChar = kw[0];  
        List< string> groupKeywords;  
 
        if (!result.TryGetValue(firstChar, out groupKeywords))  
        {  
            groupKeywords = new List< string>();  
            result.Add(firstChar, groupKeywords);  
        }  
 
        groupKeywords.Add(kw);  
    }  
 
    // 为每个分组排序  
    foreach (var groupKeywords in result.Values)  
    {  
        groupKeywords.Sort();  
    }  
 
    return result;  
}  
 

那么如果利用Lambda表达式及.NET框架中定义的扩展方法，代码又会变成什么样呢？请看：

static Dictionary< char, List< string>> GetIndexByLambda(IEnumerable< string> keywords)  
{  
    return keywords  
        .GroupBy(k => k[0]) // 按照首字母分组  
        .ToDictionary( // 构造字典  
            g => g.Key, // 以每组的Key作为键  
            g => g.OrderBy(k => k).ToList()); // 对每组排序并生成列表  
}  

光从代码数量上来看，前者便是后者的好几倍。而有关“声明式”，“what”等可读性方面的优势就不再重复了，个人认为它比上一个例子给人的“震撼”有过之而无不及。

试想，如果我们把GetIndexByLambda方法中的Lambda表达式改成.NET 2.0中delegate形式的写法：

static Dictionary< char, List< string>> GetIndexByDelegate(IEnumerable< string> keywords)  
{  
    return keywords  
        .GroupBy(delegate(string k) { return k[0]; })  
        .ToDictionary(  
            delegate(IGrouping< char, string> g) { return g.Key; },  
            delegate(IGrouping< char, string> g)  
            {  
                return g.OrderBy(delegate(string s) { return s; }).ToList();  
            });  
}  

您愿意编写这样的代码吗？

.NET Lambda表达式体现了函数式编程特性

因此，Lambda表达式在这里还是起着决定性的作用。事实上正是因为有了Lambda表达式，.NET中的一些函数式编程特性才被真正推广开来。“语言特性”决定“编程方式”的确非常有道理。这一点上Java是一个很好的反例：从理论上说，Java也有“内联”的写法，但是C#的使用快感在Java那边还只能是个梦。试想GetIndexByLambda在Java中会是什么情况3：

public Dictionary< Char, List< String>> GetIndexInJava(Enumerable< String> keywords)  
{  
    return keywords  
        .GroupBy(  
            new Func< String, Char> {  
                public Char execute(String s) { return s.charAt(0); }  
            })  
        .ToDictionary(  
            new Func< Grouping< Char, String>, Char> {  
                public Char execute(IGrouping< Char, String> g) { return g.getKey(); }  
            },  
            new Func< Grouping< Char, String>, List< string>> {  
                public List< String> execute(IGrouping< Char, String> g)  
                {  
                    return g  
                        .OrderBy(  
                            new Func< String, String> {  
                                public String execute(String s) { return s; }  
                            })  
                        .ToList();  
                }  
            });  
}  

一股语法噪音的气息扑面而来，让人无法抵挡。由于Java中的匿名类型语法（即上面这种内联写法）连类型信息（new Func< String, Char>{ ... }这样的代码）都无法省去，因此给人非常繁琐的感觉。面对这样的代码，您可能会有和我一样的想法：“还不如最普通的写法氨。没错，这种函数式编程的风格，由于缺乏语言特性支持，实在不适合在Java语言中使用。事实上，这种内联写法很早就出现了（至少在02、03年我还在使用Java的时候就已经有了），但是那么多年下来一点改进都没有。而Lambda表达式出现之后，社区中立即跟进了大量项目，如Moq，Fluent NHibernate等等，充分运用了C# 3.0的这一新特性。难道这还不够说明问题吗？

对了，再次推荐一下Scala语言，它的代码可以写的和C#一样漂亮。我不是Java平台的粉丝，更是Java语言的忠实反对者，但是我对Java平台上的Scala语言和开源项目都抱有强烈的好感。

既然谈到了函数式编程，那么就顺便再多说几句。其实这两个例子都有浓厚的函数式编程影子在里面，例如，对于函数试编程来说，Where常被叫做filter，Select常被叫做map。而.NET 3.5中定义的另一些方法在函数式编程里都有体现（如Aggregate相当于fold）。如果您对这方面感兴趣，可以关注Matthew Poswysocki提出的Functional C#类库。

以上就介绍了.NET Lambda表达式的另一个范例。

【编辑推荐】

1. .NET Lambda表达式的语义：字符串列表范例
2. 使用.NET 3.5 Lambda表达式实现委托
3. 各版本.NET委托的写法回顾
4. C# Actor模型开发实例：网络爬虫
5. 强类型和Actor：ActorLite的演示