【LINQ技术】扩展特性和LINQ操作符

LINQ特有的编程结构

LINQ就像是嵌入到C#中的强类型查询语言，尽管和SQL查询很像，但语法却并不相同，甚至还有截然相反的一面。

LINQ是在.NET发展到3.5版的时候被引进的，C#和VB语言都为此做了许多工作，扩展了大量新的编程结构。

一、隐式类型本地变量

var——一个如此小巧的关键字却有着强大的力量。

            var varInt=1;
var varBool=True;
var varString="String, String, String";

Console.WriteLine("varInt is a: {0}",varInt.GetType().Name);
Console.WriteLine("varBool is a: {0}",varBool.GetType().Name);
Console.WriteLine("varString is a: {0}",varString.GetType().Name);
        

上面的代码会很神奇的自动显示出它们各自的类型。

var的限制：

1.var不能用于字段数据
2.var不能用于返回值或参数类型
3.必须在声明时分配值，且值不为NULL

但var可以这样：

            
                var alarmClock=new AlarmClock();
alarmClock=null;
        

            
                var varInt=1;
var varInt2=varInt;

bool varBool=True;
var varBool2=varBool;
        

            
                static
                int Alarm()
{
    var alarm="09:20";
    return alarm;
}
        

隐式类型数据是强类型数据。类型推断延续了C#语言的强类型特性，并且只会在编译时影响变量的声明。之后，该数据点被视为它声明的类型。为该变量分配不同的类型将导致编译时错误。

            
                // 编译器知道“s”是一个string类型
                var s="This is a string.";
s="Funny...";

// 因此可以调用string的所有成员string bigS=s.ToUpper();

// 但不能将非string类型的数据分配给s
s=True; 
        

var为LINQ而生

LINQ技术使用的是查询表达式，它可以根据表达式本身的格式产生动态创建的结果集。但有时在某些情况下根本无法显示定义查询的访问类型，这时隐式类型就会发挥作用了。

二、对象和集合初始化语法

在扩展这个新的特性之前，我们要创建一个对象并给其属性初始化会是这样：

            
                var rect = new Rect();
rect.Height=100;
rect.Width=200;
        

但是支持C# 3.0加入了这个新特性，代码就成了这样：

            
                var rect = new Rect(){Height=100,Width=200};
        

如果有构造函数的话还可以在括号内传入参数呢，就像这样：

            
                var rect = new Rect("bigRect"){Height=100,Width=200};
        

如果对于集合，那就优势就更加明显了。

            List<Alarm> alarmList = new List<Alarm>
{
    new Alarm { Name = "todayAlarm", Description=new Desc{ Time="07:20",Location="Home"}},
    new Alarm { Name = "tomorrowAlarm", Description=new Desc{
Time="08:40",Location="Company"}}，
    new Alarm { Name = "nextYearAlarm", Description=new Desc{
Time="18:40",Location="Shanghai"}}，
}；
        

将对象/集合初始化语法和隐式类型本地变量相结合就可以声明匿名类型。

三、匿名类型

通过这个特性可以快速建立数据的“结构”，编译器将根据名称/值对的集合在编译时生成的类。该类型是基于值的语义构建的，因此System.Object中的每个虚方法都要重写。要定义一个匿名类型，可以声明一个隐式类型变量，并使用对象初始化语法指定数据的结构。

            var alarm=new 
{
    currentTime=DateTime.Now,
    alarm=new {Name="todayAlarm",Location="Shanghai",Time="18:20"},
};
        

四、扩展方法

通过面向对象的继承机制，我们可以给一个类添加新的方法等，但这不是唯一的方法。

C#的扩展方法不用子类就能向已知类型中添加新的功能，当然了，它还可以向不能有子类的密封类和结构中添加新的功能。但是需要注意的是：

1.在写扩展方法时，第一个参数必须使用this限定符，用来表示被扩展的类型
2.第一个参数不能有ref或者out的修饰符
3.第一参数还不能是指针类型
2.扩展方法只能存在于静态类中，并且必须使用static关键字将方法声明为静态的

而且使用扩展方法并不会影响性能，因为这些都是编译器需要做的，而通过继承则需要影响性能。

五、Lambda表达式

Lambda表达式可算是Lisp语言的核心了，如果想要了解该语言可以访问我的其他博客。C#添加了这个特性可谓是有了质的提升。

Lambda大大简化了.NET委托的使用，减少了需要手工输入的代码。

            List<int> list=new List<int>();
