《编写高质量代码改善建议》，感觉这正是自己需要的。

我是做游戏开发的，最近一段时间工作，接触到了数学编程，涉及到大量的计算，策划那边增改需求也很多，加上我的项目对性能要求很高。微量的计算影响到

性能。所以对代码质量要求很高，明显自己的代码质量已经不达标了。所以，我还是打牢固基础，编写高质量代码才是王道。

之前工作经历了很多其他人的代码，什么工作三四年，甚至四五年的代码都是惨不忍睹，我都是“瞧不起”的。

自己不想成为“自己眼中的他们”。这本书，大部分自己都是会的，但是总结的相当到位。毕竟

也有两年经验了，打算用3个月时间，看完，高质量的写完读后感，当然其中也会加入自己的通俗易懂的看法，取其精华。

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

1.正确操作字符串。

 1）尽量避免少的装箱。

string str1 = "djw" + 9;
string str2 = "djw" + 9.ToString(); （高效）

第一行代码会发生一次装箱操作。

第二行代码没有，因为调用的是整型的ToString方法。

（整型ToString()是直接通过操作内存来完成int到string的转换，效率比装箱高很多。）

补充说明：

大家都知道无论值类型还是引用类型其本质上都是object类型，即引用类型。

装箱：将值类型转为引用类型（object）。（通俗来说，将一个单一的东西转为万能的，当然慢）

拆箱：引用类型转为值类型。（将万能转为单一东西，当然快）

注：装箱之所以会带来性能消耗，因为需要完成下面三个步骤。

　　I.首先会为值类型在托管堆中分配内存。

　　II.将值类型的值复制到新分配的堆内存总。

　　III.返回已经成为引用类型的对象的地址。

2）避免分配额外的内存空间。

string是个很特殊的对象，一旦赋值不可改变。运行时调用System.String类中任何对象进行运算， = ， + 等，都会在内存中

创建新的字符串对象，这意味着为该对象分配新的内存空间。

运行时额外开销：

 private static void Method1()
        {
            string s1 = "aaa";
            s1 = "111" + s1 + "222";
            //创建了3个字符串对象,(开辟三个内存空间)，并调用一次string.Contract
        }
        
        private static void Method2()
        {
            string s1 = 9 + "222";
            //发生一次装箱操作，调用一次string.Contract方法
        }
          
        private static void Method3()
        {
            string s1 = "ss" + "dd" + "cc";
            //相当于 s1 = "ssddcc";
        }

        private static void Method4()
        {
            const string a = "t"; //因为a 是一个常量
            string s1 = "abs" + a;
            //该代码等效于 s1 = "abs" +"t"
            //等效于           s1 = "abst";
        }

对于操作频繁的明显带来性能消耗，可以用StringBuilder来弥补。可以参考我这篇帖子：http://www.cnblogs.com/u3ddjw/p/6823346.html

string.format内部方法使用StringBuilder进行字符串公式化。

 2.as is 区别

as  :不能操作基元类型，永远不会抛出异常，如果类型不匹配则返回null

is    :包含基元类型，但是返回true/false

强制转换 (People)SomeObbject :可能引发异常，故效率不如as了

总结 即使可以用强制类型转换，但是出于效率的角度，建议用as

3.区别const 和 readonly的使用方法

const，应用上更加效率。

编译期常量，因为如此，所以天然就是static，不能再前面增加static关键字修饰。

之所以const效率高，是因为经过编译器编译之后，我们在代码中引用const的地方会用const变量所对应的实际值来代替。

只能修饰基元类型，枚举类型或字符串类型。

readonly，大部分应用情况，“效率”并没有那么高的地位，我们更愿意采用readonly，因为readonly赋予代码更多的灵活性。

运行时常量。第一次被赋值后将不可改变。（这句话，不完全正确，再加上"除了在构造函数中，可以被赋值多次”）

修饰没有限制）

readonly 属于类实例的成员，要使他成为类的成员，需要在前面加上static，这样就可以直接使用类名调用.

(构造函数，变量初始化 都可以赋值)

4.枚举的正确使用

　　1）将0 作为枚举的默认值。

　　2)  避免给枚举类型的元素提供显示的值。

　　　　因为如果没有给元素显示的赋值，编译器会逐个为元素的值 + 1.

5.习惯使用重载运算符

