【笔记】《编写高质量代码：改善c#程序的157个建议》第1章 基本语言要素（SamWang)

**************************************************************************

该书在线阅读：编写高质量代码：改善C#程序的157个建议

源代码下载：点我下载

**************************************************************************

第1章　基本语言要素 / 2

-------------------------------

建议1：正确操作字符串 / 2

-------------------------------

• 确保尽量少的装箱
• 避免分配额外的内存空间

　　注：string是个特殊的引用类型，一旦赋值就不可改变。在运行时调用System.String类中的任何方法或进行任何运算，都会在内存中创建一个新的字符串对象，这也意味着要为该新对象分配新的内存空间。

　　　　而StringBuilder不会重新创建一个string对象。

　　　　所以一旦需要对string类型进行多次操作，就应该用StringBulider，减少性能损耗！

---------------------------------

建议2：使用默认转型方法 /6 

---------------------------------

• 使用类型的转换运算符：

　　　implicit (隐式)、explicit(显示) + operator，同时必须加上public与static

      public static implicit operator Cat(Animal a)
      {
         return new Cat() { Name = "Cat:" + a.Name };
      }

　　  （一般不建议用户对自己的类型重载转换运算符。如需用户自定义的类型之间需要转换，建议从面向对象的角度考虑，因为它们一般都含有某种关系（如继承、实现等）。在这种情况下，就应该使用第四种方法：CLR支持的转型。） 

• 使用类型内置的Parse、TryParse，或者如ToString、ToDouble、ToDateTime等方法。
• 使用帮助类提供的方法。

　　　即System.Convert。该类还支持将任何自定义类型转换为任何基元类型，只需继承IConvertible接口即可。

　　  System.BitConvert提供了基元类型与字节数组之间相互转换的方法。

　　  注意 所谓“基元类型”：是指编译器直接支持的数据类型，即直接映射到FCL中的类型。基元类型包括：sbyte / byte / short / ushort / int / uint / long / ulong / char / float / double / bool / decimal /object / string。

• 博文链接：C#基元类型、引用类型和值类型以及装箱拆箱

• 使用CLR支持的转型

　　  即上溯转型和下溯转型。也是我们平时说的向上转换和向下转换。实际上就是基类与子类之间的相互转换。

         Animal animal;          //Animal为基类
          Dog dog = new Dog();    //Dog为Animal的子类
          animal = dog;           //隐式转换，通过。
          //dog = animal;         //编译不通过。基类到子类不支持隐式
          dog = (Dog)animal;      //通过，执行成功！

          //此处需注意，上面能显示转换animal = dog这句话，此次animal保存的对象来之dog
         Animal a = new Animal();
         Dog d = (Dog)a;         //编译通过，执行失败，不允许将Animal类型转换为Dog类型

------------------------------------------

建议3：区别对待强制转型与as和is /9 

------------------------------------------

　　如果类型之间都上溯到某个共同的基类，那么根据此基类进行的转型（即基类转型为子类本身）应该使用as。子类与子类之间的转型，则应该提供转换操作符，以便进行强制转型。

　　当能使用as的情况下，都应该使用as，因为as更安全效率更高。而且结合is使用更加完美。

　　但as有个问题，即它不能操作基元类型。

---------------------------------------

建议4：TryParse比Parse好 / 12 

---------------------------------------

　　TryParse无需处理异常，效率快于Parse，尤其是在解析失败的时候！因此也有了一种模式叫TryParse模式。

-----------------------------------------------------

建议5：使用int?来确保值类型也可以为null / 15  

-----------------------------------------------------

　　从.net2.0开始，FCL中提供了一个额外的类型：可以为空的类型Nullable<T>，简写T?

　　它是个结构体，只有值类型才可以作为“可空类型”（引用类型本身就能为NULL）。

　　基元类型能隐式转换为可空类型：　　

　　int i = 0;
　　int? j = i;

