C#3.0 新特性速览(1)

转载 2007年09月26日 09:08:00

  微软最近的动作频繁,C#2.0规范才刚推出不久,我还没来的及完全消化C#2.0中的所有新特性,而今又推出了C#3.0,在短短几年中,微软就对C#进行了两次大的升级,为C#加入了许多新的特性,从而使C#变得更加强大也更加现代了。下面我就把C#3.0中的新特性的要点列出来,以供大家快速浏览。


第一个特性:隐式类型化本地变量

  这个特性非常简单,有些JavaScript的影子,我们可以统一使用使用"var"关键字来声明局部变量,而不再需要指明变量的确切类型了,变量的确切类型可通过声明变量时的初始值推断出来。这样一来,可以大大简化我们声明局部变量的工作量了,下面是一个例子:

   1:      class  : AppRunner.
   2:      {
   3:          public override void Run()
   4:          {
   5:               intValue = 5;
   6:               stringValue = ;
   7:               customClass = new ();
   8:               intArray = new int[3] { 1, 2, 3 };
   9:   
  10:              foreach (  in intArray)
  11:                  .WriteLine(
  12:          }
  13:      }

上面的代码将被解析成:

   1:      class  : AppRunner.
   2:      {
   3:          public override void Run()
   4:          {
   5:              int intValue = 5;
   6:              string stringValue = ;
   7:               customClass = new ();
   8:              int[] intArray = new int[3];
   9:   
  10:              foreach (int  in intArray)
  11:                  .WriteLine(value);            
  12:          }
  13:      }

  要特别注意的是,由于变量的类型是通过变量初始值推断而来的,所以在声明变量的同时必需为变量指定初始值。并且,变量并不是没有类型的,变量一旦初始化之后,类型就确定下来了,以后就只能存储某种类型的值了,比如上面的stringValue的类型经推断为string,所以该变量就只能保存string类型的值了。


第二个特性:匿名类型 

  有些时候我们需要临时保存一些运算的中间结果,特别是当这些中间结果是由多个部份组成时,我们常常会去声明一个新的类型,以方便保存这些中间结果。表面上看起来这很正常,而细想之后就会发现,这个新类型只服务于这个函数,其它地方都不会再使用它了,就为这一个函数而去定义一个新的类型,确实有些麻烦。

  现在,C#3.0中的匿名类型特性就可以很好的解决上面提到的问题,通过匿名类型,我们可以简单使用new { 属性名1=值1, 属性名2=值2, ..... , 属性名n=值n }的形式直接在函数中创建新的类型,看下面这个例子:

   1:      class  : AppRunner.
   2:      {
   3:          public override void Run()
   4:          {
   5:               anonymousType1 = new {
CardNumber = , Name = , Sex = true
                 };
   8:   
   9:              .WriteLine(anonymousType1.CardNumber);
  10:              .WriteLine(anonymousType1.Name);
  11:   
  12:               anonymousType2 = new {
                    CardNumber = , Name = , Sex = true
                };
  15:   
  16:              anonymousType2 = anonymousType1;
            }
        }

  在新类型中只能有字段成员,而且这些字段的类型也是通过初值的类型推断出来的。如果在声明新的匿名类型时,新类型的字段名、顺序以及初始值的类型是一致的,那么将会产生相同的匿名类型,所以上例中anonymousType1和anonymousType2的类型是相同的,自然能进行anonymousType2=anonymousType1的赋值。


第三个特性:
隐式类型化数组

  这个特性是对隐式类型化本地变量的扩展,有了这个特性,将使我们创建数组的工作变得简单。我们可以直接使用"new[]"关键字来声明数组,后面跟上数组的初始值列表。在这里,我们并没有直接指定数组的类型,数组的类型是由初始化列表推断出来的。

   1:      class  : AppRunner.
   2:      {
   3:          public override void Run()
   4:          {
   5:               intArray = new[] { 1, 2, 3, 4, 5 };
   6:               doubleArray = new[] { 3.14, 1.414 };
   7:               anonymousTypeArray = new[] {
   8:                  new { Name=, Sex=false, Arg=22 },
   9:                  new { Name=, Sex=true, Arg=23 }
  10:              };
  11:   
  12:              .WriteLine(intArray);
  13:              .WriteLine(doubleArray);
  14:              .WriteLine(anonymousTypeArray[0].Name);
  15:          }
  16:      }

  上面的代码中,anonymousTypeArray变量的声明同时运用了隐式类型化数组和匿名类型两种特性,首先创建匿名类型,然后再初始值列表,推断出数组的确切类型。


第四个特性:对象构造者

  我们在声明数组时,可以同时对其进行初始化,这样就省去了很多麻烦,但是在创建类的对象时,这招可就不灵了,我们要么调用该类的构造函数完成对象的初始化,要么就手工进行初始化。这两种方法都不太方便,使用构造函数来对对象进行初始化时,我们为了某种灵活性,可能需要编写构造函数的多个重载版本,实在是麻烦。

  C#3.0中加入的对象构造者特性,使得对象的初始化工作变得格外简单,我们可以采用类似于数组初始化的方式来初始化类的对象,方法就是直接在创建类对象的表达式后面跟上类成员的初始化代码。具体示例如下:

   1:     class 
   2:     {
   3:          public int X { ; ; }
   4:          public int Y { ; ; }
   5:   
   6:          public override string ToString()
   7:          {
   8:              return  + X.ToString() +  + Y.ToString() + ;
   9:          }
  10:      }
  11:   
  12:      class 
  13:      {
  14:          public  P1 { ; ; }
  15:          public  P2 { ; ; }
  16:   
  17:          public Rectangle()
  18:          {
  19:              P1 = new ();
  20:              P2 = new ();
  21:          }
  22:   
  23:          public override string ToString()
  24:          {
  25:              return  + P1 +  + P2;
  26:          }
  27:      }
  28:   
  29:      class  : AppRunner.
  30:      {
  31:          public override void Run()
  32:          {
  33:               thePoint = new () { X = 1, Y = 2 };
  34:              .WriteLine(, thePoint);
  35:   
  36:               theRectangle = new () { 
                    P1 = { X = 1, Y = 1 }, P2 = { X = 100, Y = 200 } 
                };
  39:              .WriteLine(theRectangle);
  30:          }
  41:      }

  我们在定义Point类的X和Y属性时,只须写上该属性的get和set访问器声明,C#编译器会自动为我们生成默认的get和set操作代码,当我们需要定义简单属性时,这个特性非常有用。

  我们以new Point() { X = 1, Y = 2 }语句,轻松的完成了对Point类的初始化工作。在创建类的对象时,我们可以按照需要去初始化类的对象,只要在类的创建表达式后跟上要初始化属性的列表即可,且可以只对需要初始化的属性赋初值,而无需把所有属性的初始值都写上去。

  在theRectangle对象的初始化表达式中,我们首先对P1属性进行初始化,然而P1属性也是一个自定义的类型,所以P1属性的初始化是另一个类型(Point)的初始化表达式,我们可以这样的方式来对更加复杂的类型进行初始化。

  未完待续.........
 

C#3.0新特性速览(1)

微软最近的动作频繁,C#2.0规范才刚推出不久,我还没来的及完全消化C#2.0中的所有新特性,而今又推出了C#3.0,在短短几年中,微软就对C# 进行了两次大的升级,为C#加入了许多新的特性,从而使C...

C#3.0中的新特性(1)

1. 隐式类型 以前这样声明变量: string str = "Hello World"; 现在可以写成: var str = "Hello World"; str仍然被认为是string类...

C#3.0新特性(三)- 详说自动属性和匿名类型

一、自动实现的属性   全称应该叫自动实现的属性(Auto-implemented properties),在上一篇中,给了简单的例子,说的是当属性访问器中不需要其他逻辑时,自动实现的属性可使属性声明...

VS2008 c#3.0新特性之var源码

  • 2010年10月16日 23:43
  • 32KB
  • 下载

c#3.0中的新特性(2)

7. 扩展方法 扩展方法就是给一个既有的类添加新的方法,这在以前是不可思议的事情,在C#3.0里却是很简单: public static class MethodsExtentions { ...

c#3.0新特性使用lambda表达式创建表达式树

c#3.0新特性使用lambda表达式创建表达式树2009年8月18日 云飞扬 发表评论 阅读评论 -c#3.0新特性使用lambda表达式创建表达式树题外话:这空间访问速度真慢,在我发布文章的时候,...
  • rise51
  • rise51
  • 2011年01月19日 18:02
  • 236

C#3.0与VB9.0的新特性介绍

  • 2008年03月26日 10:24
  • 2.34MB
  • 下载

C#3.0 新特性

1 具有隐式类型的局部变量 2 扩展方法 2.1 声明扩展方法 2.2 导入扩展方法 2.3 扩展方法的调用 3 拉姆达表达式 3.1 拉姆达表达式转换 3.2 类型...
  • JGL5987
  • JGL5987
  • 2012年06月07日 13:26
  • 3774

C#3.0新特性

C#3.0新特性速览(1)微软最近的动作频繁,C#2.0规范才刚推出不久,我还没来的及完全消化C#2.0中的所有新特性,而今又推出了C#3.0,在短短几年中,微软就对C#进行了两次大的升级,为C#加入...

C#3.0的新特性

总体来说,Visual Studio 2008和.NET 3.5是建立在.NET2.0核心的基础之上,.NET2.0核心本身将不再变化(如果不了解.NET2.0的朋友,请参看MSDN或者一些经典的书籍...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:C#3.0 新特性速览(1)
举报原因:
原因补充:

(最多只允许输入30个字)