7语法基础_CLR核心解析

{  //内存分配：线程栈   堆
                ValuePoint valuePoint;
                valuePoint.x = 123;
                Console.WriteLine(valuePoint.x);//赋值后才能使用

                ValuePoint point = new ValuePoint();//默认一定有无参数构造函数
            }

            {  //装箱拆箱
                int i = 3;
                object oValue = i;//装修 值类型转引用类型
                int k = (int)oValue;//拆箱 引用类型转值类型
            }
            {//new一个对象的步骤
                ReferenceTypeClass referenceTypeClassInstance = new ReferenceTypeClass();
                referenceTypeClassInstance.Method(); 
                //1  调用New  就会去先开辟内存
                //2  把实例传递给构造函数
                //3  执行构造函数
                //4  引用返回
            }
            //值类型的值，会随着对象的位置存储
            //引用类型的值，是一定会存储在堆里面 
            //值类型的长度是确定，引用类型的长度不确定的，只有堆才能存放各种值

            {
                string student = "大山";
                string student2 = "APP";//共享
                student2 = "大山"; 
                Console.WriteLine(object.ReferenceEquals(student, student2)); //判断二者是不是同 
                // 输出 true  student和student2指向的是同一个引用地址  享元模式
               
                student2 = "大山1"; // new String("大山1")  会开辟一块新的内存 
                Console.WriteLine(student); 
                //还是输出大山 字符串的不可变性  

                string student3 = string.Format("大{0}", "山");
                Console.WriteLine(object.ReferenceEquals(student, student3));
                //false  因为二者没有享元  先分配内存   然后计算  最终的结果才是 “大山”


                string student4 = "大" + "山";
                Console.WriteLine(object.ReferenceEquals(student, student4));
                //true  先计算了，  直接就得到大山  可以指向之前存在的内存块

                string halfStudent = "山";
                string student5 = "大" + halfStudent;
                Console.WriteLine(object.ReferenceEquals(student, student5));
                //false    是先分配内存，然后再计算
            }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyCLRCore
{ 
    /// <summary>
    /// 标准Dispose模式
    /// 
    /// 析构函数:被动清理
    /// Dispose：主动清理
    /// </summary>
    public class StandardDispose : IDisposable
    {
        //演示创建一个非托管资源
        private string _UnmanageResource = "未被托管的资源";
        //演示创建一个托管资源
        private string _ManageResource = "托管的资源";


        private bool _disposed = false;

        /// <summary>
        /// 实现IDisposable中的Dispose方法
        /// </summary>
        public void Dispose()
        {
            this.Dispose(true); //必须为true
            GC.SuppressFinalize(this);//通知垃圾回收机制不再调用终结器（析构器）
        }

        /// <summary>
        /// 不是必要的，提供一个Close方法仅仅是为了更符合其他语言（如C++）的规范
        /// </summary>
        public void Close()
        {
            this.Dispose();
        }

        /// <summary>
        /// 必须，以备程序员忘记了显式调用Dispose方法
        /// </summary>
        ~StandardDispose()
        {
            //必须为false
            this.Dispose(false);
        }

        /// <summary>
        /// 非密封类修饰用protected virtual
        /// 密封类修饰用private
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (this._disposed)//已经被释放的还可以不异常
            {
                return;
            }
            if (disposing)
            {
                // 清理托管资源
                if (this._ManageResource != null)
                {
                    //Dispose
                    this._ManageResource = null;
                }
            }
            // 清理非托管资源
            if (this._UnmanageResource != null)
            {
                //Dispose  conn.Dispose()
                this._UnmanageResource = null;
            }
            //让类型知道自己已经被释放
            this._disposed = true;
        }

        public void PublicMethod()
        {
            if (this._disposed)
            {
                throw new ObjectDisposedException("StandardDispose", "StandardDispose is disposed");
            }
            //
        }
    }
}