一、标准的三层架构模式
Blog.AutoFac.ConsoleApp：控制台应用程序代替界面层（UI），负责处理数据；
Blog.AutoFac.Service：业务逻辑层（BLL），负责业务逻辑运算；
Blog.AutoFac.Repository：数据访问层（DAL），负责提供数据。
BlogService 在构造函数初始化 BlogRepository 对象，BlogService 实现依赖于 BlogRepository。BlogRepository 的代码改动也会导致 BlogService 代码改动，这是一种紧密耦合关系。
数据访问层代码：
/// <summary>
/// 博客仓储
/// </summary>
public class BlogRepository
{
public string GetBlogName(long BlogId)
{
return \”Autofac入门到入坟\”;
}
}
业务层代码：
public class BlogService
{
readonly BlogRepository _blogRepository;
public BlogService()
{
_blogRepository= new BlogRepository();
}
public string GetBlogName(long BlogId)
{
return _blogRepository.GetBlogName(BlogId);
}
}
二、面向接口
面向接口编程是面向对象编程的一部分，通过定义一组接口，仅向上层暴露其接口功能，上层对于下层仅仅是接口依赖，而不依赖具体类。
面向接口好处是降低程序的耦合性，相对于标准的三层架构模式，解除BlogService 对于 BlogRepository 的依赖，易于程序的扩展。
面向接口编程遵循设计模式的开闭原则（对扩展开放，对修改关闭），将具体逻辑与实现分开，有新的改动可以添加新类，减少对于其他模块的影响。
Blog.AutoFac.ConsoleApp：界面层（UI），负责展示数据；
Blog.AutoFac.Service：业务逻辑层（BLL），负责业务逻辑运算；
Blog.AutoFac.Repository：数据访问层（DAL），负责提供数据；
Blog.AutoFac.IService：业务逻辑抽象层（InterfaceBLL），业务逻辑运算抽象接口；
Blog.AutoFac.IRepository：数据访问抽象层（InterfaceDAL），数据访问抽象接口。
添加数据访问抽象层接口：
public interface IBlogRepository
{
string GetBlogName(long BlogId);
}
然后让 BlogRepository 去实现这个接口：
/// <summary>
/// 博客仓储
/// </summary>
public class BlogRepository: IBlogRepository
{
public string GetBlogName(long BlogId)
{
return \”Autofac入门到入坟\”;
}
}
添加业务逻辑抽象层接口：
public interface IBlogService
{
string GetBlogName(long BlogId);
}
BlogService 只依赖于 IBlogRepository，后续增删改查可以通过 IBlogRepository 这个抽象来定义：
public class BlogService: IBlogService
{
readonly IBlogRepository _blogRepository;
public BlogService()
{
_blogRepository= new BlogRepository();
}
public string GetBlogName(long BlogId)
{
return _blogRepository.GetBlogName(BlogId);
}
}
三、控制反转
如果项目业务有多个 Service，当 Service 要使用 Repository，Service 除了自身主要业务职责还得创建仓储类实例（控制关系）。
那么有木有一种方法可以让 Repository 注入到 Service 里来，使得 Service 不需要关注Repository 实例，降低代码之间的耦合度？
我们可以使用控制反转（Inversion of Control，缩写为IoC）设计原则解决上述问题，通过依赖注入（Dependency Injection，缩写DI）实现IOC。
这里通过引入开源的轻量级的 DI 容器 AutoFac ，把会产生依赖的对象添加到容器当中，把对象创建实例的权限交给容器，当BlogService内部需要使用 BlogRepository 时，是通过容器，把 BlogRepository 注入到 BlogService 当中。
Blog.AutoFac.ConsoleApp：界面层（UI），负责展示数据；
Blog.AutoFac.Service：业务逻辑层（BLL），负责业务逻辑运算；
Blog.AutoFac.Repository：数据访问层（DAL），负责提供数据；
Blog.AutoFac.IService：业务逻辑抽象层（InterfaceBLL），业务逻辑运算抽象接口；
Blog.AutoFac.IRepository：数据访问抽象层（InterfaceDAL），数据访问抽象接口；
Blog.AutoFac.Ioc：控制反转，依赖注入的处理类。
通过 NuGet 包管理器安装 Autofac:
BlogService 类通过构造函数注入 BlogRepository 实例。
public class BlogService: IBlogService
{
readonly IBlogRepository _blogRepository;
public BlogService(IBlogRepository blogRepository)
{
_blogRepository = blogRepository;
}
public string GetBlogName(long BlogId)
{
return _blogRepository.GetBlogName(BlogId);
}
}
DIContainer 依赖注入类：
/// <summary>
/// 控制台程序容器
/// </summary>
public static class DIContainer
{
/// <summary>
/// 容器
/// </summary>
public static IContainer Instance;
/// <summary>
/// 初始化容器
/// </summary>
/// <returns></returns>
public static void Init()
{
//新建容器构建器，用于注册组件和服务
var builder = new ContainerBuilder();
//自定义注册
BuildrRegister(builder);
//利用构建器创建容器
Instance = builder.Build();
}
/// <summary>
/// 自定义注册
/// </summary>
/// <param name=\”builder\”></param>
public static void BuildrRegister(ContainerBuilder builder)
{
builder.RegisterType<BlogRepository>().As<IBlogRepository>();
builder.RegisterType<BlogService>().As<IBlogService>();
}
在控制台应用程序使用：
internal class Program
{
static void Main(string[] args)
{
// 初始化容器，将需要用到的组件添加到容器中
DIContainer.Init();
// 获取博客名称
IBlogService blogService = DIContainer.Instance.Resolve<IBlogService>();
string blogName = blogService.GetBlogName(1);
Console.WriteLine(blogName);
Console.ReadLine();
}
}
代码示例
四、Autofac 注册方式
4.1 实例注册
使用RegisterInstance把实例注册到容器有两种：
注册一个对象实例：
// 实例注册
var blogRepository = new BlogRepository();
builder.RegisterInstance(blogRepository).As<BlogRepository>();
注册已存在单例：
internal class Singleton
{
private static Singleton instance = null;
static Singleton() { }
private static object objectlock = new object();
public static Singleton Instance
{
get
{
lock (objectlock)
{
if (instance == null)
{
instance = new Singleton();
}
return instance;
}
}
}
}
builder.RegisterInstance(Singleton.Instance).ExternallyOwned();
4.2 反射注册
使用RegisterType<T>()或者RegisterType(typeof(T))方法，注入对象与暴露类型：
builder.RegisterType<BlogRepository>().As<IBlogRepository>();
builder.RegisterType<BlogService>().As(typeof(IBlogService));
4.3 泛型注册
使用泛型注册对仓储层的类注入：
builder.RegisterGeneric(typeof(BaseRepository<>))
.As(typeof(IBaseRepository<>)).InstancePerLifetimeScope();
4.4 程序集批量注册
var assemblies = Assembly.GetExecutingAssembly();
builder.RegisterAssemblyTypes(assemblies)
.Where(cc => cc.Name.EndsWith(\”Repository\”) | cc.Name.EndsWith(\”Service\”))
.PublicOnly() // 只要public访问权限的
.Where(cc => cc.IsClass) // 只要class型
.AsImplementedInterfaces(); // 所有接口类型暴露
builder.RegisterGeneric(typeof(BaseRepository<>)).As(typeof(IBaseRepository<>));
————————————————
版权声明：本文为CSDN博主「夜飞鼠」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/nmmking/article/details/130306821