　　但可空类型不能直接转换为基元类型，需要使用null 合并运算符：??

　　?? 运算符定义当可以为 null 的类型分配给非可以为 null 的类型时返回的默认值。

　　int? i = null;
　　int j = i??0; //j=0

 博文链接：c#各种运算符

-----------------------------------------------------

建议6：区别readonly和const的使用方法 / 16

-----------------------------------------------------

• const是一个编译器变量，static readonly是一个运行时常量
• const只能修饰基元类型、枚举类型或字符串类型，readonly没有限制。
• readonly只能用于类成员，不能用于方法的局部变量。const无此限制。
• const 字段只能在该字段的声明中初始化。 readonly 字段可以在声明或构造函数中初始化。（对于实例字段，在包含字段声明的类的实例构造函数中；或者，对于静态字段，在包含字段声明的类的静态构造函数中）

　  注意：

1. const本身是编译期常量，所以就是static的，加上static会编译错误。
2. readonly灵活性大于const，但性能却略低于const（极小）。所以推荐尽量使用readonly。
3. readonly变量是运行时变量，只能在声明或构造函数中初始化（能在构造函数中多次赋值），在其他地方“不可以更改”。

　　　 “不可以更改”有两层含义：

• • 对于值类型变量，值本身不可以改变（readonly，只读）
  • 对于引用类型变量，引用本身（相当于指针）不可改变，但是其成员可被改变。

　　　　　　Sample2 sample2 = new Sample2(new Student() { Age = 10 });
　　　　　　sample2.ReadOnlyValue.Age = 20; //成功 

　　博文链接：C# const和static readonly区别

-----------------------------------------

建议7：将0值作为枚举的默认值 / 19

-----------------------------------------

 　　看下面的例子：

        enum Week
        {
            Monday = 1,
            Tuesday = 2,
            Wednesday = 3,
            Thursday = 4,
            Friday = 5,
            Saturday = 6,
            Sunday = 7
        }

        static Week week;

        static void Main(string[] args)
        {
            Console.WriteLine(week); //0
        }

　　输出结果为：0；因为枚举内容为int类型。所以默认值始终取0。

　　同时还能给枚举赋值其他整型数值。　　

Week week = (Week)9;

------------------------------------------------------

建议8：避免给枚举类型的元素提供显式的值 / 20

------------------------------------------------------

　　先看段例子：

        enum Week
        {
            Monday = 1,
            Tuesday = 2,
            ValueTemp,
            Wednesday = 3,
            Thursday = 4,
            Friday = 5,
            Saturday = 6,
            Sunday = 7
        }

        static void Main(string[] args)
        {
            Week week = Week.ValueTemp;
            Console.WriteLine(week);
            Console.WriteLine(week == Week.Wednesday);

        }

输出结果为：

　　Wednesday

　　True

 　　

　　红色的ValueTemp就是新增加的枚举值，出现上面的问题是因为当枚举元素没有被显示赋值时，编译器会为那些未赋值元素逐个+1赋值。

　　因此ValueTemp被赋值为3。而枚举中允许出现重复值，也就是多次赋值效果。换句话说3被赋值给Wednesday。

---------------------------------

建议9：习惯重载运算符 / 22

---------------------------------　　

    class Program
    {
        static void Main(string[] args)
        {
            Salary mikeIncome = new Salary() { RMB = 22 };
            Salary roseIncome = new Salary() { RMB = 33 };
            //Salary familyIncome = Salary.Add(mikeIncome, roseIncome);
            Salary familyIncome = mikeIncome + roseIncome;
        }
    }

    class Salary
    {
        public int RMB { get; set; }

        public static Salary operator +(Salary s1, Salary s2)
        {
            s2.RMB += s1.RMB;
            return s2;
        }
    }

----------------------------------------------------------------

建议10：创建对象时需要考虑是否实现比较器 / 23

----------------------------------------------------------------

