[C#]C# 3.5 语言新特性

C# 3.0 和 Visual Basic 9.0 在语言上有许多新特性，并完全结合了基于语言的查询综合（Linq, Language Integrated Query）技术。为适应 Linq 技术，这些语言必须有一些变化。本文描述 C# 3.0 在 2007 年 4 月发布的 Visual Studio 代号 “Orcas” 测试版 1 中的新特性。

本文适用于：Visual Studio codenamed "Orcas" Beta 1 (2007/04/20 Build 9.0.20404)，C# 3.0；.NET Framework 3.5。

在本文中：
1、隐式类型本地变量
2、对象和集合初始值设定项
3、匿名类型
4、扩展方法
5、查询综合
6、Lambda 表达式
7、宽松委托
8、自动实现属性
9、分部方法

隐式类型本地变量

隐式类型本地变量(Implicity Typed Local Variables)是一种在变量声明时编译器自动推断其变量类型的一种语法形式。它使用 var 关键字声明变量。例如：

var a  =   1 ;
var b  =   " Hello, Linq! " ;
var c  =   2.23 ;

编译器根据类型推断，自动设别其变量类型，等同于如下声明形式：

int  a  =   1 ;
string  b  =   " Hello, Linq " ;
decimal  c  =   2.23 ;

注意，通过 var 关键字声明的变量，不能与用 object 声明的变量等同。var 声明的变量根据类型推断，在编译时和运行时的类型均为变量自身的真正类型；而用 object 声明的变量在编译时类型为 System.Object，并伴随一个隐式类型转换的过程。

对象和集合初始值设定项

该语法为简化对象和集合类型(如数组)的初始化赋值操作而产生。例如如下代码声明并初始化一个一个 List<string>。

List < string >  list  =   new  List < string > ();
list.Add( " This " );
list.Add( " Is " );
list.Add( " A " );
list.Add( " Collection " );

可以使用如下方法直接进行初始化：

var list  =   new  List < string > ()  ... { "This", "Is", "A", "Collection" } ;

在任何实现了 Add 方法的类型上都可以使用集合初始值设定项。下面的示例展示了如何创建一个这样的类型。

public   class  Persons  ... {
   private List<string> list = new List<string>();

    public void Add(string name) ...{
        list.Add(name);
    }

    static void Main() ...{
        var p = new Persons() ...{ "1", "2", "3" };
}

对象初始值设定项则可以更加直接的初始化一个对象的实例，例如对于 Person 类，有公开的 Name, Age 和 Height 属性，在实例化 Person 的时候，可以用如下语法形式。

public   class  Person  ... {
    public string Name ...{ get; set; }
    public int Age ...{ get; set; }
    public decimal Height ...{ get; set; }
}

var p  =   new  Person  ... { Name = "Orochi", Age = 24, Height = 175 } ;
var persons  =   new []  ... {
    new Person ...{ Name = "Orochi", Age = 24, Height = 175 },
    new Person ...{ Name = "Blinda", Age = 23, Height = 165 },
    new Person ...{ Name = "Ninicat", Age = 22, Height = 170 }
} ;

代码中 persons 的类型被推断为 Person[]。

匿名类型

匿名类型常常用在查询表达式的结果中，因为这种类型的返回值往往是一个包含一种特定类型的 IEnumerable<T>。例如，要从上面的例子中选出年龄大于 21 岁，身高大于 160 厘米的 Person 集合，可以采用如下形式。

var result  =  from person  in  persons  where  person.Age  >=   21   &&  person.Height  >=   160
    select  new   ... { Name = person.Name, Age = person.Age, Height = person.Height / 100 } ;

new { Name = person.Name, Age = person.Age, Height = person.Height / 100 } 是一个匿名类型，编译器将对它做如下声明。

public   class  _Anonymous_Name_Age_Height  ... {
    public string Name;
    public string Age;
    public decimal Height;
}

扩展方法

扩展方法将一个在特定类型上实现的方法引入到该类型上，并可利用该类型直接调用。

例如，Count() 方法可以计算元素的个数，Count() 方法可以实现在 string、数组、集合、IEnumerable<T> 上，甚至是上文中定义的 Persons 类上。为了在 string 上实现 Count()，可以使用如下代码。

using  System.Runtime.CompilerService;

public   class  Extensions  ... {
    [Extension()]
    public int Count(this string source) ...{
        int count = 0;
        foreach (var item in source) ...{
            count++;
        }
        return count;
    }

    [Extension()]        
    public int Count<T>(this IEnumerable<T> source) ...{
        int count = 0;
        foreach (var T in source) ...{
            count++
        }
        return count;
    }
}

这样，就在 IEnumerable<T> 上和 string 上都实现了 Count() 方法。我们可以象使用 IEnumerable<T> 和 string 上的成员方法一样使用扩展方法，例如：

string  s  =   " Hello, World! " ;
int  c1  =  s.Count();

List < int >  list  =   new  List < int > ()  ... { 1, 2, 3, 4, 5, 6 } ;
int  c2  =  list.Count();

 

查询综合

C# 3.0 支持基于语言的查询框架(Linq)，可以在语言上实现类似于 SQL 的查询。Linq 包含一些关键字，如 select, from, where 等，用来实现更直观的 Linq 语法；Linq 包括 Linq to SQL, Linq to Objects, Linq to XML 和 ADO.NET Entity Framework 等几个部分。

Linq 的基本语法为：

[<变量类型> <变量名称>] [=]
    from <变量名 1> in <可查询集合表达式 1>
    from <变量名 2> in <可查询集合表达式 2>
    join <可查询集合表达式> on <布尔表达式> into <变量名>
    where <布尔表达式>
    group <变量名> by <表达式> into <变量名>
    orderby <变量名> <ascending | descending
    select <表达式>

让我们在一个 DataContext 类上实现几个查询。

[Table]
public   class  Goods
    [Column]  public   string  Name  ... { get; set; }
    [Column]  public   string  BarCode  ... { get; set; }
    [Column]  public   int  VendorID  ... { get; set; }
}

[Table]
public   class  Vendor
... {
    [Column] public int ID ...{ get; set; }
    [Column] public string Name ...{ get; set; }
    [Column] public string Name ...{ get; set; }
}

[STAThread]
public   class  Program
... {
    public void Main()
    ...{
        DataContext dc = new DataContext("server=local; database=testdb;");

        var result = from goods in dc.GetTable<Goods>()
            from vendors in dc.GetTable<Vendor>()
            where goods.VendorID == vendors.ID
            group goods by goods.Name, vendors.Name
            orderby vendors.ID
            select new ...{ GoodsName = goods.Name, VendorName = vendors.Name };

        foreach (var item in result)
            Console.WriteLine("GoodsName: {0}, VendorName: {1}", item.GoodsName, item.VendorName);
    }
}

Lambda 表达式

Lambda 表达式是一种匿名函数结构，它可以方便的实现委托、查询综合和扩展方法的 delegate 类型参数的初始化定义。例如：

delegate   void  Func( int  x);

void  Add( int  x)  ... { x ++; }

Func f  =   new  Func(Add);
f( 1 );

可以使用更加简洁的方式实例化 f。

Func f  =  (x)  =>   ... { x++; } ;

或者

Func f  =  ( int  x)  =>   ... { x++; } ;

虽然上面的代码在实际中没有什么意义，但它为我们展示了一个更直观的委托实现方式。Lambda 表达式的基本语法为：

([[<类型>] <变量名>[, [<类型>] <变量名>]]) => { <语句快> };

Lambda 表达式可以没有参数列表，如：

()  =>   ... { Console.WriteLine(""); } ;

宽松委托

宽松委托使得 C# 在判断委托实例化赋值时，对于签名不同的函数可以接受。例如 EventArgs 和 MouseEventArgs 是具备继承关系的类，当它们出现在同一个接受 EventArgs 类型参数的委托定义中时，编译器对于这两种委托都能接受。例如：

delegate   void  A ( object  sender, MouseEventArgs e);
delegate   void  B ( int  a,  int  b);

EventHandler e1, e2;
e1  =   new  A(...);     //  OK
e2  =   new  EventHandler(...);    //  OK
e1  =  e2;     //  OK

B b  =  ( long  a,  int  b)  +>   ... { } ;    //  OK

自动实现属性

在定义类的属性时，常常需要像下面的代码一样封装一个域。

private   string  name;

public   string  Name  ... { get ...{ return name; } set ...{ name = value; } }

C# 3.0 提供了一种简化的属性定义方法，可以实现上述代码的作用。

public   string  Name  ... { get; set; }

这就是自动实现属性。编译器自动实现类似域封装的代码。不过自动实现属性不能定义只读和只有 get 过程的属性；set 也不能具备访问性描述。

分部方法

分部方法允许开发人员在多个文件中定义一个类的方法。如：

//  文件 1.cs
public   partial   class  A  ... {
    void B();
}

//  文件 2.cs
public   partial   class  A  ... {
    void B ...{ Console.WriteLine("B invoked."); }
}

这种语法可以把函数的定义和声明分开编写。使用分部方法需要注意：

1、分部方法的类实体必须为 partial。
2、分部方法的返回值必须为 void。
3、如果没有实现分部方法，但却定义了此方法的声明，在使用这个包含分部方法的类时，编译器自动将没有实现的方法签名移除。

结论

C# 300 确实为提高生产力做出了巨大贡献，它也代表了下一代程序设计语言的优势和发展方向，这里仅仅是简单介绍了一下 C# 的新特性和新语法，如果您需要更加深入地了解 C# 3.0 和 Visual Studio 代号 “Orcas”，请参考如下资源链接。

Visual Studio Orcas MSDN 页：http://msdn.microsoft.com/vstudio/future/。
C# 3.0 语言规范：http://msdn.microsoft.com/vcsharp/future/。
Linq 项目：http://msdn.microsoft.com/framework/future/。