LCLFramework框架之IOC
我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。
借助于“第三方”实现具有依赖关系的对象之间的解耦，如下图：
LCLFramework框架之依赖注入(IOC)职责
- 依赖注入（Dependency Injection，简称DI）
- 依赖查找（Dependency Lookup）
- 控制反转
LCLFramework框架之依赖注入(IOC)设计
网上有很多的IOC框架如何让用户选择自己熟悉的IOC框架了，那LCL就需要提供可扩展的IOC应该如何让框架注入自己熟悉的IOC框架呢？
下图是基本的IOC扩展契约，所有的第三方都要实现IObjectContainer契约，下图中实现了，Unity，TinyIoc两个第三方IOC框架。
抛弃了ObjectContainer类，直接使用接口进行扩展
LCLFramework框架之依赖注入(IOC)设计代码
/// <summary>
/// 表示持久化事件时出现的并发异常
/// </summary>
public interface IObjectContainer
{
/// <summary>
/// 注册一个给定的类型及其所有实现的接口
/// </summary>
/// <param name="type"></param>
void RegisterType(Type type);
/// <summary>
/// 注册一个给定的类型及其所有实现的接口
/// </summary>
/// <param name="type"></param>
/// <param name="key"></param>
void RegisterType(Type type, string key);
/// <summary>
/// 注册给定程序集中符合条件的所有类型
/// </summary>
/// <param name="typePredicate"></param>
/// <param name="assemblies"></param>
void RegisterTypes(Func<Type, bool> typePredicate, params Assembly[] assemblies);
/// <summary>
/// 注册给定接口的实现
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <typeparam name="TImpl"></typeparam>
/// <param name="life"></param>
void Register<TService, TImpl>(LifeStyle life)
where TService : class
where TImpl : class, TService;
/// <summary>
/// 注册给定接口的实现
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <typeparam name="TImpl"></typeparam>
/// <param name="key"></param>
/// <param name="life"></param>
void Register<TService, TImpl>(string key, LifeStyle life = LifeStyle.Singleton)
where TService : class
where TImpl : class, TService;
/// <summary>
/// 注册给定接口的默认实现
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <typeparam name="TImpl"></typeparam>
/// <param name="life"></param>
void RegisterDefault<TService, TImpl>(LifeStyle life)
where TService : class
where TImpl : class, TService;
/// <summary>
/// 注册给定类型的实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instance"></param>
/// <param name="life"></param>
void Register<T>(T instance, LifeStyle life) where T : class;
/// <summary>
/// 注册给定类型的实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instance"></param>
/// <param name="key"></param>
/// <param name="life"></param>
void Register<T>(T instance, string key, LifeStyle life) where T : class;
/// <summary>
/// 判断给定的类型是否已经注册
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
bool IsRegistered(Type type);
/// <summary>
/// 判断给定的类型是否已经注册
/// </summary>
/// <param name="type"></param>
/// <param name="key"></param>
/// <returns></returns>
bool IsRegistered(Type type, string key);
/// <summary>
/// 获取给定类型的一个实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
T Resolve<T>() where T : class;
/// <summary>
/// 获取给定类型的一个实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
T Resolve<T>(string key) where T : class;
/// <summary>
/// 获取给定类型的一个实例
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
object Resolve(Type type);
/// <summary>
/// 获取给定类型的一个实例
/// </summary>
/// <param name="key"></param>
/// <param name="type"></param>
/// <returns></returns>
object Resolve(string key, Type type);
}
[DebuggerDisplay("ObjectContainer = {_container}")]
public class ServiceLocator
{
private readonly IObjectContainer _container = LEnvironment.AppObjectContainer;
public static readonly ServiceLocator Instance = new ServiceLocator();
private ServiceLocator()
{
}
/// <summary>
/// 注册一个给定的类型及其所有实现的接口
/// </summary>
/// <param name="type"></param>
public void RegisterType(Type type)
{
_container.RegisterType(type);
}
/// <summary>
/// 注册一个给定的类型及其所有实现的接口
/// </summary>
/// <param name="type"></param>
/// <param name="key"></param>
public void RegisterType(Type type, string key)
{
_container.RegisterType(type, key);
}
public void RegisterType(Type type, Type Impl)
{
//_container.RegisterType()
}
/// <summary>
/// 注册给定程序集中符合条件的所有类型
/// </summary>
/// <param name="typePredicate"></param>
/// <param name="assemblies"></param>
public void RegisterTypes(Func<Type, bool> typePredicate, params Assembly[] assemblies)
{
_container.RegisterTypes(typePredicate, assemblies);
}
/// <summary>
/// 注册给定接口的实现
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <typeparam name="TImpl"></typeparam>
/// <param name="life"></param>
public void Register<TService, TImpl>(LifeStyle life = LifeStyle.Singleton)
where TService : class
where TImpl : class, TService
{
_container.Register<TService, TImpl>(life);
}
/// <summary>
/// 注册给定接口的实现
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <typeparam name="TImpl"></typeparam>
/// <param name="key"></param>
/// <param name="life"></param>
public void Register<TService, TImpl>(string key, LifeStyle life = LifeStyle.Singleton)
where TService : class
where TImpl : class, TService
{
_container.Register<TService, TImpl>(key, life);
}
/// <summary>
/// 注册给定接口的默认实现
/// </summary>
/// <typeparam name="TService"></typeparam>
/// <typeparam name="TImpl"></typeparam>
/// <param name="life"></param>
public void RegisterDefault<TService, TImpl>(LifeStyle life = LifeStyle.Singleton)
where TService : class
where TImpl : class, TService
{
_container.RegisterDefault<TService, TImpl>(life);
}
/// <summary>
/// 注册给定类型的实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instance"></param>
/// <param name="life"></param>
public void Register<T>(T instance, LifeStyle life = LifeStyle.Singleton) where T : class
{
_container.Register<T>(instance, life);
}
/// <summary>
/// 注册给定类型的实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="instance"></param>
/// <param name="key"></param>
/// <param name="life"></param>
public void Register<T>(T instance, string key, LifeStyle life = LifeStyle.Singleton) where T : class
{
_container.Register<T>(instance, key, life);
}
/// <summary>
/// 判断给定的类型是否已经注册
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public bool IsRegistered(Type type)
{
return _container.IsRegistered(type);
}
/// <summary>
/// 判断给定的类型是否已经注册
/// </summary>
/// <param name="type"></param>
/// <param name="key"></param>
/// <returns></returns>
public bool IsRegistered(Type type, string key)
{
return _container.IsRegistered(type, key);
}
/// <summary>
/// 获取给定类型的一个实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public T Resolve<T>() where T : class
{
return _container.Resolve<T>();
}
/// <summary>
/// 获取给定类型的一个实例
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
public T Resolve<T>(string key) where T : class
{
return _container.Resolve<T>(key);
}
/// <summary>
/// 获取给定类型的一个实例
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public object Resolve(Type type)
{
return _container.Resolve(type);
}
/// <summary>
/// 获取给定类型的一个实例
/// </summary>
/// <param name="key"></param>
/// <param name="type"></param>
/// <returns></returns>
public object Resolve(string key, Type type)
{
return _container.Resolve(key, type);
}
}
LCLFramework框架之IOC扩展
public class UnityObjectContainer : IObjectContainer
{
private IUnityContainer _unityContainer;
public UnityObjectContainer()
{
_unityContainer = new UnityContainer();
}
public UnityObjectContainer(IUnityContainer unityContainer)
{
_unityContainer = unityContainer;
}
public IUnityContainer UnityContainer
{
get { return _unityContainer; }
}
public void RegisterType(Type type)
{
var life = ParseLife(type);
if (!_unityContainer.IsRegistered(type))
{
if (life == LifeStyle.Singleton)
{
_unityContainer.RegisterType(type, new ContainerControlledLifetimeManager());
}
else
{
_unityContainer.RegisterType(type);
}
}
foreach (var interfaceType in type.GetInterfaces())
{
if (!_unityContainer.IsRegistered(interfaceType))
{
if (life == LifeStyle.Singleton)
{
_unityContainer.RegisterType(interfaceType, type, new ContainerControlledLifetimeManager());
}
else
{
_unityContainer.RegisterType(interfaceType, type);
}
}
}
}
public void RegisterType(Type type, string key)
{
var life = ParseLife(type);
if (!IsRegistered(type, key))
{
if (life == LifeStyle.Singleton)
{
_unityContainer.RegisterType(type, new ContainerControlledLifetimeManager());
}
else
{
_unityContainer.RegisterType(type);
}
}
foreach (var interfaceType in type.GetInterfaces())
{
if (!IsRegistered(interfaceType, key))
{
if (life == LifeStyle.Singleton)
{
_unityContainer.RegisterType(interfaceType, type, new ContainerControlledLifetimeManager());
}
else
{
_unityContainer.RegisterType(interfaceType, type);
}
}
}
}
public void RegisterTypes(Func<Type, bool> typePredicate, params Assembly[] assemblies)
{
foreach (var assembly in assemblies)
{
foreach (var type in assembly.GetExportedTypes().Where(x => typePredicate(x)))
{
RegisterType(type);
}
}
}
public void Register<TService, TImpl>(LifeStyle life = LifeStyle.Singleton) where TService : class where TImpl : class, TService
{
if (life == LifeStyle.Singleton)
{
_unityContainer.RegisterType<TService, TImpl>(new ContainerControlledLifetimeManager());
}
else
{
_unityContainer.RegisterType<TService, TImpl>();
}
}
public void Register<TService, TImpl>(string key, LifeStyle life = LifeStyle.Singleton)
where TService : class
where TImpl : class, TService
{
if (life == LifeStyle.Singleton)
{
_unityContainer.RegisterType<TService, TImpl>(key, new ContainerControlledLifetimeManager());
}
else
{
_unityContainer.RegisterType<TService, TImpl>(key);
}
}
public void RegisterDefault<TService, TImpl>(LifeStyle life = LifeStyle.Singleton)
where TService : class
where TImpl : class, TService
{
if (life == LifeStyle.Singleton)
{
_unityContainer.RegisterType<TService, TImpl>(new ContainerControlledLifetimeManager());
}
else
{
_unityContainer.RegisterType<TService, TImpl>();
}
}
public void Register<T>(T instance, LifeStyle life = LifeStyle.Singleton) where T : class
{
if (life == LifeStyle.Singleton)
{
_unityContainer.RegisterInstance<T>(instance, new ContainerControlledLifetimeManager());
}
else
{
_unityContainer.RegisterInstance<T>(instance);
}
}
public void Register<T>(T instance, string key, LifeStyle life = LifeStyle.Singleton) where T : class
{
if (life == LifeStyle.Singleton)
{
_unityContainer.RegisterInstance<T>(key, instance, new ContainerControlledLifetimeManager());
}
else
{
_unityContainer.RegisterInstance<T>(key, instance);
}
}
public bool IsRegistered(Type type)
{
return _unityContainer.IsRegistered(type);
}
public bool IsRegistered(Type type, string key)
{
return _unityContainer.IsRegistered(type, key);
}
public T Resolve<T>() where T : class
{
return _unityContainer.Resolve<T>();
}
public T Resolve<T>(string key) where T : class
{
return _unityContainer.Resolve<T>(key);
}
public object Resolve(Type type)
{
return _unityContainer.Resolve(type);
}
public object Resolve(string key, Type type)
{
return _unityContainer.Resolve(type, key);
}
private static LifeStyle ParseLife(Type type)
{
var componentAttributes = type.GetCustomAttributes(typeof(ComponentAttribute), false);
return componentAttributes.Count() <= 0 ? LifeStyle.Transient : (componentAttributes[0] as ComponentAttribute).LifeStyle;
}
}
LCLFramework框架之IOC的更多相关文章
- LCLFramework框架 1.1 Pre-Alpha 源码公布
使用开发框架的好处:1.框架在技术上为软件系统提供了完整的模式实践2.框架为团队提供了合理可行的软件开发过程模式3.框架的应用大大提高了团队的开发效率,团队只需要关注与领域相关的业务实现,而无需关注具 ...
- LCLFramework框架之Plugin模式
插件应用架构概述 基于LCLFramework插件框架的应用由以下三个部分构成: (1)主程序:针对特定应用环境(Web.WinForm等应用环境),加载启动插件,获取插件入口,运行入口程序. (2) ...
- LCLFramework框架之数据门户
LCLFramework框架之数据门户职责 形成统一的数据访问方式. LCLFramework框架之数据门户设计 数据门户分为客户端/服务端. LCLFramework框架之数据门户设计代码 数 ...
- LCLFramework框架之Service模式
Service模式介绍 领域中的一些概念不太适合建模为对象,即归类到实体对象或值对象,因为它们本质上就是一些操作,一些动作,而不是事物.这些操作或动作往往会涉及到多个领域对象,并且需要协调这些领域对象 ...
- LCLFramework框架之Repository模式
Respository模式在示例中的实际目的小结一下 Repository模式是架构模式,在设计架构时,才有参考价值: Repository模式主要是封装数据查询和存储逻辑: Repository模式 ...
- Spring框架(3)---IOC装配Bean(注解方式)
IOC装配Bean(注解方式) 上面一遍文章讲了通过xml来装配Bean,那么这篇来讲注解方式来讲装配Bean对象 注解方式需要在原先的基础上重新配置环境: (1)Component标签举例 1:导入 ...
- Spring框架之IOC(控制反转)
[TOC] 第一章Spring框架简介 IOC(控制反转)和AOP(面向方面编程)作为Spring框架的两个核心,很好地实现了解耦合.所以,简单来说,Spring是一个轻量级的控制反转(IoC)和面向 ...
- Spring框架中IoC(控制反转)的原理（转）
原文链接:Spring框架中IoC(控制反转)的原理 一.IoC的基础知识以及原理: 1.IoC理论的背景:在采用面向对象方法设计的软件系统中,底层实现都是由N个对象组成的,所有的对象通过彼此的合作, ...
- Spring框架的IOC核心功能快速入门
2. 步骤一:下载Spring框架的开发包 * 官网:http://spring.io/ * 下载地址:http://repo.springsource.org/libs-release-local/ ...
随机推荐
- opengles tutorial
https://developer.apple.com/library/ios/documentation/3DDrawing/Conceptual/OpenGLES_ProgrammingGuide ...
- C++ map使用（基于hashtable）
C++ map使用(基于hashtable) 实际上基于hashtable的map有两种一种是hash_map,unordered_map,但是最好使用后者,原因如下[1] 因为标准化的推进,unor ...
- 用scala实现一个sql执行引擎-(上)
前言 在实时计算中,通常是从队列中收集原始数据,这种原始数据在内存中通常是一个java bean,把数据收集过来以后,通常会把数据落地到数据库,供后面的ETL使用.举个一个简单的例子,对一个游戏来说, ...
- Activity之间的通信
通常Activity之间的通信有三种方式:单向不传参数通信.单项传参数通信和双向通信. 这几种传递方式都需要通信使者Intent.以下将用代码来辅助理解. 1.单向不传递参数通信 public cla ...
- poj3468 A Simple Problem with Integers (线段树区间最大值)
A Simple Problem with Integers Time Limit: 5000MS Memory Limit: 131072K Total Submissions: 92127 ...
- 关于mysql占用CPU过高，问题解决
使用SHOW PROCESSLIST 查看 原因: 使用了 一个触发器 不断的去删除日志,保证每个用户的日志只有10条 去掉之后,CPU使用率从97% 降到了 %. 利用show columns fr ...
- Webpack使用教程四（Loaders）
Loaders是webpack最有用的特性之一,通过Loaders,webpack可以预处理源码文件中的Json文件或者将包含新特性的Javascript代码转换成浏览器能处理的JavaScript代 ...
- ASP.NET MVC学习之Ajax（完结）
一.前言 通过上面的一番学习,大家一定收获不少.但是总归会有一个结束的时候,但是这个结束也意味着新的开始. 如果你是从事ASP.NET开发,并且也使用了第三方控件,那么一定会觉得ASP.NET开发aj ...
- SRS用列建模
基本规则: 五子棋是两个人之间进行的竞技活动,由于对黑方白方 规则不同,黑棋必须先行.五子棋专用盘为 15×15 , 五连子的方向为横.竖.斜. 禁手是对局中被判为负的行棋手段.白棋无禁手. 在棋盘上 ...
- 写给自己看的Linux运维基础(二) - Apache/MySQL. 安全设置. 定时任务
本文使用环境为CentOS 6 Apache, PHP, MySQL等常用软件均可通过yum安装包获取 yum install httpd php mysql-server # mysql: 客户端; ...