抽象工厂模式

BLL层

BLL类库

BaseBll.cs

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

namespace BLL
{

    //BLL层只实现IBLL层的接口，不直接与DAL层打交道
    using IBLL;
    using IDAL;
    public class BaseBll<T> : IBaseBllInterface<T> where T:class //父类方法只实现父类接口
    {
        protected IBaseDalInterface<T> basedal;
        public List<T> QueryWhere(System.Linq.Expressions.Expression<Func<T, bool>> where)
        {
            return basedal.QueryWhere(where);
        }

        public bool DeleteWhere(System.Linq.Expressions.Expression<Func<T, bool>> where)
        {
            return basedal.DeleteWhere(where);
        }
    }
}

T_UserInfoBll.cs

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

namespace BLL
{
    using IBLL;
    using IDAL;
    using Model;
    using DALFactroy;

    //这里为什么要继承这个借口呢？那是因为虽然T_UserInfoBll继承了 BaseBll<T_UserInfo>类，而且 BaseBll<T_UserInfo>类也实现了IBaseBll<T>接口口。但是IT_UserInfoBllInterface是继承自IBaseBll<T>接口的，在IT_UserInfoBllInterface接口中可以有存在它自己的独特方法。如果你想用IT_UserInfoBllInterface接口中的独特方法的话，那么就就需要来继承这个IT_UserInfoBllInterface接口并实现它。 （子类实现对应的子类接口）
    public class T_UserInfoBll : BaseBll<T_UserInfo>, IT_UserInfoBllInterface 
    {
        IT_UserInfoDalInterface dal;
        public T_UserInfoBll()
        {
            this.dal = DalFactroy.CreateUserInfoDalInstance(); //创建子类dal对象（如果子接口中有方法，这个子类需要实现）
            base.basedal = this.dal; 
        }

    }
   
}

IBLL类库

IBaseBllInterface.cs

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

namespace IBLL
{
    /// <summary>
    /// 定义方法在这里，BLL层只要实现这个接口中的方法就可以了，其他都不用惯（不管更换什么BLL，新来的BLL只需要实现IBLL中的方法）
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IBaseBllInterface<T> where T:class
    {
        List<T> QueryWhere(System.Linq.Expressions.Expression<Func<T, bool>> where);

        bool DeleteWhere(System.Linq.Expressions.Expression<Func<T, bool>> where);
    }
}

IT_UserInfoBllInterface.cs

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

namespace IBLL
{
    using IBLL;
    using Model;

   
    public interface IT_UserInfoBllInterface:IBaseBllInterface<T_UserInfo>
    {
        //这里除了继承IBaseBllInterface<T_UserInfo>接口中的方法外，还可以定义自己的抽象方法，继承它的子类需要实现
    }
}

AbstractFactroy类库（抽象工厂类库）

AbstFactroycs.cs

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

namespace AbstractFactroy
{
    using IBLL;
    using System.Reflection;
    public abstract class AbstFactroycs
    {
        public abstract IT_UserInfoBllInterface CreateUserInfoInstance();


        //----------------一下方法其实可以封装到一个OperationFactroy类中（这个类叫操作工厂类），这样这个抽象类就只负责定义抽象方法就可以了。如果仅仅是定义抽象方法的话，这个抽象类甚至可以改成一个接口（如果这个抽象类改成接口的话，就不叫抽象工厂了，不过这仅仅是叫法而已，我们当然也可以这么做，只要能实现解耦就可以啦）

        //在这里通过反射创建业务工厂类对象 (假设我们项目中存在2个业务工厂，那么我们就应该创建2个业务工厂类的对象)
        public static AbstFactroycs CreateAFactroy(string factroyName)
        {
           
            //Assembly ass = Assembly.Load("这里是A工厂的类库名");
            Assembly ass = Assembly.Load("BLLFactroy");
            return ass.CreateInstance(factroyName) as AbstFactroycs;
        }

        public static AbstFactroycs CreateBFactroy(string factroyName)
        {
            //Assembly ass = Assembly.Load("这里是B工厂的类库名");
            Assembly ass = Assembly.Load("BLLFactroy"); //这里仅仅是演示当有多个工厂的时候我们怎么做而已.
            return ass.CreateInstance(factroyName) as AbstFactroycs;
        }

    }
}

BLLFactroy类库 （业务工厂类库）

（业务工厂类库，这种业务工厂类库可以存在在多个，当存在多个业务工厂类库的时候，那么抽象工厂类库就将所有的业务工厂类库公有的创建对象的方法提取出来，变成抽象的方法，然后不同的业务工厂来继承这个抽象工厂并重写这个抽象工厂的公共方法。我们在UI层就只依赖抽象工厂，在抽象工厂中写一个创建对象的非抽象方法，这个创建对象的方法，用反射的形式创建一个子类对象，然后以抽象类的形式返回，这样我们就可以在UI层中调用抽象工厂类来创建业务工厂类，并调用业务工厂类中的方法，创建类对象，最后用这个类对象调用类方法，实现数据查询)

BllFactroy.cs

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

namespace BLLFactroy
{
    using IBLL;
    using AbstractFactroy;
    /// <summary>
    /// 这个BLL层的工厂是给UI层来调用的（目的是创建BLL层的对象）
    /// </summary>
    public class BllFactroy : AbstFactroycs //让它继承抽象工厂类，并
    {
        object CreateObject(string className)
        {
            string assName = System.Configuration.ConfigurationManager.AppSettings["bll"];
            if (string.IsNullOrEmpty(assName))
            {
                throw new Exception("没配置BLL程序集的名称");
            }

            Assembly ass = Assembly.Load(assName);
            //如果对象创建不成功，查询下EF的版本是不是与类库中的引用的EF版本不一致。
            return ass.CreateInstance(assName + "." + className);

        }

        /// <summary>
        /// 创建T_UserInfoBll类对象
        /// </summary>
        /// <returns>将T_UserInfoBll类对象以IT_UserInfoBllInterface接口的形式返回</returns>
        public override IT_UserInfoBllInterface  CreateUserInfoInstance()
        {
            return CreateObject("T_UserInfoBll") as IT_UserInfoBllInterface;
        }
    }
}

UI层

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace MvcApp.Controllers
{
    //using BLLFactroy; UI层不直接与业务工厂打交道，而是与抽象工厂打交道
    using AbstractFactroy;
    using Model;
    public class HomeController : Controller
    {
        //     
        public ActionResult Index()
        {
                
            //List<T_UserInfo> list= BllFactroy.CreateUserInfoInstance().QueryWhere(r => r.Age > 10).ToList();

            //原理：先创建业务工厂类对象，然后用业务工厂类对象创建BLL层的类对象（这个类对象以接口形式返回），最后操作类对象的方法
            List<T_UserInfo> list = AbstFactroycs.CreateAFactroy("BllFactroy").CreateUserInfoInstance().QueryWhere(R => R.Age > 10);

            return View(list);
        }
	}
}

DAL层我就不贴了。原理是和BLL层一样的。