CSharp3.0锐利初体验（一）

 
装了VS2008 beta 2 ,今天小爽了一把CSharp3.0,总的感受就是微软帮程序员又分担了很多负担，编译器的编写者试着将程序员的一些冗余工作交给编译器去完成，程序员写起代码来更加顺畅。从语言的角度来讲，C#的抽象程度越来越高了。

下面这个程序包含了一部分C#3.0的新特征：

  1using System;
  2
  3using System.Collections.Generic;
  4
  5using System.Text;
  6
  7using System.Threading;
  8
  9 
 10
 11namespace CSharp3
 12
 13{
 14
 15    class Program
 16
 17    {
 18
 19        static void Main(string[] args)
 20
 21        {
 22
 23            //扩展方法
 24
 25            string s = "aa2ss";
 26
 27            s.ExMethod();
 28
 29 
 30
 31            //对象初始化器
 32
 33            //对象初始化器的出现，减少了冗余代码
 34
 35            //直接在实例化类的同时就初始化了字段，但是这跟构造函数是不同的
 36
 37            myPoint my = new myPoint { X = 0, Y = 1 };
 38
 39            Console.WriteLine("X of my =" + my.X.ToString());
 40
 41            Console.ReadKey();
 42
 43 
 44
 45            //匿名类型
 46
 47            //编译器会根据属性来推断相应的类型
 48
 49            //有var的地方就有推断
 50
 51            Console.Clear();
 52
 53            var p1 = new { X = 32, Y = 45 };
 54
 55            Console.WriteLine(
 56
 57"p1 is :{0},and p1.X={1}" ,
 58
 59p1.GetType().ToString(),p1.X);
 60
 61            Console.ReadKey();
 62
 63 
 64
 65            //Lambda表达式 
 66
 67            Console.Clear();
 68
 69            LambdaClass.testLambda1();
 70
 71            Console.WriteLine("********************");
 72
 73            LambdaClass.testLambda2();
 74
 75            Console.ReadKey();
 76
 77        }
 78
 79 
 80
 81    }
 82
 83 
 84
 85    /**//// <summary>
 86
 87    /// 扩展方法
 88
 89    /// </summary>
 90
 91    public static class Extensions
 92
 93    {
 94
 95        /**//// <summary>
 96
 97        /// 扩展方法实际上提供了一种给已定义类添加或者追加方法的方便途径
 98
 99        /// 这里this关键字是个标示符，this后面的类型定义了要给哪个类追加方法
100
101        /// </summary>
102
103        /// <param name="s"></param>
104
105        public static void ExMethod(this string s)
106
107        {
108
109            Console.WriteLine("This is a Extension Method!!");
110
111            Console.ReadKey();
112
113            Console.Clear();
114
115        }
116
117    }
118
119 
120
121    /**//// <summary>
122
123    /// 对象初始化器例子
124
125    /// </summary>
126
127    public class myPoint
128
129    {
130
131        int x, y;
132
133 
134
135        public int Y
136
137        {
138
139            get { return y; }
140
141            set { y = value; }
142
143        }
144
145        public int X
146
147        {
148
149            get { return x; }
150
151            set { x = value; }
152
153        }
154
155    }
156
157 
158
159    # region Lambda Expressions
160
161 
162
163   public delegate int myDelegate(int a,int b);
164
165 
166
167    /**//// <summary>
168
169   /// Lambda表达式本身是一个委托类型
170
171    /// </summary>
172
173    public class LambdaClass
174
175    {
176
177        public static void myMethod(myDelegate myDele)
178
179        {
180
181          Console.WriteLine(
182
183"Let's have a see what was represented by the delegate:\n{0}",
184
185              myDele.Method.ToString());
186
187          Console.WriteLine("the result of culculating between 8 & 8 is :");
188
189          Console.WriteLine(myDele.Invoke(8, 8));
190
191        }
192
193 
194
195        /**//// <summary>
196
197        /// 甚至无须声明参数类型，因为编译器会在匹配的委托里找到它们的类型
198
199        /// </summary>
200
201        public static void testLambda1()
202
203        {
204
205            LambdaClass.myMethod((x,y) =>x*y);
206
207        }
208
209 
210
211        /**//// <summary>
212
213        /// 很自然的方式，可以替代匿名方法，或者作为一个匿名的委托
214
215        /// </summary>
216
217        public static void testLambda2()
218
219        {
220
221            Thread t = new Thread(() =>
222
223                {
224
225                        Console.WriteLine("This is a Lambda Expression!");
226
227                });
228
229            t.Start();           
230
231        }
232
233    }
234
235    #endregion
236
237}
238
239

 的确写得比较爽，体现了“以人文本”的思想. 编译器似乎是程序员的一个朋友，为程序员分担了很多工作，编译器会经常猜到程序员写的是什么，当然前提是你写的程序为编译器的推断提供了充分合理的理由。我想这也是一个趋势吧，让程序员coding时更惬意，更自然，更像”人”一样开发，而不是处处要迎合机器的思维.恩，也许不久以后CSharp会像word一样普及的，期待中...