九、C#笔记

/// <summary>
/// 第十四章：使用垃圾回收和资源管理
/// </summary>
namespace Chapter14
{
    class Program
    {
        static void Main(string[] args)
        {
            //14.1对象生存
            /*
             * new操作的步骤：
             * 1.首先，new操作从堆中分配原始内存，这个阶段无法进行任何干预。
             * 2.然后，new操作将原始内存转换成对象，这时必须初始化对象。
             * 
             * 对象销毁的过程：
             * 1. .NET“运行时”执行清理工作，可以写一个终结器来加以控制。
             * 2. .NET“运行时”将对象占用的内存归还给堆，解除对象内存分配。
             * 
             * 销毁对象并将内存归还给堆的过程称为垃圾回收
             */
            ///14.1.1编写终结器（使用终结器，可在对象被垃圾回收时执行必要的清理）
            /*
             * 终结器存在以下重要限制:
             * 1.终结器只适合引用类型.值类型(例如struct)不能声明终结器
             * 2.不能为终结器指定访问修饰符(例如public)
             * 3.终结器不能获取任何参数.
             * 4.终结代码只应专注于释放资源.(不要包含任何逻辑)
             */

            ///14.1.2 为什么要使用垃圾回收器
            /*
             * 垃圾回收器的特点是,程序员不知道(也不应依赖)对象的销毁顺序.
             * 需理解的最后一个重点是,终结器只有在对象被垃圾回收时才运行.
             * 终结器肯定会允许,只是不保证在什么时候运行.
             * 所以写代码时,不要对终结器的运行顺序或时间有任何预设.
             */
            ///14.1.3垃圾回收器的工作原理                       
            /*
             * 采取的步骤如下:
             * 1.构造所有可达对象的一个映射(map).
             * 2.检查是否有任何不可达对象包含一个需要运行的终结器.需要被终结的任何不可达对象都放在一个称为freachable的特殊队列中.
             * 3.回收剩下的不可达对象(即不需要终结的对象).
             * 4.然后,允许其他线程恢复执行.
             * 5.在一个独立线程中,对需终结的不可达对象执行终结操作.
             */
            ///14.1.4慎用终结器
            /*
             * 写包含终结器的类,会使代码和垃圾回收过程变复杂.
             */

            //14.2资源管理
            /*有些资源过于宝贵,用完之后应马上释放,唯一的选择就是亲自释放资源.*/
            ///14.2.1资源清理方法
            TextReader reader = new StreamReader("aa.txt");
            string line;
            while ((line = reader.ReadLine()) != null)
            {
                Console.WriteLine(line);
            }
            reader.Close();
            ///14.2.2异常安全的资源清理
            /*
             * try之后写在finally里面，但是也存在缺点：
             * 略
             * using语句可以解决这些缺点
             */
            ///14.2.3using语句和IDisposable接口
            using (TextReader reader1 = new StreamReader("aa.txt"))
                //相当于自己try、finally，省略了finally的关闭（关闭用的Dispose）
            {
                string line1;
                while ((line1 = reader.ReadLine()) != null)
                {
                    Console.WriteLine(line1);
                }
            }
            /*
             * using语句声明的变量的类型必须实现IDisposable接口在System命名空间中，只包含一个名为Dispose的方法。
             * Dispose方法的作用是清理对象使用的任何资源。
             * 特点『
             * 1.需要清理多个资源时，具有良好的扩展性
             * 2.不影响程序代码的逻辑
             * 3.对问题进行良好抽象，避免重复性编码
             * 4.非常健壮，using语句结束后，就不能使用using语句中声明的变量了，因为它已不在作用域。
             * 』
             */
            ///14.2.4从终结器中调用Dispose方法
            /*
             * 1.类实现了IDispsable就诶口
             * 2.公共Dispose方法可由应用程序代码在任何时候调用
             * 3.公共Dispose方法调用Dispose方法来获取一个Boolean参数的受保护重载版本，
             * 向其传递true，由后者来实际清理资源
             * 4.终结器调用Dispose方法来获取一个Boolean参数的受保护重载版本，
             * 向其传递false。终结器只由垃圾回收器在对象被终结时调用。
             * 5.受保护的Dispose方法可以安全地多次调用。
             * 6.受保护的Dispose方法支持托管资源和非托管资源的清理。
             * 7.公共Dispose方法调用静态GC.SuppressFinalize方法。该方法阻止垃圾回收器为这个对象调用终结器，因为对象已经终结
             * 8.类的所有常规方法都要检查对象是否已清理；是的话，就抛出异常。
             */

            //14.3实现异常安全的资源清理
            //14.4处理异步清理
            /*await using()
             调用： awit 方法名（）
             */
        }
    }
}

namespace Chapter14.Mouble
{
    internal class Resource
    {
    }
}

namespace Chapter14.Mouble
{
    class FileProcessor
    {
        FileStream file = null;
        public FileProcessor(string fileName)
        {
            this.file = File.OpenRead(fileName);
        }
        /// <summary>
        /// 14.1.1编写终结器
        /// </summary>
        ~FileProcessor()
        {
            this.file.Close();
        }
    }
}
 

namespace Chapter14.Mouble
{
    /// <summary>
    /// 14.2.4从终结器中调用Dispose方法
    /// </summary>
    public class Example:IDisposable
    {
        private Resource scarce;
        private bool disposed = false;

    ~Example()
    {
        this.Dispose(false);
    }

    public virtual void Dispose()
    {
        this.Dispose(true);
        GC.SuppressFinalize(this);
    }

    public virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if(disposing)
            {

            }
            this.disposed = true;
        }
    }

    public void SomeBehavior()
    {
        checkIfDisposed();
    }

    private void checkIfDisposed()
    {
        if (this.disposed)
        {
            throw new ObjectDisposedException("示例：对象已经清理");
        }
    }
}
}