　　　开发过程中应该习惯使用微软提供给我们的语法特性。　

 class Salary
    {
        public int RMB;
        public static Salary operator  +(Salary a,Salary b)
        {
            b.RMB += a.RMB;
            return b;
        }
    }

6.创建对象时考虑是否实现比较器

　　编码中，一般我们实现.Net自带的类，方法比较多，但是很多时候，接口，也给我们提供很多方便的功能。我们用的比较少（可能我学的还是比较浅吧）。

比较器的使用，真的很方便，我直接上可使用的代码。

　　IComparable :接口，类直接可继承。

　　IComparer :接口，自定义类型继承。

　　CompareTo：方法，简写比较方法。

 public class Salary:IComparable<Salary>
    {
        public int BaseSalary { get; set; }
        public int Bonus { get; set; }

        public int CompareTo(Salary sa)
        {
            return BaseSalary.CompareTo(sa.BaseSalary);
        }

        public Salary(int baseSalary,int bonus)
        {
            this.BaseSalary = baseSalary;
            this.Bonus = bonus;
        }
    }

　　//自定义排序（可根据该，进行扩展，实现你需要的类型比较，是不是超方便）
    public class SortSalaryBonus:IComparer<Salary>
    {
        public int Compare(Salary sa,Salary sb)
        {
            return sa.Bonus.CompareTo(sb.Bonus);
        }
    }


   static void Main(string[] args)
        {
            List<Salary> salarys = new List<Salary>();
            salarys.Add(new Salary(2, 10));
            salarys.Add(new Salary(21, 1210));
            salarys.Add(new Salary(22, 10));
            salarys.Add(new Salary(233, 120));
            salarys.Sort();
            for (int i = 0; i < salarys.Count; i++)
            {
                Console.WriteLine(salarys[i].BaseSalary);
            }
            salarys.Sort(new SortSalaryBonus());
            for (int i = 0; i < salarys.Count;i++ )
            {
                Console.WriteLine(salarys[i].Bonus);
            }
                Console.Read();
        }

 7.区别对待 == 和 Equals

1)Equals

首先，要明确“相等性”的概念。CLR中将“相等性”分为两类，“值相等”和“引用相等”。

如果用来比较的两个变量所包含的数值相等，那么将其定义为“值相等”；

如果比较的两个变量引用的是同一内存，那么将其定义为“引用相等”。

但是无论 == 还是 equals，都一个原则：0

对于值类型，如果类型的值相等，就返回true。

对于引用类型，如果类型指向同一个对象，则返回true。

 同时我们需要了解，无论是操作符“==”还是“Equals”方法都是可以被重载的。比如string这样一个特殊的引用类型，

微软觉得它的实际意义更接近值类型，所以在FCL中，string的比较被重在为针对“类型的值”，而不是针对“引用本身”

的比较。从设计角度，很多自定义的类型（尤其是自定义的引用类型）会存在和string比较接近的情况，这时候需要重载

Equals这个方法。

但是这里Equals有什么跟==的区别？

 我们写一个简单的Person类。

  public class Person
    {
        public string IdCode;
        public Person(string id)
        {
            IdCode = id;
        }
    }

   Person p1 = new Person("111");
   Person p2 = new Person("111");

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

    此时  p1 == p2 p1.Equals(p2)             false,true

 (我这边理解的Equals 和 ==，Equals就是给你用于引用类型重载出你想要的 相等性，而==用于值类型的值保持其本来的相等性 ！！！！！！真贴心啊)

2)GetHashCode

看到上图后注意：GetHashCode不一样，GetHashCode是干嘛的。

Object为所有的CLR类型提供了GetHashCode的默认实现。每New一个对象，CLR都会为该对象生成一个固定的整型值，

该整型值在对象的生命周期内不会改变，而对象默认的GetHashCode实现就是对该整型值求HashCode。

还有就是，虽然我们重写Equals后比较是相等的，但是如果我们存到键值的集合中，以该Person作为key，再取，就不是相等的。

因为由于CLR内部会优化这种查找，实际上是根据HashCode来查找Value值。代码运行的时候首先会调用Person类型的GetHashCode·

由于发现Person没有实现GetHashCode，所以CLR最终会调用Object的GetHashCode的方法。所以导致这样的相等的Person查找，是找不到的。

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