　　一般对需要比较或排序的对象，继承IComparable<T>接口，实现默认比较器。如果需要其他比较可以如下例子中创建非默认的比较器。

     class Program
     {
         static void Main(string[] args)
         {
             List<Salary> companySalary = new List<Salary>()
                 {
                     new Salary() { Name = "Mike", BaseSalary = 3000, Bonus = 1000 },
                     new Salary() { Name = "Rose", BaseSalary = 2000, Bonus = 4000 },
                     new Salary() { Name = "Jeffry", BaseSalary = 1000, Bonus = 6000 },
                     new Salary() { Name = "Steve", BaseSalary = 4000, Bonus = 3000 }
                 };
             companySalary.Sort(); //根据自带的进行排序，按BaseSalary
             //companySalary.Sort(new BonusComparer());    //提供一个非默认的比较器，按Bonus
             foreach (Salary item in companySalary)
             {
                 Console.WriteLine(string.Format("Name:{0} \tBaseSalary:{1} \tBonus:{2}", item.Name, item.BaseSalary, item.Bonus));
             }
         }
     }
 
     class Salary : IComparable<Salary>
     {
         public string Name { get; set; }
         public int BaseSalary { get; set; }
         public int Bonus { get; set; }
 
         #region IComparable<Salary> 成员
 
         public int CompareTo(Salary other)
         {
             return BaseSalary.CompareTo(other.BaseSalary);
         }
 
         #endregion
     }
 
     class BonusComparer : IComparer<Salary>
     {
         #region IComparer<Salary> 成员
 
         public int Compare(Salary x, Salary y)
         {
             return x.Bonus.CompareTo(y.Bonus);
         }
 
         #endregion
     }

-----------------------------------------

建议11：区别对待==和Equals / 27

-----------------------------------------

　　相等性比较主要有三种：运算符==、Equals、ReferenceEquals（引用比较）。

• 对于值类型，如果类型的值相等，就应该返回True。
• 对于引用类型，如果类型指向同一个对象，则返回True。

    class Program
    {
        static void Main(string[] args)
        {
            //ValueTypeOPEquals();
            //ReferenceTypeOPEquals();
            //ValueTypeEquals();
            ReferenceTypeEquals();
        }

        static void ValueTypeOPEquals()
        {
            int i = 1;
            int j = 1;
            //True
            Console.WriteLine(i == j);
            j = i;
            //True
            Console.WriteLine(i == j);
        }

        static void ReferenceTypeOPEquals()
        {
            object a = 1;
            object b = 1;
            //False
            Console.WriteLine(a == b);
            b = a;
            //True
            Console.WriteLine(a == b);
        }

        static void ValueTypeEquals()
        {
            int i = 1;
            int j = 1;
            //True
            Console.WriteLine(i.Equals(j));
            j = i;
            //True
            Console.WriteLine(i.Equals(j));
        }


        static void ReferenceTypeEquals()
        {
            object a = new Person("NB123");
            object b = new Person("NB123");
            //False,重载后True
            Console.WriteLine(a.Equals(b));
            Console.WriteLine(a.Equals(b as Person));
            Console.WriteLine(a as Person == b as Person);
            //false
            Console.WriteLine(a == b); //用object的==判断
            Console.WriteLine(object.ReferenceEquals(a,b));
            b = a;
            //True
            Console.WriteLine(a.Equals(b));
            Console.WriteLine(a.Equals(b as Person));
            Console.WriteLine(a as Person == b as Person);
            Console.WriteLine(a == b);
            Console.WriteLine(object.ReferenceEquals(a, b));
        }
    }

    class Person
    {
        public string IDCode { get; private set; }

        public Person(string idCode)
        {
            this.IDCode = idCode;
        }

        public override bool Equals(object obj)
        {
            return IDCode == (obj as Person).IDCode;
        }

        public bool Equals(Person p)
        {
            return IDCode == p.IDCode;
        }

        public static bool operator ==(Person p1, Person p2)
        {
            return p1.IDCode == p2.IDCode;
        }

        /// <summary>
        /// 必须同时重载==与!=
        /// </summary>
        public static bool operator !=(Person p1, Person p2)
        {
            return !(p1 == p2);
        }
    }

