工厂模式

希望对你有所帮助（C#）

首先是一个大体结构如下，

抽象工厂：
父类层：
      接口
      {//功能
  void Create();//创建
         void Delete();//删除
      }

      抽象类
      {
          1.静态的  自身类型的 属性  返回：实现类的对象  

          2.抽象的  接口类型的 属性
      }

子类层：
      接口的实现类
      {
         //实现了具体功能 create()
      }

      抽象类的实现类
      {
         //重写接口类型的属性  get{ return new 接口实现类();}
           实际返回 本层接口的实现类对象
      }

调用：
      抽象类.自身类型的属性.接口类型属性.Create();

下面是一个项目结构的搭建（多层架构）：
1.新建类库Sys
  文件夹DAL
  {
       接口：IUserDao
       抽象类：DaoFactory
  }

2.新建类库DAL
  文件夹DAO
  {
      接口实现类：UserDao 
      抽象类实现类：DaoRealize
  }

3.在Sys层新建文件夹BLL
  {
 接口：IUserBll
 抽象类：BllFactory
   }

4.新建类库BLL
 {
 接口实现类：UserBll
 抽象类实现类：BllRealize
 }

5.新建WebUI
 
6.将DAL、BLL程序集的生成路径改为/WebUI/bin
 class Program
    {
        static void Main1(string[] args)
        {
            //普通实现接口
            MyClass myInter = new MyClass();
           // myInter.Fun();

            // 接口类型的引用 指向  实现类的对象
            //显示实现接口
            //MyInterface myInter2;//引用类型 存储的是引用 声明在栈
            //myInter2= new MyClass();//存储在堆中
            //myInter2.Fun();

            MyInterface m1 = new MyClass();
            m1.Fun();

            MyInterface2 m2 = new MyClass();
            m2.Fun();

        }

        //抽象工厂
        static void Main()
        {
            AbstractFactory.Instanct.GetInterFather.Create();
        }
    }
    #region 接口、抽象类
    abstract class MyAbstract
    {
        string name;
        string Name;
        void Fun()
        {
 
        }
    }

    interface MyInterface
    {//功能
        void Fun();
    }
    interface MyInterface2
    {
        void Fun();
    }

    class MyClass:MyInterface,MyInterface2
    {
        //实现接口
     
        ////显示实现接口
        //void MyInterface.Fun()
        //{
        //    Console.WriteLine("22");
        //}
        void MyInterface.Fun()
        {
            
        }
        void MyInterface2.Fun()
        {
           
        }
    }
#endregion
}
父类层
  //接口
    public interface InterFather
    {//功能
        void Create();
        void Delete();
    }
    
    //抽象类
    public abstract class AbstractFactory
    {
        //1.静态的  自身类型的 属性  返回实现类的对象
        private static AbstractFactory _instanct;
        public static AbstractFactory Instanct
        {
            get
            {//只读属性  返回私有字段
                return _instanct;
            }
        }
        //静态构造函数  初始化静态成员
        static AbstractFactory()
        {
            //实例化实现类对象
            _instanct = new ChildFactory2();
        }

        //2.抽象的 接口类型的 属性
        public abstract InterFather GetInterFather { get; }
    }
}

子类层1
  //接口的实现类
    public class ChildInter1 : InterFather
    { //具体的实现方法
        void InterFather.Create()
        {
            Console.WriteLine("子类层1的create方法执行");
        }

        void InterFather.Delete()
        {
            Console.WriteLine("子类层1的delete方法执行");
        }
    }
    
     //抽象类的实现类
    public class ChildFactory1 : AbstractFactory
    {
        public override InterFather GetInterFather
        {
            get
            { //返回本层 接口的实现类
                ChildInter1 child = new ChildInter1();
                return child;
            }
        }
    }

}

子类层2
  //接口的实现类
    public class ChildInter2 : InterFather
    { //具体的实现方法
        void InterFather.Create()
        {
            Console.WriteLine("子类层2的create方法执行");
        }

        void InterFather.Delete()
        {
            Console.WriteLine("子类层2的delete方法执行");
        }
    }
    
     //抽象类的实现类
    public class ChildFactory2 : AbstractFactory
    {
        public override InterFather GetInterFather
        {
            get
            { //返回本层 接口的实现类
                ChildInter2 child = new ChildInter2();
                return child;
            }
        }
    }

}