list.AddRange(newint[]{10,21,4,8,3,59});

List<int> list2=list.FindAll(i=>(i%2)==1);

Console.WriteLine("Here are your odd numbers:");
foreach(int n in list2)
{
    Console.Write("{0}\t",n);
}
        

C# LINQ查询操作符是调用System.Linq.Enumerable类中方法的简便方式，这些方法通常都使用委托作为参数，用来处理数据生成正确的结果集。

LINQ的用途

1.数据

作为软件开发者，编程的绝大部分时间中都在操作着数据。数据有哪些来源？我们可能会从用户输入中得到数据，也可能从配置文件中得到数据，还可能从网络中得到数据，甚至可能从WCF服务返回的内存中得到数据。但是在操作特定的数据时，我们往往会使用不同的API。

数据	操作数据的方式
关系数据	System.Data.dll和System.Data.SqlClient.dll等
XML文档数据	System.Xml.dll
元数据表	System.Reflection命名空间
对象集合	System.Array和System.Collections/System.Collections.Generic

我们可以使用ADO.NET、XML命名空间、Reflection（反射）服务还有各种对于集合的操作。但就这些API本身而言，它们都是独立的个体。而LINQ API则倾向于提供一个同一且对称的方式，以便我们能够在广义的数据上得到和操作“数据”。通过使用LINQ，我们便可以直接创建被称为查询表达式（query expression）的实体。这些查询表达式是基于许多查询操作符（query operator）的，而且有意设计为类似SQL表达式。

而根据LINQ查询的应用场景，可以分为以下5个部分：

LINQ to Object： 针对数组和集合使用的LINQ查询
LINQ to XML： 使用LINQ来操纵和查询XML文档
LINQ to DataSet： 针对ADO.NET DataSet对象使用的LINQ查询
LINQ to Entity： 对ADO.NET Entity Framework （EF）API使用的LINQ查询
Parallel LINQ （PLINQ）： 并行处理LINQ查询返回的结果

2.LINQ表达式是强类型的

和传统的SQL语句不同，LINQ查询表达式是强类型的，所以我们必须保证这些表达式在语法上都是合理的。因此我们要充分利用Visual Studio这个IDE的智能感知、自动感知等有用的功能。

LINQ操作数组

通过下面这个示例，我们可以将数组中的int数值取出奇数并排序。

            
                static
                void Main(string[] args)
{
    LINQDemo();
}

staticvoid LINQDemo()
{
    int[] array = { 8, 30, 13, 35, 89, 31, 83, 58, 32, 76 };
    IEnumerable<int> subset = from a in array
                    where a % 2 == 1orderby a
                    select a;
    foreach(int i in subset)
    {
         Console.Write("Item: {0}\n", i);
    }
}
        

最后获得的结果的集合是由一个实现了IEnumerable< T >泛型版本的对象来表示的。前面我们介绍了var，这里可以用吗？当然可以。

            
                var subset = from a in array
    where a % 2 == 1orderby a
    select a;
        

如果使用var的话，那么在foreach中也需要将int改为var。一般来说，最好在获取LINQ查询结果时都使用隐式类型，但在绝大多是情况下，真正的返回值是实现了IEnumerable< T >接口的类型。

延迟执行和立即执行

在迭代内容之前，LINQ查询表达式并不会真正进行计算。这就叫“延迟执行”，它能够让相同的容器执行多次相同的LINQ查询，而始终获得最新的结果。

            
                static
                void LINQDemo()
{
    int[] array = { 8, 30, 13, 35, 89, 31, 83, 58, 32, 76 };
    var subset = from a in array
                    where a % 2 == 1orderby a
                    select a;
    foreach(var i in subset)
    {
         Console.Write("Item: {0}\n", i);
    }
    Console.WriteLine();

    array[0]=71;

    foreach(var i in subset)
    {
         Console.Write("Item: {0}\n", i);
    }
    Console.WriteLine();
}
        

这样一来在第二次的输出中就会在数组的头部添加一个71。

这里就是在foreach中运算的LINQ表达式，但如果希望在foreach之前就运算呢？可以调用Enumerable类型定义的许多扩展方法。它定义了ToArray< T >()、ToList< T >()和ToDictionary

            
                static
                void LINQDemo()
{
    int[] array = { 8, 30, 13, 35, 89, 31, 83, 58, 32, 76 };
    int[] subsetInt = (from a in array
                    where a % 2 == 1orderby a
                    select a).ToArray<int>();
    List<int> subsetList = (from a in array
                    where a % 2 == 1orderby a
                    select a).ToList<int>();
}
        

