集合访问中的LINQ查询表达式与普通方法对比

C# 中集合的概念不仅指的是System.Collection和System.Collection.Generic集合中的结合类型，实际上其他数据也可看作集合，如XML文件，数据库，数组都是集合，高效地集合操作能大大提高开发效率，C#中对于集合的操作希望做到尽量简单，统一，.NET Framework 3.5种引入的Linq（语言集成查询）实现了这一功能。

下面我们以无序的List为例，来体验linq查询表达式相对于普通集合查询的优越性。

先声明一个Book类：

class Book
{
    public string BookName { get; set; }
    public int PublishYear { get; set; }
    public string Author { get; set; }
}

 

然后初始化一个List<Book>：

List<Book> bookInstances=new List<Book>
{
    new Book
    {
        BookName="Windows Phone 应用程序开发",
        PublishYear =2012,
        Author="李春旭"
    },
    new Book
    {
        BookName="Silverlight高级编程",
        PublishYear=2011,
        Author="李春旭"
    },
    new Book
    {
        BookName=".NET高级程序设计",
        PublishYear=2010,
        Author="李春旭"
    },
    new Book
    {
        BookName="精通Android应用程序",
        PublishYear=2010,
        Author="刘泽宏"
    }
};

 

我们需要完成的三个任务：

1. 查找书名为《.NET高级程序设计》的元素。
2. 统计每个作者写书的数量。
3. 找出每个作者出版的最后一本书。

一 ： 普通方法

主要依靠对集合的循环遍历。

Task 1：

static void Task1()
{
    Console.WriteLine("===查找元素书名为《.NET高级程序设计》的书=======");
    Book theSpecialBook = null;
    foreach (Book item in books)
    {
        if (item.BookName.Equals(".NET高级程序设计"))
        {
            theSpecialBook = item;
            break;
        }
    }
    Console.WriteLine(theSpecialBook.BookName);
    Console.WriteLine(theSpecialBook.Author);
    Console.WriteLine(theSpecialBook.PublishYear);
    Console.WriteLine();
}

 

Task 2：

static void Task2()
{
    Console.WriteLine("===统计每个作者共写书的数量======");
    Dictionary<string, int> bookCount = new Dictionary<string, int>();
    foreach (Book item in books)
    {
        int bookNum = 0;
        if (bookCount.TryGetValue(item.Author, out bookNum))
        {
            bookNum++;
            bookCount[item.Author] = bookNum;
        }
        else
        {
            bookCount.Add(item.Author, 1);
        }
    }
    foreach (string key in bookCount.Keys)
    {
        Console.Write(key);
        Console.WriteLine("\t" + bookCount[key]);
    }
    Console.WriteLine();
}

 

Task 3：

static void Task3()
{
    Console.WriteLine("===每个作者出版的最后一本书=====");
    Dictionary<string, Book> lastBookList = new Dictionary<string, Book>();
    foreach (Book item in books)
    {
        Book temp = null;
        if (lastBookList.TryGetValue(item.Author, out temp))
        {
            if (item.PublishYear > temp.PublishYear)
            {
                lastBookList[item.Author] = item;
            }
        }
        else
        {
            lastBookList.Add(item.Author, item);
        }
    }

    foreach (string key in lastBookList.Keys)
    {
        Console.WriteLine(key);
        Console.WriteLine("\t" + lastBookList[key].BookName);
        Console.WriteLine("\t" + lastBookList[key].PublishYear);
    }
}

 

至此，我们发现上述对集合的操作无外乎是遍历，区别仅是遍历的条件，次数和遍历过程中保存临时变量的内容和条件的不同，这种操作方式相对不够直观和易于理解。

二：Linq查询表达式

Task 1：

static void Task1()
{
    Console.WriteLine("===查找元素书名为《.NET高级程序设计》的书=======");
    IEnumerable<Book> items =
        (from c in books where c.BookName.Equals(".NET高级程序设计") select c);
    foreach (Book item in items)
    {
        Console.WriteLine(item.BookName);                
        Console.WriteLine(item.Author);
        Console.WriteLine(item.PublishYear);
        Console.WriteLine();
    }
}

 

Task 2：

static void Task2()
{
    Console.WriteLine("===统计每个作者共写书的数量======");
    //通过group按作者名字进行分组，然后统计每组的数量
    var items = from c in books
                group c by c.Author into d
                select new              //分组之后选择出一个匿名类，使用select将数据投射为另一种类型
                {                       //该匿名类有两个属性，
                    d.Key,              //1.作者名字
                    Count = d.Count()   //2.书籍的数量
                };                      //相对于使用Dictionary来保存更加简便和直接。
    foreach (var item in items)
    {
        Console.Write(item.Key);
        Console.WriteLine("\t"+item.Count);
    }
    Console.WriteLine();
}

 

Task 3：

static void Task3()
{
    Console.WriteLine("===每个作者出版的最后一本书=====");
    var lastBooks = from c in books
                    group c by c.Author into d
                    let maxPubYear=d.Max<Book>(item => item.PublishYear)
                    select new
                    {
                        d.Key,
                        PublishYear =maxPubYear,
                        LastBook = from e in books  
                                   where e.PublishYear.Equals(maxPubYear)&&e.Author.Equals(d.Key)
                                   select e.BookName
                    };
    foreach (var item in lastBooks)
    {
        Console.WriteLine(item.Key);
        Console.WriteLine("\t"+item.LastBook.First());
        Console.WriteLine("\t"+item.PublishYear);
    }
}

 

从上面可以看出，使用Linq，只需要一句话就能完成多行代码才能完成的功能，并且形式上更容易理解，不需要去看循环的逻辑，判断条件，循环结束条件等逻辑判断，而且不需要去设计临时变量，不用考虑如何保存遍历的结果。

使用Linq访问集合实际上是一种函数式编程，实现上述任务本质上还是调用了集合类实现的排序，查找等算法，Linq只是对相应的函数调用做了一个更易理解，更不易出错的语法描述。

完整的项目和代码可在此处下载。