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/ ...
随机推荐
- Python 2 —— 基本数据类型及其运算
基本运算 一.数字 **表示乘方运算 12 / 3 = 4.0浮点数 12 // 3 = 4整数 二.字符串 1.表示 单行:'...'或者"..." 多行:'''...'''或者 ...
- Windows 8.1 应用再出发 (WinJS) - 创建一个简单项目
前面几篇我们介绍了如何利用 C# + XAML 完成Windows Store App 功能的实现,接下来的几篇我们来看看如何利用 Html + WinJS 来完成这些功能. 本篇我们使用WinJS ...
- 项目启动异常java.lang.OutOfMemoryError: PermGen space
java.lang.OutOfMemoryError: PermGen space 解决办法: Eclipse-->window-->Tomcat -->JVM setting - ...
- [ACM_模拟] POJ 1094 Sorting It All Out (拓扑排序+Floyd算法 判断关系是否矛盾或统一）
Description An ascending sorted sequence of distinct values is one in which some form of a less-than ...
- 微软 PowerShell Script Explorer 满血复活，正式发布
一年前的今天,微软在其Windows PowerShell官方博客声明中止 ‘Script Explorer’ 应用程序的开发. 一年后的今天,微软为其Script Explorer注入了新的生命.一 ...
- javascript中重要概念-闭包-深入理解
在上次的分享中javascript--函数参数与闭包--详解,对闭包的解释不够深入.本人经过一段时间的学习,对闭包的概念又有了新的理解.于是便把学习的过程整理成文章,一是为了加深自己闭包的理解,二是给 ...
- C语言实现单链表-03版
在C语言实现单链表-02版中我们只是简单的更新一下链表的组织方式: 它没有更多的更新功能,因此我们这个版本将要完成如下功能: Problem 1,搜索相关节点: 2,前插节点: 3,后追加节点: 4, ...
- Install wget for mac
Download: http://ftp.gnu.org/gnu/wget/ Unpack: tar zxvf wget-1.16.tar Configuration: ./configure If ...
- Redis 环境搭建与使用(C#)
Redis Redis是一个开源的使用ANSI C语言编写.支持网络.可基于内存亦可持久化的日志型.Key-Value数据库,并提供多种语言的API. Redis是一个key-value存储系统.和M ...
- Leetcode 1 Two Sum STL
题意:给定一个目标值target,找到两个数的和为target,返回这两个数的下标 用map记录每个数的下标,并用于查找 class Solution { public: vector<int& ...