c#3.0新特性（一）:var关键字、自动属性、初始化器和扩展方法

前言：上周闲暇时在公司看了Anders Hejlsberg在PDC08上讲的“The Future of C#”。下面是视频里的截图：

笔者接触c#（主要是2.0）不足两年时间，而且c#2.0很多东西都还没学或者没有学懂。虽然在网上也曾经看过几篇介绍c#3.0的博文，可是看过就没有再使用过，几乎已经真的“忘到姥姥家了”。看到c#变化的如此之快，更加感到恐惧和不安。既然抱了ms的大腿，学习要是没有自发性和积极性，“落后”是早晚的事啊。
现在c#已经有十年历史，最高版本已经到4.0了。在视频里安德斯展现了c#惊人的生产力，对照现在自己的编程水平，恍如隔世，惭愧啊。
言归正传。下面整理下这几天自己的自学笔记，所有代码都在本人的机器上测试通过，本人菜鸟，如有讹误，务请留意。
一、var关键字
如果你有javascript的开发经验，var关键字你一定不会陌生。和js中的var关键字类似，在C#3.0中，var关键字用来定义隐式化的局部变量，看个例子先：

    class Test
    {
        public static void Main()
        {
            /*
             * 使用var关键字的注意点
             * (1) 隐式类型变量定义时必须要定义初始值；
             * (2) 不能用null来初始化；
             * (3) 不能使用var作为方法的返回值或者参数类型；
             * (4) 不能用var定义类的成员；
 `          */
            var i = 0; 
            var str = "jeff wong";
            var obj = new object();
            var isTrue = false;
            var intListArr = new List<int> { 2, 4, 8, 16 };
            Console.WriteLine(i);
            Console.WriteLine(str);
            Console.WriteLine(obj);
            Console.WriteLine(isTrue);
            foreach (var item in intListArr)
            {
                Console.WriteLine(item);
            }
            Console.Read();
        }

其实在使用var关键字时，编译器会根据初始化变量的变量值来推断变量的数据类型，所以var关键字在本质上并没有改变什么。只不过比直接写强类型的数据类型看起来更"灵活"一些，这也就是解释型语言曾经的“优势”。
接着介绍常用的四个新特性，贴代码为主，多操作就熟练了。

二、自动属性（Automatic Properties）

    /// <summary>
    /// AutomaticProperties（自动属性）
    /// </summary>
    public class AutomaticProperties
    {
        public int Tid { get; set; } //快捷键:键入prop 然后tab键两次

        // 上面的Tid属性（自动属性）等同于下面的Tid属性
        //private int tid;
        //public int Tid
        //{
        //    get { return tid; }
        //    set { tid = value; }
        //}

三、对象初始化器（Object Initializers）

    /// <summary>
    /// 对象初始化器
    /// </summary>
    public class User
    {
        //自动属性
        public string Name { get; set; }
        public int Age { get; set; }

        public static void Mains()
        {
            User myUser = new User { Name = "jeff wong", Age = 25 };

            // 上面的myUser对象（对象初始化器）等同于下面的myUser对象
            //User myUser = new User();
            //myUser.Name = "jeff wong";
            //myUser.Age = 25;

        }

四、集合初始化器（Collection Initializers）

 /// <summary>
    /// 集合初始化器
    /// </summary>
    public class User
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public static void Main()
        {
            //集合初始化器
            List<User> users = new List<User> 
            { 
                new User{Name="jeff wong",Age=25}, //对象初始化器
                new User { Name = "xiao wang", Age = 26 },
                new User { Name = "xiao chen", Age = 30 } 
            };

            // 上面的users集合（集合初始化器）等同于下面的users集合
            // List<User> users = new List<User>();
            // users.Add(new User { Name="jeff wong",Age=25});
            // users.Add(new User { Name = "xiao wang", Age = 26  });
            // users.Add(new User { Name = "xiao chen", Age = 30  });

            foreach (var item in users)
            {
                Console.WriteLine(item.Name + "'s age is " + item.Age);
            }

            Console.ReadLine();

        }
    }

五、扩展方法（Extension Method）

"扩展方法使您能够向现有类型“添加”方法，而无需创建新的派生类型、重新编译或以其他方式修改原始类型。扩展方法是一种特殊的静态方法，但可以像扩展类型上的实例方法一样进行调用。"通常，建议您只在不得已的情况下才实现扩展方法，并谨慎地实现。只要有可能，必须扩展现有类型的客户端代码都应该通过创建从现有类型派生的新类型来达到这一目的"。
如果你有javascript的开发经验，相信对js的原型（prototype）不会陌生，这里的扩展方法其实类似于js的原型方式。举例来说：
Q：去掉字符串两端的特殊字符"-"
1、javascript实现方式

// 去掉字符串两端的特殊字符"-"
String.prototype.TrimMinus = function() {
    return this.replace(/(^[-]+)|([-]+$)/g, "");
}
var strTest="-jeff wong-";
alert(strTest.TrimMinus()); //调用

2、看下c#扩展方法如何发挥：

    /// <summary>
    /// ExtensionMethods (扩展方法)
    /// </summary>
    public class ExtensionMethods
    {
        public static void Main()
        {
            string testStr = "-jeff wong test-";
            Console.WriteLine(testStr.TrimMinus());

            string[] strArr= new string[] { "a", "b", "c" };
            //使用object的In()扩展方法
              bool b = "b".In(strArr);
            //b == true
            Console.WriteLine(b);
            Console.ReadLine();
        }
    }

    /// <summary>
    /// 扩展方法（类和方法均为static）
    /// 使用的时候要引用该类的命名空间
    /// </summary>
    public static class MyExtensionMethods
    {
        // this代表扩展方法应用于string类型上
        public static string TrimMinus(this string str)
        {
            return str.Trim(new char[] { '-' });
        }

        // this代表扩展方法应用于object类型上
        // 该扩展方法需要一个类型为System.Collections.IEnumerable的参数
        // In()是判断一个object是否存在于一个System.Collections.IEnumerable中的扩展方法
        public static bool In(this object o, System.Collections.IEnumerable e)
        {
            foreach (object i in e)
            {
                if (i.Equals(o))
                {
                    return true;
                }
            }

            return false;
        }
    }

ps:上述js的原型扩展和c#的扩展方法功能是一样的,就是string这个类添加一个扩展方法,使得所有这个类的实例化对象能够直接使用这个方法.