LINQ之路 2:C# 3.0的语言功能(上)

在上一篇的LINQ介绍中,我们已经看到了隐式类型变量var,扩展方法(extension method)和lambda表达式的身影。没错,他们正是LINQ技术的基石,是他们让LINQ的实现成为可能,并且简化了LINQ表达式的书写。在这一篇中,我将和大家一一探讨C#3.0在语言功能上所作的努力,包括:隐式类型局部变量、自动属性和匿名类型。

 

隐式类型局部变量

C#是强类型语言,意味着我们在声明变量时必须指定变量的具体类型,比如:

        static void DeclareExplicitVars()
{
int myInt = 0;
bool myBool = true;
string myString = "Hello, World!";
}

现在C# 3.0为我们提供了一个新的关键字var,你可以使用它代替正式的数据类型名(如int, bool, string)。在使用var关键字时,编译器会根据用于初始化局部变量的初始值推断出变量的数据类型。例如,上面的变量声明可以改为如下代码:

        static   void DeclareImplicitVars()
{
// 隐式类型局部变量的声明方式: var varName = defaultValue;
var myInt = 0;
var myBool = true;
var myString = "Hello, World!";
}

上面两种方式是等价的,编译器可以根据初始值推断myInt的类型为System.Int32,myBool的类型为System.Boolean,myString的类型为System.String。

除此之外,我们可以对基类库中的所有类型使用隐式类型,包括数组、泛型、自定义类型。

        public   static void   DeclareImplicitVars()
{
// declare implicit variables
var numbers = new int[] { 2, 4, 6, 8 };
var persons = new List<Person>();
var car = new SportsCar();

// verify the data type using reflection
Console.WriteLine("numbers is a: {0}", numbers.GetType().Name);
Console.WriteLine("persons is a: {0}", persons.GetType().Name);
Console.WriteLine("car is a: {0}", car.GetType().Name);
}

输出结果如下:
       

var在foreach语句中的使用

在foreach循环语句中,我们也可以使用隐式类型。正如你希望的那样,编译器会推断出正确的数据类型:

        static   void VarInForeachLoop()
{
var numbers = new int[] { 2, 4, 6, 8 };
foreach (var item in numbers)
{
Console.WriteLine("Item value: {0}", item);
}
}

隐式类型变量的限制

需要注意的是,使用var关键字时会存在多种限制。首先,隐式类型只能应用与方法或者属性内局部变量的声明,不能使用var来定义返回值、参数的类型或类型的数据成员。

其次,使用var进行声明的局部变量必须赋初始值,并且不能以null作为初始值。其原因在于编译器必须能够根据初始值推断出该变量的实际类型。

隐式类型数据是强类型数据

隐式类型局部变量最终会产生强类型数据。因此,var关键字与脚本语言(如VBScript或Perl)的Variant数据类型是不一样的,对后者来说,一个变量可以在其生命周期中保存不同类型的值。

其实,类型推断保持了C#语言的强类型特性,并且在编译时只影响变量声明。初始化之后,编译器就已经为隐式类型变量推断出了确切的数据类型。如果把不同类型的值赋给变量会导致编译时错误:

        static   void ImplicitTypingStrongTyping()
{
// 编译器知道 s 是System.String类型
var s = "This variable can only hold string data!";
s = "It's OK.";

// 可以调用任何基础方法
string upper = s.ToUpper();

// 错误!不能把数值类型数据赋给String类型变量
s = 100;
}

隐式类型局部变量的作用

看了上面的介绍,你肯定会奇怪这个结构有什么用呢。如果只是为了简单,就不值得了,因为这样做可能会使其他阅读代码的人感到疑惑。但当我们使用LINQ时,var关键字的优势就显现出来了。它可以动态根据查询本身的格式来创建结果集,这样我们就不需要显示定义查询可能返回的类型,而且在很多时候我们并不能一眼就看出LINQ的返回类型。如下例:

        public   static void   QueryOverInts()
{
int[] numbers = { 10, 20, 30, 40, 1, 2, 3, 5 };
var subset = from i in numbers where i < 10 select i;

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

Console.WriteLine("subset is a: {0}", subset.GetType().Name);
Console.WriteLine("subset is defined in: {0}", subset.GetType().Namespace);
}

输出:
       

 其实,我们可以认为只有在定义从LINQ查询返回的数据时才使用var关键字。

 

自动属性

我们知道.NET语言推荐使用类型属性来封装私有数据字段,而不是 使用GetXXX()和SetXXX()方法。因为.NET基类库总是使用类型属性而不是传统的访问和修改方法,因此使用属性可以获得与.NET平台更好的集成性。需要知道的是,在底层,C#属性会被映射到前缀get_和set_的方法中,即如果定义了Name属性,C#会自动生成get_Name()和set_Name()方法。

考虑如下的C#类型定义:

    class Person
{
private string firstName = string.Empty;
public string FirstName
{
get { return firstName; }
set { firstName = value; }
}

private string lastName = string.Empty;
public string LastName
{
get { return lastName; }
set { lastName = value; }
}

private int level = 0;
public int Level
{
get { return level; }
set { level = value; }
}
}