-----------------------------------------------------------

建议12：重写Equals时也要重写GetHashCode / 29

-----------------------------------------------------------

 　　例子：

    class Program
    {
        static Dictionary<Person, PersonMoreInfo> PersonValues = new Dictionary<Person, PersonMoreInfo>();
        static void Main(string[] args)
        {
            AddAPerson();
            Person mike = new Person("NB123");
            Console.WriteLine(mike.GetHashCode());
            Console.WriteLine(PersonValues.ContainsKey(mike));

            //string str1 = "NB0903100006";
            //string str2 = "NB0904140001";
            //Console.WriteLine(str1.GetHashCode());
            //Console.WriteLine(str2.GetHashCode());
        }

        static void AddAPerson()
        {
            Person mike = new Person("NB123");
            PersonMoreInfo mikeValue = new PersonMoreInfo() { SomeInfo = "Mike's info" };
            PersonValues.Add(mike, mikeValue);
            Console.WriteLine(mike.GetHashCode());
            Console.WriteLine(PersonValues.ContainsKey(mike));
        }

    }

    class Person : IEquatable<Person>
    {
        public string IDCode { get; private set; }

        public Person(string idCode)
        {
            this.IDCode = idCode;
        }

        public override bool Equals(object obj)
        {
            return IDCode == (obj as Person).IDCode;
        }

        public override int GetHashCode()
        {
            //return this.IDCode.GetHashCode();
            return (System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName + "#" + this.IDCode).GetHashCode();
        }

        public bool Equals(Person other)
        {
            return IDCode == other.IDCode;
        }
    }

    class PersonMoreInfo
    {
        public string SomeInfo { get; set; }
    }

　　上面代码中当不重写GetHashCode时输出为：

　　

 　　基于键值的集合（如上面的DIctionary）会根据Key值来查找Value值。CLR内部会优化这种查找，实际上，最终是根据Key值的HashCode来查找Value值。

　　Object为所有的CLR类型都提供了GetHashCode的默认实现。每new一个对象，CLR都会为该对象生成一个固定的整型值，该整型值在对象的生存周期内不会改变，而该对象默认的GetHashCode实现就是对该整型值求HashCode。

　　简单重写GetHashCode，

        public override int GetHashCode()
        {
            return this.IDCode.GetHashCode();
        }

　　输出为：

　　

　　尽管这里GetHashCode已经实现了，但是还存在另外一个问题，它永远只返回一个整型类型，而整型类型的容量显然无法满足字符串的容量，以下的例子就能产生两个同样的HashCode。

      string str1 = "NB0903100006";
     string str2 = "NB0904140001";
     Console.WriteLine(str1.GetHashCode());
     Console.WriteLine(str2.GetHashCode());

 　　

　　为了减少两个不同类型之间根据字符串产生相同的HashCode的几率，一个稍作改进版本的GetHashCode方法：　　

        public override int GetHashCode()
        {
            return (System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName + "#" + this.IDCode).GetHashCode();
        }

 　　　

-------------------------------------------- 

建议13：为类型输出格式化字符串 / 32 

--------------------------------------------

　　输出格式化字符串一般有两种

• 简单重写ToString()方法
• 继承IFormattable接口，实现其方法ToString。

