Ninject使用介绍

    #region 第二种写法
    /// <summary>
    ///  using(IKernel tKernel=new StandardKernel(new PeoKernelServer()))
    /// {
    ///     ISay tSay= tKernel.Get<ISay>();
    ///     IPeople tPeople = new PeoEnglish(tSay);
    ///     tPeople.sayHello();
    /// }
    /// </summary>
    public class PeoKernelServer : NinjectModule
    {
        public override void Load()
        {
            Bind<ISay>().To<ChinaSay>();//这个地方用法类似第一种
        }
    }
    #endregion
    #region 第一种写法
    /// <summary>
    /// ISay pSay = PeoKernel.PeoKernelSigle.KernelSingle.Get<ISay>();
    /// IPeople pEoChina = new PeoChina(pSay);
    /// pEoChina.Name = "陈国岭";
    /// pEoChina.sayHello();
    /// </summary>
    public class PeoKernel
    {
        protected static PeoKernel _PeoKernel = new PeoKernel();
        public static PeoKernel PeoKernelSigle
        {
            get
            {
                return _PeoKernel;
            }
        }
        protected Ninject.IKernel _Kernel = null;
        public Ninject.IKernel KernelSingle
        {
            get
            {
                return _Kernel;
            }
        }
        protected PeoKernel()
        {
            _Kernel = new StandardKernel();
            BindClass();
        }
        protected void BindClass()
        {
            #region  简单绑定

            //_Kernel.Bind<ISay>().To<ChinaSay>();//1、一般绑定,必须有无参数构造函数
            #region 绑定方法
            //Ø To:绑定到接口的具体实现。
            //Ø ToConstant:绑定到某个常量值。
            //Ø ToMethod:绑定到方法。
            //Ø ToProvider:绑定到某个自定义的对象创建提供程序。
            //Ø ToSelf:自绑定
            #endregion
            //_Kernel.Bind<ISay>().To<EnglishSay>().WithConstructorArgument(true);//2.构造函数中,参数绑定,可以没有无参数构造函数
            #region 参数绑定
            // Ø WithConstructorArgument:指定构造函数中相关的参数,还有回调方法的重载。
            //Ø WithMetadata:指定相关元数据信息。
            //Ø WithParameter:指定相关的自定义参数。这个方法也实现构造函数参数值指定,与WithConstructorArgument类似,如:Bind<IMessage>().To<MessageDB>().WithConstructorArgument("msg", 1);同样可以写成:Bind<IMessage>().To<MessageDB>().WithParameter(new ConstructorArgument("msg", 1));
            //Ø WithPropertyValue:指定相关的属性值,还有回调方法的重载。
            #endregion
            //_Kernel.Bind<ISay>().To<EnglishSay>().WithPropertyValue("IsEngOrUSALangle", false);//3.属性绑定,必须有无参构造函数。同样可以写成:Bind<IMessage>().To<MessageDB>().WithParameter(new ConstructorArgument("msg", 1));
            //_Kernel.Bind<PeoChina>().ToSelf();//4、自我绑定.自我绑定后,ISay无需传递。IPeople pEoChina = PeoKernel.PeoKernelSigle.KernelSingle.Get<PeoChina>();

            #endregion
            #region 属性注入
            //_Kernel.Bind<ISay>().To<AniSay>();
            //_Kernel.Bind<AniDog>().ToSelf();//在AniDog中,ISay属性必须添加[Ninject.Inject]特性
            #endregion
            #region 条件绑定
            //把ChinaSay指定为PeoChina中的ISay
            _Kernel.Bind<ISay>().To<ChinaSay>().WhenInjectedInto<PeoChina>();//1、一般绑定,必须有无参数构造函数
            //把EnglishSay指定为PeoEnglish中的ISay。同时EnglishSay传递参数true
            _Kernel.Bind<ISay>().To<EnglishSay>().WhenInjectedInto<PeoEnglish>().WithConstructorArgument(true);//2.构造函数中,参数绑定,可以没有无参数构造函数
            _Kernel.Bind<PeoChina>().ToSelf();
            _Kernel.Bind<PeoEnglish>().ToSelf();
            #endregion
            #region 线程调用
            _Kernel.Bind<ISay>().To<ChinaSay>().InThreadScope();//可以线程调用
            #region 调用 指定了对象在InThreadScope,在使用的代码中分别创建了2个线程来进行模拟,最终每个线程都是创建了一个对象。
            using (IKernel tKer = new StandardKernel(new PeoKernelServer()))
            {
                Thread tT1 = new Thread(new ThreadStart(() =>
                    {
                        ISay tPeoSay = tKer.Get<ISay>();
                        tPeoSay.SayLanager();
                    }));
                Thread tT2 = new Thread(new ThreadStart(() =>
                {
                    ISay tPeoSay = tKer.Get<ISay>();
                    tPeoSay.SayLanager();
                }));
                tT1.Start();
                tT2.Start();
            }
            #endregion

            #endregion
        }
    }
    #endregion
    #region 伪代码
    public interface ISay
    {
        string SayLanager();
    }
    public class ChinaSay : ISay
    {
        public ChinaSay()
        {

        }
        public string SayLanager()
        {
            return "汉语";
        }
    }
    public class EnglishSay : ISay
    {
        private bool _isEngOrUSALangle = false;

        public bool IsEngOrUSALangle
        {
            get { return _isEngOrUSALangle; }
            set { _isEngOrUSALangle = value; }
        }
        public EnglishSay()
        {

        }
        public EnglishSay(bool isEngOrUSALangle)
        {
            _isEngOrUSALangle = isEngOrUSALangle;
        }
        public string SayLanager()
        {
            string strEngLan = "EngLan";
            if (_isEngOrUSALangle)
            {
                strEngLan = "USALan";
            }
            return strEngLan;
        }
    }
    public interface IPeople
    {
        string Name { get; set; }
        void sayHello();
    }
    public abstract class PeopleBase : IPeople
    {
        protected string _Name = "";
        public string Name
        {
            get
            {
                return _Name;
            }
            set
            {
                _Name = value;
            }
        }

        public virtual void sayHello()
        {
            throw new NotImplementedException();
        }
    }
    public class PeoChina : PeopleBase
    {
        public PeoChina()
        {
        }
        private ISay _Say;
        public PeoChina(ISay pSay)
        {
            _Say = pSay;
        }
        public override void sayHello()
        {
            MessageBox.Show(string.Format("我是中国人,我叫:{0},我说:{1}", _Name, _Say.SayLanager()));
        }
    }
    public class PeoEnglish : PeopleBase
    {
        private ISay _Say;
        public PeoEnglish()
        {

        }
        public PeoEnglish(ISay pSay)
        {
            _Say = pSay;
        }
        public override void sayHello()
        {
            MessageBox.Show(string.Format("I am English,my name is :{0},I Say:{1}", _Name, _Say.SayLanager()));
        }
    }

    public class AniSay : ISay
    {
        public AniSay()
        {

        }
        public string SayLanager()
        {
            return "wang";
        }
    }
    public class AniDog
    {
        [Ninject.Inject]//属性注入
        public ISay jiao { get; set; }
        public void gouJiao()
        {
            MessageBox.Show(jiao.SayLanager());
        }
    }
    #endregion