虽然定义属性不难,但如果属性只是赋值和返回值,对次定义字段和属性也很麻烦,特别是在类属性很多的情况下。为了简化这种简单的数据字段封装的过程,C# 3.0提供了自动属性语法。现在,上面的Person可以定义成如下形式:

    class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int Level { get; set; }
}

定义自动属性时,我们只需要指定访问修饰符、数据类型、属性名称和空的get/set作用域。在编译时,会使用自动生成的私有支持字段以及get/set逻辑的正确实现。

需要注意的是,定义自动属性时,必须同时提供get和set关键字,因此不能定义只读或者只写的自动属性。

 

匿名类型

作为一个面向对象的程序员,我们知道如何定义类来表达一个给定的编程实体。当我需要一个在项目之间重用的类型时,我们通常创建一个C#类,为该类提供必需的一系列属性、方法和事件等。但有时候,我们可能需要定义类来封装一些相关数据,而不需要任何相关联的方法、事件。并且,给类不需要在项目间重用。尽管如此,我们还是得定义一个“临时”类,虽然工作不是很复杂,但是如果需要定义类来封装很多数据成员的话,那么将消耗你大量的劳动时间。我想,大家都不会希望把编程变成一项机械运动吧。

C# 3.0提供的匿名类型正是为了上述任务而生,匿名类型是匿名方法的自然延伸,可以帮助我们轻松的完成上面的工作。

定义一个匿名类型时,使用新的关键字var和之前介绍的对象初始化语法,如下示例:

        static void TestAnonymousType()
{
// 构造一个匿名对象表示一个雇员
var worker = new { FirstName = "Vincent", LastName = "Ke", Level = 2 };

// 显示并输出
Console.WriteLine("Name: {0}, Level: {1}", worker.FirstName + "" + worker.LastName, worker.Level);
}

使用上述代码来构建匿名对象时,C#编译器会在编译时自动生成名称唯一的类。因为这个类的名字在C#中是不可见的,所以必需使用var关键字来使用隐式类型化。另外,我们需要通过对象初始化语法来定义一系列属性来封装各个数据。

匿名类型的内部表示

所有的匿名类型都自动继承自System.Object,我们可以在隐式类型话的worker上面调用ToString()、GetHashCode()、Equals()、GetType()等方法。

我们可以定义如下方法来查看匿名类型的信息:

        static void ReflectAnonymousType(object obj)
{
Console.WriteLine("Type Name: {0}", obj.GetType().Name);
Console.WriteLine("Base Class: {0}", obj.GetType().BaseType);
Console.WriteLine("obj.ToString() = {0}", obj.ToString());
Console.WriteLine("obj.GetHashCode() = {0}", obj.GetHashCode());
}

static void TestAnonymousType()
{
// 构造一个匿名对象表示一个雇员
var worker = new { FirstName = "Vincent", LastName = "Ke", Level = 2 };
ReflectAnonymousType(worker);
}

结果如下:

上例中,worker的类型是<>f__AnonymousType0`3(各版本之中可能会有所不同),匿名类型的类型名完全由编译器决定。更重要的是,使用对象初始化语法定义的每一个名称/值对被映射为同名的只读属性以及被封装的私有数据成员。

方法ToString()和GetHashCode()的实现

从上面可以看到,匿名类型直接了System.Object,并且重写了Equals()、GetHashCode()、ToString()方法。其中ToString()根据每一个名称/值对,生成并返回一个字符串,见上图。

GetHashCode()的实现使用每一个匿名类型的成员变量来计算散列值。当且仅当两个匿名类型有相同的属性别且被赋予相同的值时,就会产生相同的散列值,这样,匿名类型就可以很好的和Hashtable容器一起工作。

匿名类型的相等语义

编译器重写的Equals()在判断对象时使用了基于值的语义,但编译器并没有重载(==和!=)相等运算符,因此使用==比较两个匿名对象时,是基于引用的语义!”==”比较引用是对所有类的默认行为。如下例:

        static void AnonymousTypeEqualityTest()
{
// 构建两个匿名类型,拥有相同的名称/值对
var worker1 = new { FirstName = "Harry", SecondName = "Folwer", Level = 2 };
var worker2 = new { FirstName = "Harry", SecondName = "Folwer", Level = 2 };

// Equals测试
if (worker1.Equals(worker2))
Console.WriteLine("worker1 equals worker2");
else
Console.WriteLine("worker1 not equals worker2");

// ==测试
if (worker1 == worker2)
Console.WriteLine("worker1 == worker2");
else
Console.WriteLine("worker1 != worker2");

// Type Name测试
if (worker1.GetType().Name == worker2.GetType().Name)
Console.WriteLine("we are both the same type");
else
Console.WriteLine("we are different types");
}

结果为:

posted @ 2011-10-26 12:45  Life a Poem  阅读(15361)  评论(28编辑  收藏  举报