学步园

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

该书在线阅读：编写高质量代码：改善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; }













														

返回