Linq学习笔记（转）

时间：2023-12-23 11:54:38

开始Linq前你要知道的

　　扩展方法

　　顾名思义就是对现有类进行扩展的的方法，扩展方法可以在不修改现有类的情况下，为现有类增加公共的接口（不是C#中的interface）。

　　扩展方法本质上是一个静态方法，不同之处在于它的第一个参数必须有this关键字声明，并且第一个参数的类型即为要扩展的类型。如

public static double ToDouble(this string source)

{

    double res = 0d;

    double.TryParse(source, out res);

    return res;

}

public static void SimpleExtesionMethod()

{

    double d = "12345.54321".ToDouble();

    Console.WriteLine(d);

}

这里是个简单的将字符串转为double类型的扩展方法，只要引用了该方法的命名空间，则都可以直接用string类型来调用ToDouble方法。

　　扩展方法是后文的基础，C#3.0中的Linq的实现都是基于扩展方法，通过对IEnumerable<T>接口（Linq to Objects）的扩展和对IQueryable<T>的扩展来实现Linq的相关功能，而Linq的相关关键字最终都是转化为对IEnumerable<T>(IQueryable<T>)的调用。

　　Lambda表达式

　　lambda表达式其实就是.net2.0中的匿名方法，然后再3.0中以一种更优美的姿态呈现出来。

　　lambda表达式的基本语法为

　　(参数列表) =>{语句块;}    或者　　( 参数列表) =>表达式

　　当参数列表中只有一个参数的时候，圆括号可以省略

Func<string, string> func = x => x + x;

Console.WriteLine(func("a"));

Var：隐式类型化变量

　　使用与可以由编译器推导出的变量的声明，不需要显式指定对象的类型。

var container = new List<string> { "张三", "李四", "王五" };

IEnumerable<string> query = from name in container

            select name;

上例中由于定义中已经指明了对象的类型，声明中已经完全没有必要使用显示的类型定义，所以可以使用var关键字。

　　对于匿名对象

var test = new { Name = "Sth.", Type = "UnKnown" };

由于无法用一个类型类声明匿名对象，此时可以用var是声明。

　　注意var只是省下了显式声明的过程，而C#本身就是静态语言，所以var所声明的变量的类型已经确定任然是不能改变的，亦即，var并非是变体类型。

Linq对谁适用

　　linq的语法通过System.Linq下面的Enumerable类提供支持，通过观察他的签名，你就会发现他为IEnumerable<T>实现了一系列的扩展方法，也就是说，只要是实现了IEnumerable<T>的对象都可以使用Linq的语法来查询。

　　而对于只实现了IEnumerable接口而没有实现IEnumerable<T>的对象可以通过

public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source);

来将IEnumerable接口转为IEnumerable<T>（例如ArrayList）。

Linq中的关键字

　　在C#3.0中，为Linq引入了一些新的关键字，他们是：

　　from join where group into let orderby select

　　熟悉Sql的同学看着是不是有些眼熟呢，其实在Linq中他们的涵义和在SQL中类似的，所以会很容易理解的。接下来的时间，简单介绍下这些关键字的使用。

from

　　from子句是一个Linq查询的开始，任何一个Linq语句都是以from开始，from子句指定查询的容器，和在此语句有效的局部变量（用来指定容器中的一项，from子句的效果很类似于foreach）。from子句的语法为

 from local in container

local就是在此Linq语句中的局部变量，由于container必须为IEnumerable<T>，他的类型可以由container推导出来（即T）。上一段简单的例子：

ar container = new List<string> { "张三", "李四", "王五" };

var query = from name in container

            select name;

foreach (string name in query)

{

    Console.WriteLine(name);

}

输出:

张三

李四

王五

如果container仅仅实现IEnumerable而没有实现IEnumerable<T>，则需要显式指定局部变量的类型，或者是使用Cast转为IEnumerable<T>

var container = new ArrayList { "张三", "李四", "王五" };

var query = from name in container.Cast<string>()

            select name;

//或者

var query1 = from string name in container

             select name;

select

　　对查询的结果进行投影，在子句中指定要选择的列，如上例。有的时候，我们只需要投影某一列，我们可以这样

private static void TestSelectSingleProperty()

{

    var persons = GetPersons();

    var query = from p in persons
select p.Name;

    foreach (var item in query)

    {

        Console.WriteLine(item);

    }

}

