在说LINQ之前必须先说说几个重要的C#语言特性
一:与LINQ有关的语言特性
1.隐式类型
(1)源起
在隐式类型出现之前,
我们在声明一个变量的时候,
总是要为一个变量指定他的类型
甚至在foreach一个集合的时候,
也要为遍历的集合的元素,指定变量的类型
隐式类型的出现,
程序员就不用再做这个工作了。
(2)使用方法
来看下面的代码:
var a = 1; //int a = 1;
var b = "123";//string b = "123";
var myObj = new MyObj();//MyObj myObj = new MyObj()
上面的每行代码,与每行代码后面的注释,起到的作用是完全一样的
也就是说,在声明一个变量(并且同时给它赋值)的时候,完全不用指定变量的类型,只要一个var就解决问题了
(3)你担心这样写会降低性能吗?
我可以负责任的告诉你,这样写不会影响性能!
上面的代码和注释里的代码,编译后产生的IL代码(中间语言代码)是完全一样的
(编译器根据变量的值,推导出变量的类型,才产生的IL代码)
(4)这个关键字的好处:
你不用在声明一个变量并给这个变量赋值的时候,写两次变量类型
(这一点真的为开发者节省了很多时间)
在foreach一个集合的时候,可以使用var关键字来代替书写循环变量的类型
(5)注意事项
你不能用var关键字声明一个变量而不给它赋值
因为编译器无法推导出你这个变量是什么类型的。
2.匿名类型
(1)源起
创建一个对象,一定要先定义这个对象的类型吗?
不一定的!
来看看这段代码
(2)使用
var obj = new {Guid.Empty, myTitle = "匿名类型", myOtherParam = new int[] { 1, 2, 3, 4 } };
Console.WriteLine(obj.Empty);//另一个对象的属性名字,被原封不动的拷贝到匿名对象中来了。
Console.WriteLine(obj.myTitle);
Console.ReadKey(); new关键字之后就直接为对象定义了属性,并且为这些属性赋值
而且,对象创建出来之后,在创建对象的方法中,还可以畅通无阻的访问对象的属性
当把一个对象的属性拷贝到匿名对象中时,可以不用显示的指定属性的名字,这时原始属性的名字会被“拷贝”到匿名对象中
(3)注意
如果你监视变量obj,你会发现,obj的类型是Anonymous Type类型的
不要试图在创建匿名对象的方法外面去访问对象的属性!
(4)优点
这个特性在网站开发中,序列化和反序列化JSON对象时很有用
3.自动属性
(1)源起
为一个类型定义属性,我们一般都写如下的代码: 复制代码
public class MyObj2
{
private Guid _id;
private string _Title;
public Guid id
{
get { return _id; }
set { _id = value; }
}
public string Title
{
get { return _Title; }
set { _Title = value; }
}
}
复制代码 但很多时候,这些私有变量对我们一点用处也没有,比如对象关系映射中的实体类。
自C#3.0引入了自动实现的属性,
以上代码可以写成如下形式:
(2)使用
public class MyObj
{
public Guid id { get; set; }
public string Title { get; set; }
}
这个特性也和var关键字一样,是编译器帮我们做了工作,不会影响性能的
4.初始化器
(1)源起
我们创建一个对象并给对象的属性赋值,代码一般写成下面的样子
var myObj = new MyObj();
myObj.id = Guid.NewGuid();
myObj.Title = "allen";
自C#3.0引入了对象初始化器,
代码可以写成如下的样子
(2)使用
var myObj1 = new MyObj() { id = Guid.NewGuid(), Title = “allen” };
如果一个对象是有参数的构造函数
那么代码看起来就像这样
var myObj1 = new MyObj (“allen”) { id = Guid.NewGuid(), Title = “allen” };
集合初始化器的样例代码如下:
var arr = new List() { 1, 2, 3, 4, 5, 6 };
(3)优点
我个人认为:这个特性不是那么amazing,
这跟我的编码习惯有关,集合初始化器也就罢了,
真的不习惯用对象初始化器初始化一个对象!
5.委托
(1)使用
我们先来看一个简单的委托代码
复制代码
delegate Boolean moreOrlessDelgate(int item);
class Program
{
static void Main(string[] args)
{
var arr = new List() { 1, 2, 3, 4, 5, 6,7,8 };
var d1 = new moreOrlessDelgate(More);
Print(arr, d1);
Console.WriteLine(“OK”);
var d2 = new moreOrlessDelgate(Less);
Print(arr, d2);
Console.WriteLine("OK");
Console.ReadKey();
}
static void Print(List<int> arr,moreOrlessDelgate dl)
{
foreach (var item in arr)
{
if (dl(item))
{
Console.WriteLine(item);
}
}
}
static bool More(int item)
{
if (item > 3)
{
return true;
}
return false;
}
static bool Less(int item)
{
if (item < 3)
{
return true;
}
return false;
}
}
复制代码
这段代码中
<1>首先定义了一个委托类型
delegate Boolean moreOrlessDelgate(int item);
你看到了,委托和类是一个级别的,确实是这样:委托是一种类型
和class标志的类型不一样,这种类型代表某一类方法。
这一句代码的意思是:moreOrlessDelgate这个类型代表返回值为布尔类型,输入参数为整形的方法
<2>有类型就会有类型的实例
var d1 = new moreOrlessDelgate(More);
var d2 = new moreOrlessDelgate(Less);
这两句就是创建moreOrlessDelgate类型实例的代码,
它们的输入参数是两个方法
<3>有了类型的实例,就会有操作实例的代码
Print(arr, d1);
Print(arr, d2);
我们把前面两个实例传递给了Print方法
这个方法的第二个参数就是moreOrlessDelgate类型的
在Print方法内用如下代码,调用委托类型实例所指向的方法
dl(item)
6.泛型
(1)为什么要有泛型
假设你是一个方法的设计者,
这个方法有一个传入参数,有一个返回值。
但你并不知道这个参数和返回值是什么类型的,
如果没有泛型,你可能把参数和返回值的类型都设定为Object了
那时,你心里肯定在想:反正一切都是对象,一切的基类都是Object
没错!你是对的!
这个方法的消费者,会把他的对象传进来(有可能会做一次装箱操作)
并且得到一个Object的返回值,他再把这个返回值强制类型转化为他需要的类型
除了装箱和类型转化时的性能损耗外,代码工作的很好!
那么这些新能损耗能避免掉吗?
有泛型之后就可以了!
(2)使用
<1>使用简单的泛型
先来看下面的代码:
复制代码
var intList = new List() { 1,2,3};
intList.Add(4);
intList.Insert(0, 5);
foreach (var item in intList)
{
Console.WriteLine(item);
}
Console.ReadKey();
复制代码
在上面这段代码中我们声明了一个存储int类型的List容器
并循环打印出了容器里的值
注意:如果这里使用Hashtable、Queue或者Stack等非泛型的容器
就会导致装箱操作,损耗性能。因为这些容器只能存储Object类型的数据
<2>泛型类型
List、Dictionary
from p in db.Employees
select new
{
LastName = p.LastName,
TitleOfCourtesy = p.TitleOfCourtesy
} into EmployeesList
orderby EmployeesList.TitleOfCourtesy ascending
select EmployeesList;