时间: 2024-11-09 00:06:44

Ninject使用介绍的相关文章

Ninject框架的介绍

Ninject是C#语言的一款依赖性的注入器框架,我认为之所以会出现这个框架是因为类与类由于继承或者接口与类继承而出现的,首先这 个最典型存在是因为接口,首先我们来看看这个用了框架和没有用框架的区别吧.首先声明一个IDiscountHeler接口,然后用一个类继承接口 public interface IDiscountHelper { int ApplyDiscount(int totalParm); } public class DeafaultDiscountHelper : IDisco

Ninject之旅之八:Ninject插件模型

摘要 在前面的章节中,我们看了在单一的绑定条件下Ninject能够处理依赖类型,就是说,每个服务类型只绑定到单一的实现类型.然而,有些情况下我们需要绑定一个抽象服务类型到多个实现,这叫多个绑定.多个绑定有两种情况.第一个是插件模型实现,另一个是上下文绑定.这篇文章介绍插件模型实现,下一篇文章介绍上下文绑定. 插件模型让一个应用程序获得很强的可扩展性而不用修改源代码.下面的例子,我们将实现一个音乐播放器应用程序,使用解码插件来支持不同的音乐格式.这个应用程序使用两个内置的解码器,也可以添加更多的解

ASP.NET MVC学前篇之Ninject的初步了解