　　代码如下：

    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person() { FirstName = "Jessica", LastName = "Hu", IDCode = "NB123" };
            Console.WriteLine(person.ToString());
            Console.WriteLine(person.ToString("Ch", null));
            Console.WriteLine(person.ToString("En", null));
        }
    }

    class Person : IFormattable
    {
        public string IDCode { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }

        //实现接口IFormattable的方法ToString
        public string ToString(string format, IFormatProvider formatProvider)
        {
            switch (format)
            {
                case "Ch":
                    return this.ToString();
                case "En":
                    return string.Format("{0} {1}", FirstName, LastName);
                default:
                    return this.ToString();
            }
        }

        //重写Object.ToString()
        public override string ToString()
        {
            return string.Format("{0} {1}", LastName, FirstName);
        }
    }

　　上面这种方法是在意识到类型会存在格式化字符串输出方面的需求时没提起为类型继承了接口IFormattable。如果类型本身没有提供格式化输出的功能，这个时候，格式化器就派上了用场。格式化器的好处就是可以根据需求的变化，随时增加或者修改它。

    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person() { FirstName = "Jessica", LastName = "Hu", IDCode = "NB123" };
            Console.WriteLine(person.ToString());
            PersonFomatter pFormatter = new PersonFomatter();
            Console.WriteLine(pFormatter.Format("Ch", person, null));
            Console.WriteLine(pFormatter.Format("En", person, null));
            Console.WriteLine(pFormatter.Format("ChM", person, null));
        }
    }

    class Person
    {
        public string IDCode { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }

    class PersonFomatter : IFormatProvider, ICustomFormatter
    {

        #region IFormatProvider 成员

          public object GetFormat(Type formatType)
        {
            if (formatType == typeof(ICustomFormatter))
                return this;
            else
                return null;
        }

        #endregion

        #region ICustomFormatter 成员

          public string Format(string format, object arg, IFormatProvider formatProvider)
        {
            Person person = arg as Person;
            if (person == null)
            {
                return string.Empty;
            }

            switch (format)
            {
                case "Ch":
                    return string.Format("{0} {1}", person.LastName, person.FirstName);
                case "En":
                    return string.Format("{0} {1}", person.FirstName, person.LastName);
                case "ChM":
                    return string.Format("{0} {1} : {2}", person.LastName, person.FirstName, person.IDCode);
                default:
                    return string.Format("{0} {1}", person.FirstName, person.LastName);
            }
        }

        #endregion
    }

　　

　　结合以上两个版本，可以得出最终版。（至于选择哪个版本，看具体需求确定）

     static void Main(string[] args)
    {
            Person person = new Person() { FirstName = "Jessica", LastName = "Hu", IDCode = "NB123" };
            Console.WriteLine(person.ToString());
            PersonFomatter pFormatter = new PersonFomatter();
            //第一类格式化输出语法
            Console.WriteLine(pFormatter.Format("Ch", person, null));
            Console.WriteLine(pFormatter.Format("En", person, null));
            Console.WriteLine(pFormatter.Format("ChM", person, null));
            //第二类格式化输出语法，也更简洁
            Console.WriteLine(person.ToString("Ch", pFormatter));
            Console.WriteLine(person.ToString("En", pFormatter));
            Console.WriteLine(person.ToString("ChM", pFormatter));

        }
    }

    class Person : IFormattable
    {
        public string IDCode { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }

        //实现接口IFormattable的方法ToString
        public string ToString(string format, IFormatProvider formatProvider)
        {
            switch (format)
            {
                case "Ch":
                    return this.ToString();
                case "En":
                    return string.Format("{0} {1}", FirstName, LastName);
                default:
                    return this.ToString();
                    ICustomFormatter customFormatter = formatProvider as ICustomFormatter;
                    if (customFormatter == null)
                    {
                        return this.ToString();
                    }
                    return customFormatter.Format(format, this, null);

            }
        }

        //重写Object.ToString()
        public override string ToString()
        {
            return string.Format("{0} {1}", LastName, FirstName);
        }
    }

    class PersonFomatter : IFormatProvider, ICustomFormatter
    {

        #region IFormatProvider 成员

          public object GetFormat(Type formatType)
        {
            if (formatType == typeof(ICustomFormatter))
                return this;
            else
                return null;
        }

        #endregion

        #region ICustomFormatter 成员

          public string Format(string format, object arg, IFormatProvider formatProvider)
        {
            Person person = arg as Person;
            if (person == null)
            {
                return string.Empty;
            }

            switch (format)
            {
                case "Ch":
                    return string.Format("{0} {1}", person.LastName, person.FirstName);
                case "En":
                    return string.Format("{0} {1}", person.FirstName, person.LastName);
                case "ChM":
                    return string.Format("{0} {1} : {2}", person.LastName, person.FirstName, person.IDCode);
                default:
                    return string.Format("{0} {1}", person.FirstName, person.LastName);
            }
        }

        #endregion
    }

