C# 3.0 新语言特性（第一部分）

引言

在这篇文章中，我将阐述 C# 3.0 的一些新的语言和编译器特性，并在第二部分中阐述其余的特性。首先，让我们定义所有的新特性

1. 隐式类型局部变量和数组
2. 对象初始化器
3. 集合初始化器
4. 扩展方法
5. 匿名类型
6. Lambda 表达式
7. 查询关键字
8. 自动实现属性
9. 分部方法定义

在本文中，我将用代码示例定义前四个特性，使其清晰明了。

隐式类型局部变量和数组

现在我们可以使用推断类型而不是使用显式类型，这意味着将任何局部变量声明为 `var`，并且该类型将由编译器从初始化语句右侧的表达式推断出来。
这种推断类型可以是

• 内置类型
• 匿名类型（稍后讨论）
• 用户定义的类型
• .NET Framework 类库中定义的类型

现在让我们看看如何使用 `var` 声明局部变量

var int_variable = 6;                 // int_variable is compiled as an int
var string_variable = "Mony";         // string_variable is compiled as a string
var int_array = new[] { 0, 1, 2 };    // int_array is compiled as int[]


// Query is compiled as IEnumerable
var Query =
    from c in customers
    where c.Name == "Mony"
    select c;

// anonymous_variable is compiled as an anonymous type
var anonymous_variable = new { Name = 
var list = new List"Mony", Job = "Web Developer" };

// Implicitly Typed Arrays
 var int_array = new[] { 1, 10, 100, 1000 }; // int[]
 var string_array = new[] { "hello", null, "world" }; // string[]

使用隐式类型变量时的限制如下

• `var` 只能用于在同一语句中声明和初始化局部变量。
• 变量不能初始化为 `null`。
• `var` 不能在类范围内的字段上使用。
• 使用 `var` 声明的变量不能在初始化表达式中使用。换句话说，`var i = i++;` 会产生编译时错误。
• 不能在同一语句中初始化多个隐式类型变量。
• 如果名为 `var` 的类型在范围内，那么如果您尝试使用 `var` 关键字初始化局部变量，您将收到编译时错误。

对象初始化器

有时，您会花费大量时间编写大量冗余代码来声明执行相同工作的构造函数。 对象初始值设定项可用于初始化类型，而无需编写显式构造函数。

代码示例 1

private class Person
{
    // Auto-implemented properties
    public int Age { get; set; }
    public string Name { get; set; }
}

static void Test()
{
    // Object initializer
    Person per = new Person { Age = 22, Name = "Mony" };
}

代码示例 2

class Point
{
    int x, y;
    public int X
    {
        get { return x; }
        set { x = value; }
    }
    public int Y
    {
        get { return y; }
        set { y = value; }
    }
}

当您实例化这个类时，您通常会编写以下代码

Point p = new Point();
p.X = 10;
p.Y = 20;

相反，您可以像这样创建和初始化一个 `Point` 对象

Point p = new Point { X = 10, Y = 20 }; // object initializer

甚至像这样

var p = new Point { X = 10, Y = 20 }; // object initializer

对于复杂的字段，例如角位于点 `p1` 和 `p2` 的正方形或矩形，您可以按如下方式创建 `Rectangle` 类

public class Rectangle
{
    Point p1;
    Point p2;
    public Point ULcorner { get { return p1; } set { p1 = value; } }
    public Point LRcorner { get { return p2; } set { p2 = value; } }
}

您可以像这样创建和初始化 `Rectangle` 对象

var rectangle = new Rectangle { ULcorner = new Point { X = 0, Y = 0 },
            LRcorner = new Point { X = 10, Y = 20 } };

集合初始化器

启用使用初始化列表初始化集合，而不是使用对 `Add` 或其他方法的特定调用。 此初始化具有与对每个集合元素使用 `Add` 方法相同的效果。

public class Person
{
   string _Name;
   List _Intersets = new List();
   public string Name { get { return _Name; } set { _Name =value; } }
   public List Interests { get { return _Intersets; } }
}

class Test
{
   static void Main(string[] args)
  {
    List PersonList = new List();
    Person p1 = new Person();
    p1.Name = "Mony Hamza";
    p1.Interests.Add("Reading");
    p1.Interests.Add("Running");
    PersonList.Add(p1);
    Person p2 = new Person();
    p2.Name = "John Luke";
    p2.Interests.Add("Swimming");
    PersonList.Add(p2);
   }
}

在 C# 3.0 中，您可以编写更少的代码来表达相同的概念

static void Main(string[] args)
{
    var PersonList = new List{
    new Person{ Name = "Mony Hamza", Interests = { "Reading", "Running" } },
    new Person { Name = "John Luke", Interests = { "Swimming"} };
}

扩展方法

扩展方法使您能够“添加”方法到现有类型，而无需创建新的派生类型、重新编译或以其他方式修改原始类型。

要创建扩展方法，请在 `static` 类中将其声明为 `static` 方法。 扩展方法的第一个参数必须是关键字 `this`。

以下是将温度从华氏温度转换为摄氏温度的扩展方法的示例。

namespace MyNameSpace
 {
     public static class MyClass
        {
           public static double ConvertToCelsius(this double fahrenheit)
            {
              return ((fahrenheit – 32) / 1.8); }

            }
        }
}

现在可以像调用实例方法一样调用扩展方法 `ConvertToCelsius`

double fahrenheit = 98.7;
double Celsius = fahrenheit.ConvertToCelsius();

所以它向现有类型 `double` 添加了一个名为 `ConvertToCelisius` 的方法。

希望这篇简单的文章能让 C# 3.0 的新语言特性变得非常清晰。 在下一篇文章中，我将讨论其他五个特性。

期待您的反馈。