我们还可以指定要投影的列的集合，这个时候我们要用到匿名类型

var query = from p in persons

            select new { p.ID, p.Name };

foreach (var item in query)

{

    Console.WriteLine("No:{0},Name:{1}",item.ID,item.Name);

}

query中的每一项都时候一个拥有ID属性和Name属性的对象，当然有的时候实体的属性名不是我们想要的，或者是通过对属性计算得来的，那么我们可以显式指定属性名，就像下面这样：

var query = from p in persons

            select new

            {

                UserID = p.ID,

                FriendName = p.Gender == "男" ? "Mr" : "Ms" + p.Name

            };

foreach (var item in query)

{

    Console.WriteLine("No:{0},Friendly Name:{1}", item.UserID, item.FriendName);

}

where

　　对容器内的数据进行筛选。

var query = from p in persons

            where p.DepartmentID ==

            select p.Name;

join

　　类似SQL里的join，Linq中的join子句用于将两个容器的数据以某种关系进行关联。

var departments = GetDepartments();

var persons = GetPersons();

var query = from d in departments

            join p in persons on d.ID equals p.DepartmentID

            select new { d, p };

值得注意的是join子句只能使用equals或者是not equal而不能用其他运算符（==都不行）。而equals运算符左边必须联接的左部，右边为右部，不能调换的，否则编译不能通过。

into

　　into子句用于将join或者是group子句的结果进一步持续化，包装成为一个

　　System.Linq.IGrouping<TKey, TElement>对象，

　　而且IGrouping继承自IEnumerable<TElement>，可以看出，IGrouping接口提供分组的键和，该键下所包含的集合。例子见group

group

　　对结果按照指定的条件进行分组

var container = new List<string> { "ZhangSan", "LiSi", "Wangwu", "ZhaoLiu", "Deng" };

var query = from name in container

            group name by name.Length into g

            select new { g.Key, Values = g };

例子演示了通过姓名的长度对一个姓名列表进行分组，并将分组的结果保持到局部变量g中，可以通过下面的代码将query的结果输出

foreach (var group in query)

{

    Console.WriteLine("{0}:", group.Key);

    foreach (var item in group.Values)

    {

        Console.WriteLine(item);

    }

}

let

　　let子句用于在查询中添加一个新的局部变量，使其在后面的查询中可见

var query = from p in persons

            let friendlyName = p.Gender == "男" ? "Mr" : "Ms" + p.Name

            select new

            {

                UserID = p.ID,

                FriendName = friendlyName

            };

foreach (var item in query)

{

    Console.WriteLine("No:{0},Friendly Name:{1}", item.UserID, item.FriendName);

}

在IEnumerable<T>上的其他扩展

　　Take Skip

　　用于选取前XX个或者和跳过前ＸＸ个，如选择第１１到２０个则可以

query.Skip().Take();

OrderBy OrderByDescending

　　排序而已

query.OrderBy(c => c.Length);

Distinct Union Intersect Except 这些单词都见过吧，分别就是取不重复，并集，交集，差集（这个貌似看看参数就明白了）

　　其他扩展都在Enumerable类下面了。

　　Linq的延迟加载特性

　　Linq查询的执行结果是IEnumerable<T>类型，而对IEnumerable<T>，在内部，C#通过yield关键字实现迭代器达到延迟加载的目的。从而使Linq查询只是在需要的时候才会被执行。

　　但是，某一些扩展方法在执行时会试图遍历整个容器，从而使延迟加载无效，如排序，聚合函数（Count，Sum，Average等。）

static IEnumerable<int> InfinityInts()

{

    int count = ;

    while (true)

        yield return count++;

}

public static void LazyLoad()

{

    var query = from i in InfinityInts()

                select i;

    foreach (var i in query.Take())

    {

        Console.WriteLine(i);

    }

}

public static void CantDoLazyLoad()

{

    var query = from i in InfinityInts()

                select i;

    foreach (var i in query.OrderBy(i => i).Take())

    {

        Console.WriteLine(i);

    }

}

这里有个简单的例子来证明，当使用Take时候，Linq语句能正常的执行，而当我们再Linq上使用一个Order By之后，程序就卡死了，当然，这是理所应当的，在失去延迟加载的特性之后，试图对一个无穷序列排序的结果一定是outOfMemory。

相关文章