在上一篇的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");
}
结果为：
扫一扫
1352
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