GetHashCode方法哎存在另外一个问题，他永远只返回一个整型类型，而整型类型的容量显然无法满足字符串的容量。

例如：

　　　　string s1 = "2222222222sada";

               string s2 = "121122222222222";

　　　　s1.GetHashCode() ;s2.GetHashCode();

为了减少两个不同类型之间根据字符串产生相同的HashCode的概率，

改进：　　

 public override int GetHashCode()
        {
            //不懂为啥这么写，但是知道这么写就行了，暂时没必要深究了。
            return (System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName + "#" + this.IdCode).GetHashCode();
       //     return this.IdCode.GetHashCode();
        } 

 注意：也要记得实现IEquatable<T>.

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

8.正确实现浅拷贝和深拷贝

1）浅拷贝：

　　　　(一般情况)将对象中的所有字段复制到新的对象（副本）中。其中，值类型字段的值被复制到副本后，

在副本中的修改不会影响到源对象对应的值。而引用类型的字段被复制到副本中的是引用类型的引用，

而不是引用的对象，在副本中对引用类型的字段值做修改会影响到源对象本身。

 　　　　(string 的拷贝，理论上string 是引用类型，但是由于该引用类型的特殊性，Object.MemberwiseClone

的方法依旧为其创建了副本。也就是拷贝过程，应该将string类型看成值类型)

2）深拷贝：

　　　　将对象中的所有字段复制到新的对象中，无论是对象的值类型字段，还是引用类型的字段，

都会被重新创建并赋值，对于副本的修改，不会影响到源对象本身。

　　　　实现方式：a.反射 b.序列化 c.表达式树 d 慢慢手动赋值。反射进行深拷贝存在问题较多，表达式树又比较复杂,

手动慢慢赋值如果类型字段发生变化或增减，那么拷贝方法也要相应变化。

我这里只讲述 序列化进行深拷贝。

无论是深，还是浅拷贝，微软都建议用  实现 ICloneable接口的方式明确告诉调用者，该类型可以被拷贝。

当然，ICloneable接口只提供了一个声明为Clone的方法，我们可以根据需求Clone方法实现浅拷贝或深拷贝。

序列化实现方式（序列化方法，看一遍就好，了解一下就行了）

[Serializable]
    class Employee:ICloneable
    {
        public string IDCode { get; set; }
        public int Age;
        public Department department;
        public Object Clone()
        {
            return this.MemberwiseClone();
        }

        /// <summary>
        /// 深拷贝，至于里面为啥那么写，我也就没深入研究了，大概知道就好了。
        /// </summary>
        /// <returns></returns>
        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;
          }
        }

        /// <summary>
        /// 浅拷贝 (这个很容易理解)
        /// </summary>
        /// <returns></returns>
        public Employee ShallowClone()
        {
            return Clone() as Employee;
        }
    }

    [Serializable]
    class Department
    {
        public string Name{get;set;}
        public override string ToString()
        {
            return this.Name;
        }

        public Department(string name)
        {
            Name = name;
        }
    }

MemberwiseClone ：创建一个新对象，然后将当前对象的非静态字段复制到该新对象。如果字段是值类型的，

则对该字段执行逐位复制。如果字段是引用类型，则复制引用但不复制引用的对象。因此，原始对象及其本副本引用的是同一对象。

为了实现深度复制，我们就必须便利有相互引用的对象构成的图，并需要处理其中的循环引用结构。这无疑是复杂的。幸好借助.Net的序列化

和反序列化机制，可以十分简单的深度clone一个对象。

反序列化深拷贝原理：

首先将对象序列化到内存流中，此时对象和对象引用的所有对象的状态都被保存到内存中。.Net的序列化机制会自动处理循环引用的情况。

然后将内存流中的状态信息反序列化到一个新的对象中。这样一个对象的深度复制就完成了。

 注：类前面，以及类中引用的类，一定要加上 Serializable

参考：https://www.cnblogs.com/zhili/p/DeepCopy.html

　　    https://blog.csdn.net/gooodiuck/article/details/52299229

9.Dynamic

　　始终使用dynamic来简化反射实现。（了解一下）

题外话：这本书真的真的很不错啊，很适合进阶，总结。虽然里面一些东西自己都是大概知道，但是它刚刚好起了，深入重点，总结的作用。真的很好的一本书，但是淘宝销量好像很差......