-------------------------------------------- 

建议14：正确实现浅拷贝和深拷贝 / 36

--------------------------------------------

 　　为对象创建副本的技术称为拷贝（也叫克隆）。将拷贝分为浅拷贝和深拷贝。

• 共同点：将对象中的所有字段复制到新的对象（副本）中。而且，值类型字段的值被复制到副本中后，在副本中的修改不会影响到源对象对应的值。
• 不同点：引用类型浅拷贝复制的是引用类型的引用。即修改副本引用类型的值即是修改源对象的值。引用类型深拷贝而是拷贝整个引用对象，如同值类型。
• 注：string类型尽管是引用类型，但因性质特殊，所以按值类型处理。

　　拷贝建议通过继承IConeable接口的方式实现。但是该接口只有一个Clone的方法。所以浅拷贝和深拷贝可以自己定义。

　　实现深拷贝的方法有很多，比如手动拷贝每个字段的方法，但是不推荐，该方法不灵活也容易出错。

　　建议使用序列化的形式进行深拷贝。

    [Serializable]
    class Employee : ICloneable
    {
        public string IDCode { get; set; }
        public int Age { get; set; }
        public Department Department { get; set; }

        #region ICloneable 成员

        public object Clone()
        {
            return this.MemberwiseClone();
        }

        #endregion

        public Employee DeepClone()
        {
            using (Stream objectStream = new MemoryStream())
            {
                IFormatter formatter = new BinaryFormatter();
                formatter.Serialize(objectStream, this);
                objectStream.Seek(0, SeekOrigin.Begin);
                return formatter.Deserialize(objectStream) as Employee;
            }
        }

        public Employee ShallowClone()
        {
            return Clone() as Employee;
        }
    }

-------------------------------------------------- 

建议15：使用dynamic来简化反射实现 / 40

--------------------------------------------------

 　　dynamic是Framework4.0的新特性。dynamic的出现让C#具有了弱语言类型的特性，编译器在编译的时候不再对类型进行检查，编译器默认dynamic对象支持开发者想要的任何特性。

　　利用dynamic的这个特性，可以简化C#中的反射语法，大大提高效率。

　　通过的例子比较性能：

    class Program
    {
        static void Main(string[] args)
        {
            int times = 1000000;
            DynamicSample reflectSample = new DynamicSample();
            var addMethod = typeof(DynamicSample).GetMethod("Add");
            Stopwatch watch1 = Stopwatch.StartNew();
            for (var i = 0; i < times; i++)
            {
                addMethod.Invoke(reflectSample, new object[] { 1, 2 });
            }
            Console.WriteLine(string.Format("反射耗时：{0} 毫秒", watch1.ElapsedMilliseconds));
            dynamic dynamicSample = new DynamicSample();
            Stopwatch watch2 = Stopwatch.StartNew();
            for (int i = 0; i < times; i++)
            {
                dynamicSample.Add(1, 2);
            }
            Console.WriteLine(string.Format("dynamic耗时：{0} 毫秒", watch2.ElapsedMilliseconds));

            DynamicSample reflectSampleBetter = new DynamicSample();
            var addMethod2 = typeof(DynamicSample).GetMethod("Add");
            var delg = (Func<DynamicSample, int, int, int>)Delegate.CreateDelegate(typeof(Func<DynamicSample, int, int, int>), addMethod2);
            Stopwatch watch3 = Stopwatch.StartNew();
            for (var i = 0; i < times; i++)
            {
                delg(reflectSampleBetter, 1, 2);
            }
            Console.WriteLine(string.Format("优化的反射耗时：{0} 毫秒", watch3.ElapsedMilliseconds));
        }
    }

    public class DynamicSample
    {
        public string Name { get; set; }

        public int Add(int a, int b)
        {
            return a + b;
        }
    }

