首页 > > 网络编程 > Mysql >

[.NET] 《Effective C#》快速笔记（二）- .NET …

2018-06-17 22:11:51来源：未知阅读 ()

《Effective C#》快速笔记（二）- .NET 资源托管

简介

　　续《Effective C#》读书笔记（一）- C# 语言习惯。

　　.NET 中，GC 会帮助我们管理内存，我们并不需要去担心内存泄漏，资源分配和指针初始化等问题。不过，它也并非万能，因为非托管资源需要我们自己进行清理，如文件句柄、数据库连接、GDI+ 对象和COM 对象等。

十二、推荐使用成员初始化器而不是赋值语句
十三、正确地初始化静态成员变量
十四、尽量减少重复的初始化逻辑
十五、使用 using 和 try/finally 清理资源
十六、避免创建非必要的对象
十七、实现标准的销毁模式
十八、区分值类型和引用类型
十九、保证 0 为值类型的有效状态
二十、保证值类型的常量性和原子性

十二、推荐使用成员初始化器而不是赋值语句

　　1.成员初始化器：在声明变量时就进行初始化，而不是在每个构造函数中进行。

　　2.以下 3 种情况，应避免使用成员初始化器：

　　（1）当你想要初始化对象为 0 或 null 时。因为系统默认的初始化工作（在所有代码执行前）会将一切设置为 0 或 null，我们做的是一步多余的操作。而且，如果是值类型，那么性能非常差。

            MyValueType myVal1; //初始化为 0
            MyValueType myVal2 = new MyValueType(); //也是 0

　　这两条语句都将变量初始化为 0，但第一条是通过设置包含 myVal1 的这一块内存为 0 实现的，而第二条使用的是 initobj 这条 IL 指令，导致了对 myVal2 变量的一次装拆箱操作，这将占用额外性能与时间。

　　（2）需要对同一个变量执行不同的初始化方式：

    class Program
    {
        /// <summary>
        /// 声明并初始化
        /// </summary>
        private List<string> _lables = new List<string>();

        public Program() { }

        public Program(int capacity)
        {
            _lables = new List<string>(capacity);
        }
    }

　　初始化该类时，假如使用的是带 capacity 的构造函数，那么 List<string> 对象表示初始化了 2 次，头一个就成为了垃圾对象。

　　（3）将初始化代码放在构造函数的合适理由：可以方便异常管理 try-catch。

十三、正确地初始化静态成员变量

　　1.在使用类型的实例之前，就应该初始化该类型的所有静态成员变量。静态构造函数是一个特殊的函数，将在其他所有方法、变量或属性被第一次访问之前执行。你可以使用这个函数来初始化静态变量和实现单例模式等操作。

　　2.静态初始化器和静态构造函数是初始化类的静态成员的最佳选择。

　　3.使用静态构造函数而不是静态初始化器最常见的理由是可以捕捉和处理异常。

十四、尽量减少重复的初始化逻辑

　　1.如果多个构造函数包含类似的逻辑，我们应将其提取到一个公共的构造函数中，这样可以避免代码重复，也可以利用构造函数初始化器生成更高效的代码。

    class MyClass
    {
        private List<string> _lables;
        private string _name;

        public MyClass() : this(0, string.Empty)
        {

        }

        public MyClass(int capacity = 0, string name = "")
        {
            _lables = new List<string>(capacity);
            _name = name;
        }
    }

　　第二个构造函数使用了 "" 来给出 name 的默认值，而不是采用 string.Empty ，因为 string.Empty 并不是一个编译期的常量，而是一个定义在 string 类中的静态属性，所以不能用作参数的默认值。

　　2.创建某个类型的第一个实例时所进行的操作顺序：

　　（1）静态变量设置为 0 ；

　　（2）执行静态变量初始化器；

　　（3）执行基类的静态构造函数；

　　（4）执行静态构造函数；

　　（5）实例变量设置为 0；

　　（6）执行实例变量初始化器；

　　（7）执行基类中合适的实例构造函数；

　　（8）执行实例构造函数。