记得将整个LINQ表达式用圆括号括起来，这样就能将它强制转换为正确的实际类型来调用Enumerable的扩展方法。

C#编译器不得不说真的很强大，它能够准确的检测泛型项的类型参数，我们不需要指定类型参数。因此也可以像下面这样：

            
                int[] subsetInt = (from a in array
                    where a % 2 == 1orderby a
                    select a).ToArray();
        

立即执行的好处会体现在当要对外部调用者返回LINQ查询时。

LINQ 查询操作符

查询操作符	含义
from、in	用于定义任何LINQ表达式的主干，允许从合适的容器中提取数据子集
where	用于定义从一个容器里取出哪些项的限制条件
select	用于从容器中选择一个序列
join、on、equals、into	基于指定的键来做关联操作，但这些“关联”不必与关系数据库的数据有什么关系
orderby、ascending、descending	允许结果子集按升序或降序排序
group、by	用特定的值来对数据分组后得到一个子集

1.获取数据子集

使用where操作符可以从数据容器里得到特定的子集，where后应该是运算结果为布尔值的表达式。当然了，对于&& 和 || 这些操作也都是可以得。

2.投影新的数据类型

如果想要传入的Alarm[]类型的alarm集合中得到一个只有时间和名字的结果集，可以定义一个select语句，动态生成一个新的匿名类型。

            
                static
                void GetNameAndTime(Alarm[] alarm)
{
    var alarmSubset=from a in alarm selectnew {a.Name,a.Time};
    foreach (var i in alarmSubset)
    {
        Console.WriteLine(i.ToString());
    }
}
        

因为在使用投影的LINQ查询时，我们无法知道实际的数据类型，因为它是在编译时决定的，所以就必须使用var关键字。因此也就无法在创建方法时返回隐式类型。

但如果需要返回这些数据呢，难道就没有办法吗？可以用前面介绍的ToArray()扩展方法将查询结果转换为.NET System.Array对象。

            
                static Array GetAlarmProp(Alarm[] alarm)
{  
    var alarmSubset=from a in alarm selectnew {a.Name,a.Time};
    return alarmSubset.ToArray();
}
        

最后我们可以在Main()中如下调用和处理数据：

            Array al=GetAlarmProp(alarm);
foreach( object o in al)
{
    Console.WriteLine(0);
}
        

3.获取数据集中的个数

在投影一批新的数据时，比如在1000个Computer中获取所有的Windows操作系统的，那么如果知道它们的总数呢？

            
                int pc=(from c in computer where c.operation="Windows"select c).Count();
        

4.反转结果集

想要将最终的结果进行反转，可以通过Enumerable类中的扩展方法Reverse< T >()对结果集中的项进行反转。

            
                static
                void GetNameAndTime(Alarm[] alarm)
{
    var alarmSubset=from a in alarm selectnew {a.Name,a.Time};
    foreach (var i in alarmSubset.Reverse())
    {
        Console.WriteLine(i.ToString());
    }
}
        

5.对表达式进行排序

在前面我们曾使用orderby对获取到的奇数进行排序，那么为什么直接用“orderby a”就可以排序呢？很简单，因为默认是正序……对于字符串是按字母顺序，对数字就是从小到大。如果要使用逆序可以使用“orderby a descending”，正序是默认的，不过也可以加上ascending。

6.维恩图工具

Enumerable类提供了一些扩展方法，可以对两个（或多个）LINQ查询的数据进行合并（union）、比较（difference）、连接（concatenation）和交叉（intersection）。比如：

            
                List
                <
                string
                > myMoney=newList<string>{"1元","2元","5元","10元"};
List<string> yourMoney=newList<string>{"10元","20元","50元","100元"};

var ourMoney=(from m in myMoney select m).Union(from y in yourMoney select y);
        

这样一来，我们的前就合并了哈……

7.移除重复

移除重复就像前面的反转一样：

                foreach (var i in alarmSubset.Reverse())
    {
        Console.WriteLine(i.ToString());
    }
        

                foreach (var i in alarmSubset.Distinct())
    {
        Console.WriteLine(i.ToString());
    }
        

8.聚合操作

前面的Count()就是聚合中的一个例子，此外还有Average()、Max()、Min()、Sum()等等。