MVC数据访问小结 （ virtual 、 volatile）

namespace Opentide.DataAccess
{
    /// <summary>公共数据访问处理层
    /// 
    /// </summary>
    public class DubaiCircle : DbContext
    {
        #region 变量属性

        //DBContext为数据库连接字符串
        private DubaiCircle()
            : base("name=DBContext")
        {

        }
        
        //volatile用来保持多线程数据同步
        private volatile static DubaiCircle instanceDB = null;

        private static readonly object lockHelper = new object();

        /// <summary>
        /// 数据访问公开实例对象
        /// </summary>
        public static DubaiCircle InstanceDB
        {
            get
            {
                if (instanceDB == null)
                {
                    lock (lockHelper)
                    {
                        if (instanceDB == null)
                            instanceDB = new DubaiCircle();
                    }
                }
                return instanceDB;
            }
        }
            
        //定义虚方法对实体TR_Words进行增删改查
        public virtual DbSet<TR_Words> TR_Words { get; set; }

        public virtual DbSet<TR_DefaultDataStore> TR_DefaultDataStore { get; set; }
        #endregion


        #region 公共方法
        //在完成对派生上下文的模型的初始化后，并在该模型已锁定并用于初始化上下文之前，将调用此方法。虽然此方法的默认实现不执行任何操作，但可在派生类中重写此方法，这样便能在锁定模型之前对其进行进一步的配置。
        //modelBuilder:定义要创建的上下文的模型的生成器。
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();//移除复数表名的契约
            modelBuilder.Conventions.Remove<IncludeMetadataConvention>();//移除对MetaData表的查询验证，要不然每次都要访问EdmMetadata这个表
        }
        #endregion
    }
}

class A
    {
        public virtual void F() { Console.WriteLine("A.F"); }
    }
    class B : A
    {
        public override void F() { Console.WriteLine("B.F"); }  //重写A类中的虚方法
    }
    class C : B
    {
        new public virtual void F() { Console.WriteLine("C.F"); } //隐藏B类中重写过的方法，只剩下这里的虚方法会被显示，但被D重写。
    }
    class D : C
    {
        public override void F() { Console.WriteLine("D.F"); } //重写C类中的虚方法
    }    
static void Main(string[] args)
        {
            D d = new D();
            A a = d;
            B b = d;
            C c = d;
            a.F();  //A类中的虚方法被重写为B类中的F（）,所以显示结果为BF。
            b.F();  //B类中的F（）方法被调用，所以显示BF
            c.F();  //B类中的重写方法被隐藏，调用C类中的虚方法，儿虚方法被D重写，故调用D类的F（），显示结果为DF
            d.F();   //寻找基类C中的虚方法,C的基类A中的虚方法不被执行,也就说明虚方法重载只能从上一辈重载
            Console.ReadKey();
        }