1.介绍 废话几句,Ninject是一种轻量级的.基础.NET的一个开源IoC框架,在对于MVC框架的学习中会用到IoC框架的,因为这种IoC开源框架有很多,本篇的主题只有一个,就是让阅读过本篇幅的朋友逗知道IoC框架在项目中的作用,以及它的重要性. 这样做的目的是以便在以后的学习工作中选择自己中意的一个IoC框架来学习.使用,或者是自己去实现一个.好了,不废话了. 2.环境准备 1.新建个4.0Framework的一个控制台应用程序项目,名称为IoCDemo 2.在http://www.nin

Ninject之旅之十一:Ninject动态工厂(附程序下载)

摘要 如果我们已经知道了一个类所有的依赖项,在我们只需要依赖项的一个实例的场景中,在类的构造函数中引入一系列的依赖项是容易的.但是有些情况,我们需要在一个类里创建依赖项的多个实例,这时候Ninject注入就不够用了.也有些情况,我们不知道一个消费者可能需要哪个服务,因为他可能在不同的场合下需要不同的服务,而且在创建类的时候实例化所有依赖项也不合理.这样的情况,动态工厂可以帮忙.我们可以设计我们的类让他依赖一个工厂,而不是依赖这个工厂能够创建的对象.然后,我们能够命令工厂去通过命令创建需要的类型和

Ninject之旅之七:Ninject依赖注入

摘要 可以使用不同的模式向消费者类注入依赖项,向构造器里注入依赖项是期中一种.有一些遵循的模式用来注册依赖项,同时有一些需要避免的模式,因为他们经常导致不合乎需要的结果.这篇文章讲述那些跟Ninject功能相关的模式和反模式.然而,全面的介绍可以在Mark Seemann的书<Dependency Injection in .NET>中找到. 1.构造函数注入 构造函数时推荐的最常用的向一个类注册依赖项的模式.一般来说,这种模式应该经常被用作主要的注册模式,除非我们不得不使用其他的模式.在这个

使用 Ninject

在[ASP.NET MVC 小牛之路]系列上一篇文章(依赖注入(DI)和Ninject)的末尾提到了在ASP.NET MVC中使用Ninject要做的两件事情,续这篇文章之后,本文将用一个实际的示例来演示Ninject在ASP.NET MVC中的应用. 为了更好的理解和撑握本文内容,强烈建议初学者阅读本文前先阅读依赖注入(DI)和Ninject. 本文目录: 准备工作 新建一个名为BookShop的空白解决方案.在该解决方案中分别添加一个名为BookShop.WebUI的MVC空应用程序,和一个

Ninject之旅之二:开始使用Ninject

摘要 这篇文章介绍怎样将Ninject添加到实际的项目中,使用Ninject框架最基本的功能.首先用一个Hello World例子介绍怎么添加和使用Ninject.然后用一个更复杂的例子,介绍Ninject DI容器是怎样管理依赖的. 1.第一个Ninject程序:Hello World 1)创建控制台应用程序Demo.Ninject. 2)使用NuGet Manager向工程添加Ninject. 3)添加SalutationService类. 1 using System; 2 3 names

ninject学习笔记一:IOC的实现

这篇文章主要介绍ninject在IOC方面的实现,至于IOC的含义,网络资源很丰富,我这儿就不再赘述了.官方的文档其实挺好的,只是本人英语很烂,看起来比较费劲,下面这些东西是看官方的代码推敲的,我觉得应该能够说明一些问题,希望给和我一样的初学者有一些帮助吧. 这里用一个小案例开始,也就是官方案例的改版. 首先,你要创建项目,并且通过NuGet添加ninject程序集文件 install-package ninject 接着,创建一个武器接口IWeapon,常说攻击性武器,可见咱们这武器也有杀伤力

在mvc中使用Ninject进行依赖注入

说到依赖注入 ,首先要提到控制反转,控制反转(Inversion of Control,英文缩写为IoC)是一个重要的面向对象编程的原则,目的是来削减计算机程序的耦合问题控制反转一般分为两种类型, 依赖注入(Dependency Injection,简称DI)和依赖查找.两者的区别在于,前者是被动的接收对象,在类A的实例创建过程中即创建了依赖的B对象,通过类型或名称来判断将不同的对象注入到不同的 属性中,而后者是主动索取响应名称的对象,获得依赖对象的时间也可以在代码中自由控制.但是依赖注入的应用