　　从结果来看，优化的反射实现，其效率和dynamic在一个数量级上。可是它带来了效率，却牺牲了代码的整洁度，这种实现在我看来是得不偿失的。所以，现在又了dynamic类型，建议大家：

　　始终使用dynamic来简化反射实现。

　　注：以上是原文的例子，但是个人感觉有些问题，作者只是测试了调用的效率。如果反射一次，多次调用的话，作者的例子可以参考。

　　　　如果是反射一次，调用一次的模式的话，第三个优化反射中委托的创建也应该放进循环中，同时反射（GetMethod)也应该放进循环中。

　　　　以下是本人测试性能的例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace TestReflection
{
    class Program
    {
        static void Main(string[] args)
        {
            int times = 1000000;
            var sw = Stopwatch.StartNew();
            var sample = new Sample();

            //反射调用            
            for (int i = 0; i < times; i++)
            {
                typeof(Sample).GetMethod("Add").Invoke(sample, new object[] { 1, 2 });
            }
            sw.Stop();
            Console.WriteLine("Invoke:{0}毫秒", sw.ElapsedMilliseconds.ToString());

            //dynamic调用
            dynamic ds = new Sample();
            sw.Restart();
            for (int i = 0; i < times; i++)
            {
                ds.Add(1, 1);
            }
            sw.Stop();
            Console.WriteLine("dynamic:{0}毫秒", sw.ElapsedMilliseconds.ToString());

            //转换成接口调用：如果被反射的类实现了统一接口，则可转换为接口调用该方法
            sw.Restart();
            for (int i = 0; i < times; i++)
            {
                (sample as Ibase).Add(1, 2);
            }
            sw.Stop();
            Console.WriteLine("Interface:{0}毫秒", sw.ElapsedMilliseconds.ToString());            

            //反射后委托调用
            sw.Restart();
            for (int i = 0; i < times; i++)
            {
                var method = typeof(Sample).GetMethod("Add");
                var delg = (Func<Sample, int, int, int>)Delegate.CreateDelegate(typeof(Func<Sample, int, int, int>), method);
                delg(sample, 1, 1);
            }
            sw.Stop();
            Console.WriteLine("Delegate&Reflection:{0}毫秒", sw.ElapsedMilliseconds.ToString());
        }
    }

    interface Ibase
    {
        int Add(int x, int y);
    }

    class Sample : Ibase
    {
        public int Add(int x, int y)
        {
            return x + y;
        }
    }
}

　　由上面的结果可见：

　　个人建议:

• 如果这些需反射的类都实现了同一个接口，即需反射的成员继承同一个接口，那么将对象转换为接口，调用接口的成员，无需使用反射。
• 这些类没有实现同一接口，那么优先采用dynamic方式。
• 如果Framework版本低于4.0，那么只能采用反射的方式，至于用Invoke还是delegate，如果反射和调用次数相差不大，建议用Invoke，如果调用次数远多于反射，那么建议用委托。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　SamWang

  　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　2012-05-22

作者：SamWang
出处：http://wangshenhe.cnblogs.com/
本文版权归作者和博客园共有，欢迎围观转载。转载时请您务必在文章明显位置给出原文链接，谢谢您的合作。