StrangIOC详解

最新推荐文章于 2021-04-19 19:13:19 发布
最新推荐文章于 2021-04-19 19:13:19 发布
阅读量777 收藏 1
点赞数
分类专栏： StrangIOC 文章标签： StrangIOC

这是接上面的博文讲到的StrangeIoc的简要介绍后（参考http://blog.csdn.net/leoleocs/article/details/47664221），介绍一下extension中详细的内容，以及如何在Unity3d中使用该框架。

Extensions

该框架的应用是以extension的扩展为基础的，主要的扩展如下：

Injection extension

Injection的扩展可以说是松耦合绑定的基础，使逻辑和显示分离得以实现，正如官方文档所言，很多人将StrangeIoc这套框架成为Dependency Injection框架， 这个其实是由Injection扩展来是实现的，具体的类图如下： 
这里写图片描述

Injection是利用反射来实现Injection功能，比如下面的例子代码：

    public interface ISpaceship
    {
    void input(float angle, float velocity);
    IWeapon weapon{get;set;}
    }
    public class Spaceship : ISpaceship
    {
        public void input(float angle, float velocity)
        {
        //do stuff here
        }
        public IWeapon Weapon{get;set;}
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

我们对接口编程，有一个飞船的接口，他拥有武器接口IWeapon，这个可能是需要其他的类去set了，这个”其他的类” 就有依赖了。

那么如何去解除这样的依赖呢？ 我们可以用Injection中的扩展来解除这样的依赖，具体的做法如下：

    public class Spaceship : ISpaceship
    {
        public void input(float angle, float velocity)
        {
        //do stuff here
        }
        //增加Inject的属性
        **[Inject]**
        public IWeapon Weapon{get;set;}
    }

//用下面的方法来增加绑定
injectionBinder.Bind<IWeapon>().To<PhaserGun>();
injectionBinder.Bind<ISpaceship>().To<Spaceship>();
// 下面的方法可以生成SpaceShip类对象，并且其会自动帮我们设置Weapon属性
// 简单吧
ISpaceship spaceShip = injectionBinder.GetInstance<ISpaceship>() as ISpaceship;

// 如果你想换武器，就修改绑定，将PhaserGun换成其他的实现了IWeapon的具体类
injectionBinder.Bind<IWeapon>().To<Cannon>();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

在实际Injection的应用中，有两种不同的Injection属性的应用，【Inject】和【construct】，【Construct】是在构造函数中使用，可以用如下方式设置：

    public Spaceship()
    {
    //This constructor gets called by default...
    }
    [Construct]
    public Spaceship(IWeapon weapon)
    {
    //...but this one is marked, so Strange will call it instead
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

除此外，我们还可以使用【PostConstruct】属性，标记有PostConstruct属性的方法会在完成构造和Injection后调用。具体用法如下：

    [PostConstruct]
    public void PostConstruct()
    {
    //Do stuff you’d normally do in a constructor
    }
  • 1
  • 2
  • 3
  • 4
  • 5

在我们使用Injection的时候，需要注意下列事项

  1. 循环依赖问题，Injection框架可以帮我们检查这样的错误并且抛出异常，但是我们最好在写代码的时候防止这么做，下面就是一个简单的例子，在实际情况中的依赖可能比这个负责，比如，A - >B -> C- >D，而D最后又需要A。
    public class Spaceship : ISpaceship
    {
        public void input(float angle, float velocity)
        {
        //do stuff here
        }
        //增加Inject的属性
        [Inject]
        public IWeapon Weapon{get;set;}
    }
    public class PhaserGun: IWeapon 
    {
        //增加Inject的属性
        [Inject]
        public ISpaceship Spaceship{get;set;}
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

2 Injection 是利用反射来实现，反射比较慢，我们可以利用ReflectionBinder中的RefectAll提前来完成反射。 
3 我们必须记住的是，任何的依赖都需要binding去记住mapping，如果我们忘记了增加Binding，就会产生空对象异常， Injection会帮助我们查看这些错误。

Dispatcher extension

Event Dispatcher 和Singal都可以看作是Dispatcher的扩展，其实就是一种Observer设计模式的松耦合实现。基本的类关系图如下： 
这里写图片描述

这里写图片描述

本质上都是Observer的实现方式，下面的Command extension 和Mediator extension都会用Dispatch将MVC设计模式中的M，V，C联系到一起。

具体的例子代码如下：

dispatcher.AddListener("FIRE_MISSILE", onMissileFire);
dispatcher.AddListener(AttackEvent.FIRE_MISSILE, onMissileFire);
dispatcher.UpdateListener(true, AttackEvent.FIRE_MISSILE, onMissileFire);

// callback funciton without payload
private void onMissileFire()
{
//this works...
}
// callback funciton with payload
private void onMissileFire(IEvent evt)
{
    //...and so does this.
    Vector3 direction = evt.data as Vector3;
}
// 无参数的onMissileFire将会被调用
dispatcher.Dispatch(AttackEvent.FIRE_MISSILE); 
Vector3 orientation = gameObject.transform.localRotation.eulerAngles;

// 带参数的onMissileFire将会被调用
dispatcher.Dispatch(AttackEvent.FIRE_MISSILE, orientation);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

Command extension

Dispatch是将Event绑定在方法上，而Command extension是将Event绑定到具体的Command上，Command的使用应该是MVCS设计模式中的Controller（C），基本类之间的关系如下： 
这里写图片描述

CommandBinder可以将具体的Event或者Signal来绑定到具体的Command上，其负责利用Event或者Signal来找到，或者创建一个Command。我们可以看下面的简单的Command，


public class StartGameCommand : EventCommand
{
    [Inject]
    public ITimer gameTimer{get;set;}
    override public void Execute()
    {
        gameTimer.start();
        dispatcher.dispatch(GameEvent.STARTED);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

接下来，我们可以下面的方式将event和Command绑定起来

commandBinder.Bind(ServerEvent.StartGame).To<StartGameCommand>();
//  解除绑定
commandBinder.Unbind(ServerEvent.StartGame);
  • 1
  • 2
  • 3

如果想执行StartGameCoammnd，只需要调用 dispatcher.dispatch(ServerEvent.StartGame);

当然，我们也可以将Signal和Command绑定起来，在用Signal绑定以前，我们需要使用SignalCommandBinder类，代码如下:

protected override void addCoreComponents()
{
    base.addCoreComponents();
    injectionBinder.Unbind<ICommandBinder>();
    injectionBinder.Bind<ICommandBinder>().To<SignalCommandBinder>   ().ToSingleton();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

如何我们使用了SignalCommandBinder后，就可以用下面的代码简单的绑定起来了

commandBinder.Bind<SomeSignal>().To<SomeCommand>();
  • 1

如果我们要调用SomeCommand，只需要调用SomeSignal.Dispatch () 就可以了

Mediation extension

Mediation 扩展是整个StrangeIoc框架中唯一依赖Unity3D的API的扩展，这是因为mediation是用于处理显示（Views，GameObject）和除显示外的应用程序逻辑的。在这个框架中，其把显示部分分成了View和Mediator，具体的类层次关系如下： 
这里写图片描述

在实际应用中，我们可以做如下实现，

    public class TestView : EventView
    {       
        internal void init()
        {
            // do the init work
        }
        void OnMouseDown()
        {
            dispatcher.Dispatch(CLICK_EVENT);
        }
    }

    public class ExampleMediator : EventMediator
    {
        //This is how your Mediator knows about your View.
        [Inject]
        public ExampleView view{ get; set;}

        public override void OnRegister()
        {       
            //Listen to the view for an event
            view.dispatcher.AddListener(CLICK_EVENT, onViewClicked);

            view.init ();
        }

        public override void OnRemove()
        {
            //Clean up listeners when the view is about to be destroyed
            view.dispatcher.RemoveListener(CLICK_EVENT, onViewClicked);
            Debug.Log("Mediator OnRemove");
        }

        private void onViewClicked()
        {
            Debug.Log("View click detected");
            // 这部分会和其他的应用层逻辑相关联
            dispatcher.Dispatch(REQUEST_WEB_SERVICE);
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

我们实现看上述的View和Mediator后，需要调用下面的方法将他们绑定起来，

mediationBinder.Bind<ExampleView>().To<ExampleMediator>();
  • 1

Context extension

Context extension 是整个strangeIoc 的MVCS框架应用的基础，其组合了前面所有的extension，具体的关系如下图 
这里写图片描述

MVCS框架

我们可以参考官方的图来了解这个MVCS应用框架， 具体的原图在http://strangeioc.github.io/strangeioc/，我原封不动的贴在这里： 
这里写图片描述

所以整个框架的使用主要是应用了上面的扩展来实现松耦合 
我们需要注意下面的事情

  1. 程序的入口点为ContextView，其会创建程序的MVCSContext
  2. 具体程序的MVCSContext将初始化所有的绑定，如Injection, Command,Dispatcher
  3. Dispatcher是通信总线，所有的回调，消息传递都是通过Dispatch来实现的，实际上也就是Observer模式的实现。
  4. Command可以被事件和Signal触发，其控制了具体的程序逻辑。
  5. Model记录了具体的应用程序状态
  6. Service是用于网络交互，和应该程序外的，如Web，Socket等
  7. View是MonoBehaviours,会attach到具体的GameObject上，是控制具体的显示和用户交互
  8. Mediators虽然也是MonoBehaviours，但是其一般作为中介交互View与程序其他部分交互。

总体上来讲，的确可以实现松耦合，能更好的实现大型项目的并行开发。

w87580575
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
StrangeIoc框架的详细介绍
leoleocs的专栏
08-27 7686
这是接上面的博文讲到的StrangeIoc的简要介绍后（参考http://blog.csdn.net/leoleocs/article/details/47664221），介绍一下extension中详细的内容，以及如何在Unity3d中使用该框架。Extensions该框架的应用是以extension的扩展为基础的，主要的扩展如下：Injection extensionInjection的扩展可以
strangeioc
01-30
strangeioc的官方资源，包含源码、demo等
【IOC框架】分析与理解
weixin_34153893的博客
02-01 3873
1 IoC理论的背景我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。图1：软件系统中耦合的对象如果我们打开机械式手表的后盖，就会看到与上面类似的情形，各个齿轮分别带动时针、分针和秒针顺时针旋转，从而在表盘上产生正确的时间。图1中描述的就是这样的一个齿轮组，它拥有多个独立的齿轮，这些齿轮相互啮合在一起，协同工作，共同...
架构师之路(39)---IoC框架
weixin_34261415的博客
06-22 72
1 IoC理论的背景     我们都知道，在採用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，全部的对象通过彼此的合作，终于实现系统的业务逻辑。   图1：软件系统中耦合的对象     假设我们打开机械式手表的后盖，就会看到与上面类似的情形，各个齿轮分别带动时针、分针和秒针顺时针旋转，从而在表盘上产生正确的时间。图1中描写叙述的就是这种一个齿轮组，它拥有多...
StrangeIOC
09-02
Strange是为C#和unity编写的轻量级和高扩展性的IOC框架。我们已经将Strange在web，standalone，IOS和android平台。
QValueAxis详解
04-06
QValueAxis详解QValueAxis详解QValueAxis详解QValueAxis详解QValueAxis详解QValueAxis详解QValueAxis详解QValueAxis详解QValueAxis详解QValueAxis详解QValueAxis详解QValueAxis详解QValueAxis详解QValueAxis详解...
iptables 详解iptables 详解
最新发布
12-02
iptables 详解
c#深入详解
08-29
详细介绍C#的基础知识，包括体系结构、开发环境的搭建、面向对象的思想以及对XML、数据库的基本应用等等
MDX语法详解
11-17
Microsoft SQL Server Analysis Services 多维数据集是基于度量值、维度和维度属性来组织的。下表说明了使用 MDX 表达式语言所需了解的维度建模术语和概念。
cdn技术详解
01-25
cdn技术详解，高清影印版，内含部分心得。 cdn技术详解，高清影印版，内含部分心得。
unityStrangeIoc
11-30
前言 unity的框架，除了各大公司自己内部使用的，开源并好用的实际并不是很多，我会慢慢挖掘，依次写出自己的一点见解，错误的地方，望各路大神指正。 一、基本概念 控制反转（Inversion of Control，英文缩写为IOC），我的理解就是，原本A类要获取B类的对象，需要你在A类中自己New一个对象，那么是由A来获取并控制B的对象，IOC就是把对象获取的这个过程交给容器和依赖注入来处理，A类并不知道B的对象是哪里来的，对B对象的控制，由自己变成了其他类，官方一点的概念可以百度，这个还是蛮多的。 二、StrangeIOC基础类型 实际要理解一个框架的类型，还是要自己看源码，这里我只说一下几个重要类型的作用，这个看源码的时候有个印象，也方便理解，而且说这部分的帖子也很多，我就不再赘述了。 1.Context 上下文组件定义程序边界，也就是可以把一个程序定义成多上下文，让代码更加模块化 它提供了程序入口，也算是框架中耦合度最高的地方 2.Binder和Binding 这两个类是这个框架最重要的组成部分 Binding存储了对象的绑定关系，而Binder存储了Binding的对象 3.View和Mediator MVCS中的View层，View只用于显示，也就是View只负责管理UI，Mediator负责界面逻辑，事件响应等 4.Model MVCS中的Model层，负责数据部分 5.Command MVCS中的Control层，负责执行逻辑代码 6.Service MVCS中的Service层，负责与第三方交互，这个Service我理解的，并不是一定指代服务器，也可以是其他的软件，什么都可以，它就是我们程序对外的接口 7.Dispatcher 派发器是框架内通信主线的其中一种，用来派发消息，触发命令，从而进一步解耦 8.Signal 信号是框架内另外一种通信主线，它采用强类型，来绑定信号和命令之间的关系，实现消息响应的触发 9.ReflectionBinder 反射部分，通过binding来获取类的信息，存储在ReflectedClass中 10.injector 注入器,通过反射获取的信息，来实例化请求的对象 --------------------- 作者：蓝天小僧 来源：CSDN 原文：https://blog.csdn.net/zcaixzy5211314/article/details/80876228 版权声明：本文为博主原创文章，转载请附上博文链接！
StrangeIoC框架Demo
04-02
一个用StrangeIoC（MVCS）框架来实现的一个小Demo 我的一篇博客里介绍了如何编写这个Demo 大家可以和博文一起来学习
Unity框架探索——StrangeIOC篇
热门推荐
蓝天小僧的博客
07-01 1万+
前言 unity的框架，除了各大公司自己内部使用的，开源并好用的实际并不是很多，我会慢慢挖掘，依次写出自己的一点见解，错误的地方，望各路大神指正。 一、基本概念 控制反转（Inversion of Control，英文缩写为IOC），我的理解就是，原本A类要获取B类的对象，需要你在A类中自己New一个对象，那么是由A来获取并控制B的对象，IOC就是把对象获取的这个过程交给容器和依赖注入来...
IOC框架
daosen233的博客
04-19 309
大学生播客大赛 Spring框架之IOC ##概述：Spring是一个Service层的框架，它可以整合许多其它框架进行工作。Spring的主要技术就是IOC(DI)和AOP。 IOC(DI) - 控制反转（依赖注入）： 控制反转就是将对象的创建及生命周期的管理过程交给Spring来处理的过程。在此开发过程中不在需要去关注对象的创建以及对象生命周期的管理，而是在需要的时候由Spring框架提供。 IOC实现原理： 在初始化一个Spring容器时，Spring会去解析指定的xml文件，当解析到其中的标签时，会
IoC框架
Visual Studio MVC之路
10-27 415
IoC框架
Ioc框架
qq_41670132的博客
09-27 173
关于IoC框架，个人认为解释的最透彻的文章 https://blog.csdn.net/wanghao72214/article/details/3969594
Unity3D StrangeIoc框架类图
辣椒酱的博客
03-24 5136
strangeioc 框架。其核心是通过 依赖注入和控制反转来实现各个功能模块之间的解耦。从而实现，再改需求的时候，想改哪里就改哪里，多人分模块开发的需求。有没有觉得依赖注入和控制反转这俩名词，听着就很高端。 这个框架在github或者unity官方商店都能找到，建议还是unity官方商店的，下载下来的还有demo。框架使用很简单。算的上市PureMvc的变种吧。很快就能上手用。 上图是文档中
IOC 框架（依赖注入 DI）
weixin_44766402的博客
05-23 709
1、IOC理论背景 我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。 [图1：软件系统中耦合的对象] 如果我们打开机械式手表的后盖，那么我们就可以看到如上图 类似的情景，各个齿轮分别带动时针、分针和秒针顺时针旋转，从而在表盘上产生正确的时间。 而在软件系统中对象之间的耦合关系非常类似于此，这些对象（齿轮）互相耦合...
轻量级IOC框架SwiftSuspenders
weixin_30509393的博客
07-31 182
该框架的1.6版本位于https://github.com/tschneidereit/SwiftSuspenders/blob/the-past/，现在已经出了重新架构的2.0版本，所以我决定先研究已经成熟的1.6版本，有时间再研究2.0版本的。 IOC的基本知识 控制反转（Inversion of Control，英文缩写为IoC）又叫做依赖注入（Dependency Injecti...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值