　　3.使用初始化器来初始化简单的资源，使用构造函数来初始化需要复杂逻辑的成员，同事不要忘记将调用抽取到一个构造函数中，以便减少重复。

　　4.构造函数定义中只能使用一个初始化器，要么使用 This() 委托给另一个构造函数，要么使用 base() 调用基类的构造函数。

十五、使用 using 和 try/finally 清理资源

　　1.使用了非托管系统资源的类型必须显示地使用 IDisposable 接口的 Dispose() 来释放，Using() 语句将生成一个Try/finally 块。

十六、避免创建非必要的对象

　　1.GC 可以很好地管理内存，但不管多高效，分配和销毁堆上的对象总会花费很长时间，如果过多的创建引用对象，那么会对程序的性能产生严重的影响。

        public void Paint()
        {
            using (var myFont = new Font("Arial", 10.0f))
            {
                Console.WriteLine($"使用 {myFont} 进行绘画");
            }
        }

　　假如该方法被非常频繁地调用。每次调用时都会创建另一个 Font 对象，但它包含的内容和之前的是完全一样。GC 每次都要为你清理这些垃圾，显然是非常低效的。

　　可以把 myFont 提升为静态变量。

        private readonly static Font _myFont = new Font("Arial", 10.0f);

        public void Paint()
        {
            Console.WriteLine($"使用 {_myFont} 进行绘画");
        }

　　2.降低程序中创建对象数量的方法。

　　（1）将常用的局部变量提升为成员变量；

　　（2）提供一个类，存放某个类型常用实例的单例对象。

　　3.用 StringBuilder 进行复杂的字符串操作

十七、实现标准的销毁模式

　　1.IDisposable.Dispose() 方法的实现中需要完成如下 4 个任务：

　　（1）释放所有非托管资源；

　　（2）释放所有托管资源，包括释放事件监听程序；

　　（3）设定一个状态标志，表示该对象已经被销毁；

　　（4）跳过终结操作，调用 GC.SuppressFinalize(this) 即可。

十八、区分值类型和引用类型

　　1.一般来说，我们创建的大部分是引用类型。

　　2.确定创建值类型的条件有 4 个

　　（1）该类型的主要职责在于数据存储；

　　（2）该类型的公有接口都是由访问其数据成员属性定义的吗？

　　（3）你确定该类型绝不会有派生类型吗？

　　（4）你确定该类型永远都不需要多态支持吗？

　　3.用值类型表示底层存储数据的类型，用引用类型来封装程序的行为。

　　4.如果你对类型未来的用途不确定，应选择引用类型。

十九、保证 0 为值类型的有效状态

　　1..NET 系统的默认初始化过程会将所有的对象设置为 0，建议将 0 作为枚举类型的默认值。

　　2.枚举（enum）必须将 0 设定为枚举值的一个有效选择。所有的枚举值都派生自 System.ValueType。枚举的默认值开始于 0。

　　3.在创建自定义枚举值时，请确保 0 是一个有效的选项。若你定义的是标识（flag），那么可将 0 定义为没有选中任何的标志。

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

二十、保证值类型的常量性和原子性

　　1.常量性：自创建后，其值保持不变。因为不能更改内部状态，就可以省去许多不必要的错误检查，它也是线程安全的，也可以安全地暴露给外界，因为调用者不能改变对象的内部状态。

　　2.设计常量类型时，要确保没有任何漏洞会导致内部状态被外界更改。因为值类型不能派生，所以不必担心会受到派生类影响。

　　不过，如果常量中是可变的引用类型字段的话，我们就应该对这些可变类型进行防御性的复制。

    class MyClass
    {
        private readonly object[] _objs;

        public MyClass(ICollection<object> objs)
        {
            _objs = new object[objs.Count];
            objs.CopyTo(_objs, 0);　　//复制
        }

        public IEnumerable<object> Objs => _objs;
    }

        static void Main(string[] args)
        {
            var objs = new object[10];
            var myClass = new MyClass(objs);
            objs[1] = "hi";

            Console.WriteLine(myClass.Objs.ToArray()[1]);

            Console.Read();
        }