C#学习记录：编写高质量代码改善整理建议9-15

在构建自己的类型时，始终应该考虑是否可以使用运算符重载

10、创建对象时需要考虑是否实现比较器

如果需要排序，有两种比较器实现

class FirstTyPE : IComparableFirstType>
{
        public string name;
        public int age;
    public FirstType(int age)    {
            name = "aa";
            this.age = age;
    }
    public int CompareTo(FirstType other)    {
            return other.age.COMpareTo(age);
    }
}
static void Main(string[] args){
        FirstType F1 = new FirstType(3);
        FirstType f2 = new FirstType(5);
        FirstType f3 = new FirstType(2);
        FirstType f4 = new FirstType(1);
        ListFirstType>
     list = new ListFirstType>
    {
        f1,f2,f3,f4    }
    ;
        list.sort();
    foreach (VAR ITem in list)    {
            Console.WriteLine(item);
    }
}
    

或者第二种

class PRogram : IComparerFirstType>
{
    static void Main(string[] args)    {
            FirstType f1 = new FirstType(3);
            FirstType f2 = new FirstType(5);
            FirstType f3 = new FirstType(2);
            FirstType f4 = new FirstType(1);
            ListFirstType>
     list = new ListFirstType>
        {
            f1,f2,f3,f4        }
    ;
            list.Sort(new Program());
        foreach (var item in list)        {
                Console.WriteLine(item);
        }
    }
        int IComparerFirstType>
.Compare(FirstType x, FirstType y)    {
            return x.age.CompareTo(y.age);
    }
}
    

它调用的是Program的Compare方法

11、区别对待==和Equals

无论是== 还是Equals：

对于值类型，如果类型的值相等，则返回True

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

且他们都可以被重载

对于string这样一个特殊的引用类，微软可能认为它的现实意义更倾向于一个值类型，所以在fcL（Framework Class Library）中string的比较被重载为值比较，而不是针对引用本身

从设计上来说，很多引用类型会存在类似于string类型比较相近的情况，如人，他的身份证号相同，则我们就认为是一个人，这个时候就需要重载Equals方法，

一般来说，对于引用类型，我们要定义值相等的特性，应该仅仅重写Equals方法，同时让==表示引用相等，这样我们想比较哪个都是可以的

由于操作符“==”和“Equals”都可以被重载为“值相等”和“引用相等”，所以为了明确，FCL提供了object.ReferenceEquals(); 来比较两个实例是否为同一个引用

12、重写Equals时也要重写GetHashCode

字典中判断ContainsKey的时候使用的是key类型的HashCode,所以我们想都使用类型中的某个值来作为判断条件，就需要重新GetHashCode，当然还有其他使用HashCode来作为判断是否相等的，如果我们不重写，可以会产生其他的效果

public override int GetHashCode(){
        //这样写是为了减少HashCode重复的概率，至于为什么这样写我也不清楚。。 记着就行    return (System.Reflection.MethodBase.GetcurrentMethod().DeclaringType.FullName +            "#" + age).GetHashCode();
}
    

重写Equals方法的同时，也应该事先一个类型安全的接口IEquatableT> ，所以重写Equals的最终版本应该是

class FirstType : IEquatableFirstType>
{
        public string name;
        public int age;
    public FirstType(int age)    {
            name = "aa";
            this.age = age;
    }
    public override bool Equals(object obj)    {
            return age.Equals(((FirstType)obj).age);
    }
    public bool Equals(FirstType other)    {
            return age.Equals(other.age);
    }
    public override int GetHashCode()    {
            return (System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.FullName +                "#" + age).GetHashCode();
    }
}
    

13、为类型输出格式化字符串

class Person : IFormattable{
    public override string ToString()    {
            return "Default Hello";
    }
    public string ToString(string format, IFormatProvider formatProvider)    {
        switch (format)        {
                case "Chinese":                return "你好";
                case "English":                return "Hello";
        }
            return "helo";
    }
}
    

static void Main(string[] args){
        Person p1 = new Person();
        Console.WriteLine(p1);
        Console.WriteLine(p1.ToString("Chinese",null));
        Console.WriteLine(p1.ToString("English", null));
}
    

@H_406_64@

当继承了IFormattable接口后，可以在ToString里面穿参数来调用不同的ToString，上面的默认ToString就不会调用到了

具体还有一个IFormatProvider接口，我还没研究

14、正确实现浅拷贝和深拷贝

无论是深拷贝还是浅拷贝，微软都见识用类型继承ICloneable接口的方式来明确告诉调用者：该类型可以被拷贝

//记得在类前添加[Serializable]的标志[Serializable]class Person : ICloneable{
        public string name;
        public Child child;
    public object Clone()    {
            //浅拷贝        return this.MemberwiseClone();
    }
        /// summary>
        /// 深拷贝    /// 我也不清楚为什么这样写    /// /summary>
        /// returns>
    /returns>
    public Person DeepClone()    {
        using (Stream objectStream = new MemoryStream())        {
                IFormatter formatter = new BinaryFormatter();
                formatter.Serialize(objectStream, this);
                objectStream.Seek(0, SeekOrigin.Begin);
                return formatter.Deserialize(objectStream) as Person;
        }
    }
}
[Serializable]class Child{
        public string name;
    public Child(string name)    {
            this.name = name;
    }
    public override string ToString()    {
            return name;
    }
}
    

浅拷贝：

输出的p1.child.name 是更改过的p2的child.name

深拷贝：

输出的是原来的

深拷贝是对于引用类型来说，理论上string类型是引用类型，但是由于该引用类型的特殊性，Object.MemberwiseClone仍然为其创建了副本，也就是说在浅拷贝过程中，我们应该将字符串看成是值类型

15、使用dynamic来简化反射实现

static void Main(string[] args){
        //使用反射    Stopwatch watch = Stopwatch.StartNew();
        Person p1 = new Person();
        var add = typeof(Person).GetMethod("Add");
        for (int i = 0;
     i  1000000;
 i++)    {
        add.Invoke(p1, new object[] {
 1, 2 }
    );
    }
        Console.WriteLine(watch.ElapsedTicks);
        //使用dynamic    watch.Reset();
        watch.Start();
        dynamic d1 = new Person();
        for (int i = 0;
     i  1000000;
 i++)    {
            d1.Add(1, 2);
    }
        Console.WriteLine(watch.ElapsedTicks);
}
    

可以看出使用dynamic会比使用反射写出来的代码美观且简洁，而且多次运行的效率也会更高，因为dynamic第一次运行后会缓存起来

@H_126_102@几乎相差了10倍

但是反射如果次数较少效率会更高

这个是运行了100次的结果

但是很多时候效率不是必要的，始终推荐使用dynamic来简化反射的实现

相关文章：

C#学习记录：编写高质量代码改善整理建议1-3

C#学习记录：编写高质量代码改善整理建议4-8

以上就是C#学习记录：编写高质量代码改善整理建议9-15的详细内容，更多请关注其它相关文章！

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！