C# Autofac 构造函数注入，属性注入，方法注入

奋斗吧
奋斗吧
擅长邻域：未填写

标签： C# Autofac 构造函数注入，属性注入，方法注入 JavaScript博客 51CTO博客

2023-03-26 18:23:29 196浏览

C# Autofac 构造函数注入，属性注入，方法注入，十年河东，十年河西，莫欺少年穷。学无止境，精益求精。新建一个控制

十年河东，十年河西，莫欺少年穷。

学无止境，精益求精。

新建一个控制台应用程序，如下构造：

C# Autofac 构造函数注入，属性注入，方法注入_属性注入

 MyAutoFac层引入autofac 版本 V6.5

接口层如下：

namespace MyInterface
{
    public interface IPerson
    {
        void say();
        void PlayerWithDog();
        void PlayerWithCat();
        void PlayerWithPig();
    }
    public interface IDog
    {
        void say();
    }

    public interface ICat
    {
        void say();
    }
    public interface IPig
    {
        void say();
    } 
}

服务层如下：

namespace MyService
{
    public class PersonService : IPerson
    {
        private readonly IDog dog;
        private readonly ICat cat;
        private readonly IPig pig;
        public PersonService(IDog dog)
        {
            this.dog = dog;
        }
        public PersonService(IDog dog, ICat cat)
        {
            this.dog = dog;
            this.cat = cat;
        }
        public PersonService(IDog dog,  IPig pig, ICat cat)
        {
            this.pig = pig;
            this.cat = cat;
        }
        public void say()
        {
            Console.WriteLine("你好");
        }

        public void PlayerWithDog()
        {
            if (dog == null)
            {
                return;
            }
            Console.WriteLine("人在跳绳，狗在叫：");
            this.dog.say();
        }

        public void PlayerWithCat()
        {
            if (cat == null)
            {
                return;
            }
            Console.WriteLine("人在跳绳，猫在叫：");
            this.cat.say();
        }
        public void PlayerWithPig()
        {
            if (pig == null)
            {
                return;
            }
            Console.WriteLine("人在跳绳，猪在叫：");
            this.pig.say();
        }
    }

    public class DogService : IDog
    {
        public void say()
        {
            Console.WriteLine("汪汪汪");
        }
    }

    public class CatService : ICat
    {
        public void say()
        {
            Console.WriteLine("喵喵喵");
        }
    }

    public class PigService : IPig
    {
        public void say()
        {
            Console.WriteLine("哼哼哼");
        }
    }
}

1、构造函数注入

1.1、构造函数默认注入

引入一个构造函数参数

{
    //构造函数默认注入
    ContainerBuilder builder = new ContainerBuilder();
    builder.RegisterType<DogService>().As<IDog>();
    builder.RegisterType<PersonService>().As<IPerson>();
    IContainer container = builder.Build();
    var p = container.Resolve<IPerson>();
    p.say();
    p.PlayerWithDog();
}

上述代码中先通过RegisterType引入IDog，后引入IPerson，会执行PersionService中有一个IDog作为参数的构造函数

调式如下：

C# Autofac 构造函数注入，属性注入，方法注入_修饰符_02

 

将上述代码修改如下：

引入三个构造函数参数

{
    //构造函数默认注入
    ContainerBuilder builder = new ContainerBuilder();
    builder.RegisterType<DogService>().As<IDog>();
    builder.RegisterType<PigService>().As<IPig>();
    builder.RegisterType<CatService>().As<ICat>();
    builder.RegisterType<PersonService>().As<IPerson>();
    IContainer container = builder.Build();
    var p = container.Resolve<IPerson>();
    p.say();
    p.PlayerWithDog();
}

通过RegisterType引入了IDog、ICat、IPig，因此会走具有三个参数的构造函数

调试如下：

C# Autofac 构造函数注入，属性注入，方法注入_修饰符_03

 

将代码继续修改如下：

 通过反射，加载所有接口及其实现类

{
    //通过程序集加载
    ContainerBuilder builder = new ContainerBuilder();
    Assembly assemblyInterface = Assembly.LoadFrom("MyInterface.dll");
    Assembly assemblyService = Assembly.LoadFrom("MyService.dll");
    builder.RegisterAssemblyTypes(assemblyInterface, assemblyService).AsImplementedInterfaces();
    IContainer container = builder.Build();
    //PersonService 会执行参数多的构造函数
    var p = container.Resolve<IPerson>();
    p.PlayerWithDog(); p.PlayerWithCat(); p.PlayerWithPig();
}

调式如下：

C# Autofac 构造函数注入，属性注入，方法注入_修饰符_03

这里需要说明的是，如果构造函数中有相同参数个数的构造函数，AutoFac会报错，他就不知道该执行哪个构造函数了。

 1.2、通过UsingConstructor方法指定要执行的构造函数

代码如下：

{
    //注册一个普通类
    ContainerBuilder builder = new ContainerBuilder();
    builder.RegisterType<DogService>().As<IDog>();
    builder.RegisterType<CatService>().As<ICat>();
    builder.RegisterType<PersonService>().As<IPerson>().UsingConstructor(typeof(IDog), typeof(ICat));
    IContainer container = builder.Build();
    var p = container.Resolve<IPerson>();
    p.say();
    p.PlayerWithDog();
    p.PlayerWithCat();
}

C# Autofac 构造函数注入，属性注入，方法注入_属性注入_05

 调式如下：

C# Autofac 构造函数注入，属性注入，方法注入_构造函数_06

 2、属性注入

2.1、PropertiesAutowired()方法属性注入

使用PropertiesAutowired()方法支持属性注入

新增接口及实现类如下：

接口

/// <summary>
    /// 动物接口
    /// </summary>
    public interface IAnimal
    {
        void say();
    }

实现类【实现类中有三个属性】

public class AnimalService : IAnimal
    {

        /// <summary>
        /// 属性注入时，修饰符必须为Public
        /// </summary>
        /// 
        public IDog dog { get; set; }
        /// <summary>
        /// 属性注入时，修饰符必须为Public
        /// </summary>
        /// 
        public ICat cat { get; set; }
        /// <summary>
        /// 属性注入时，修饰符必须为Public
        /// </summary>
        public IPig pig { get; set; }

        public void say()
        {
            if (this.dog != null)
            {
                this.dog.say();
            }
            if (this.cat != null)
            {
                this.cat.say();
            }
            if (this.pig != null)
            {
                this.pig.say();
            }
        }
    }

 

代码如下

{
    //属性注入
    ContainerBuilder builder = new ContainerBuilder();
    builder.RegisterType<DogService>().As<IDog>();
    builder.RegisterType<CatService>().As<ICat>();
    builder.RegisterType<PigService>().As<IPig>();
    builder.RegisterType<AnimalService>().As<IAnimal>().PropertiesAutowired();
    IContainer container = builder.Build();
    var p = container.Resolve<IAnimal>();
    p.say();
}

C# Autofac 构造函数注入，属性注入，方法注入_构造函数_07

 调式如下：

C# Autofac 构造函数注入，属性注入，方法注入_构造函数_08

 2.2、属性注入选择器

新建属性类及属性选择器如下：

namespace MyIocAutoProperties
{
    [AttributeUsage(AttributeTargets.Property)]
    public class IocSelectAttribute: Attribute
    {

    }

    public class IoctAttributeSelector : IPropertySelector
    {
        public bool InjectProperty(PropertyInfo propertyInfo, object instance)
        {
            return propertyInfo.CustomAttributes.Any(A => A.AttributeType == typeof(IocSelectAttribute));
        }
    }
}

修改如下：

public class AnimalService : IAnimal
    { 
        /// <summary>
        /// 属性注入时，修饰符必须为Public
        /// </summary>
        /// 
        [IocSelect]
        public IDog dog { get; set; }
        /// <summary>
        /// 属性注入时，修饰符必须为Public
        /// </summary>
        /// 
        [IocSelect]
        public ICat cat { get; set; }
        /// <summary>
        /// 属性注入时，修饰符必须为Public
        /// </summary>
        public IPig pig { get; set; }

        public void say()
        {
            if (this.dog != null)
            {
                this.dog.say();
            }
            if (this.cat != null)
            {
                this.cat.say();
            }
            if (this.pig != null)
            {
                this.pig.say();
            }
        }
    }

View Code

C# Autofac 构造函数注入，属性注入，方法注入_修饰符_09

 

 代码如下：

{
    //属性注入
    ContainerBuilder builder = new ContainerBuilder();
    builder.RegisterType<DogService>().As<IDog>();
    builder.RegisterType<CatService>().As<ICat>();
    builder.RegisterType<PigService>().As<IPig>();
    builder.RegisterType<AnimalService>().As<IAnimal>().PropertiesAutowired(new IoctAttributeSelector());
    IContainer container = builder.Build();
    var p = container.Resolve<IAnimal>();
    p.say();
}

View Code

C# Autofac 构造函数注入，属性注入，方法注入_修饰符_10

 

 吊事如下：

C# Autofac 构造函数注入，属性注入，方法注入_属性注入_11

 3、方法注入

所谓方法注入是指：在接口对象构造后，自动调用对象的某个方法

在接口中增加一个Eat方法

/// <summary>
    /// 动物接口
    /// </summary>
    public interface IAnimal
    {
        void say();
        void eat(ICat cat);
    }

实现类如下：

public class AnimalService : IAnimal
    { 
        /// <summary>
        /// 属性注入时，修饰符必须为Public
        /// </summary>
        ///  
        public IDog dog { get; set; }
        /// <summary>
        /// 属性注入时，修饰符必须为Public
        /// </summary>
        ///  
        public ICat cat { get; set; }
        /// <summary>
        /// 属性注入时，修饰符必须为Public
        /// </summary>
        public IPig pig { get; set; }

        public void say()
        {
            if (this.dog != null)
            {
                this.dog.say();
            }
            if (this.cat != null)
            {
                this.cat.say();
            }
            if (this.pig != null)
            {
                this.pig.say();
            }
        }

        public void  eat(ICat cat)
        {
            Console.WriteLine("方法注入：在构建IAnimal对象时，触发eat方法执行");
        }
    }

View Code

代码如下：

{
    //方法注入
    ContainerBuilder builder = new ContainerBuilder(); 
    builder.RegisterType<CatService>().As<ICat>();
    builder.RegisterType<AnimalService>().As<IAnimal>().OnActivated(Activator =>
    {
        var cat = Activator.Context.Resolve<ICat>();
        Activator.Instance.eat(cat);
    }); 
    IContainer container = builder.Build();
    //构建IAnimal对象，触发上述eat方法执行
    container.Resolve<IAnimal>();
}

程序将在 container.Resolve<IAnimal>(); 之后，执行eat方法

调式如下：

C# Autofac 构造函数注入，属性注入，方法注入_构造函数_12

 

 4、单抽象，多实现

如下案例

/// <summary>
    /// 动物接口
    /// </summary>
    public interface IAnimal
    {
        void say(); 
    }

多个实现类继承该接口

public class DogService : IAnimal
    {
        public void say()
        {
            Console.WriteLine("汪汪汪");
        }
    }

    public class CatService : IAnimal
    {
        public void say()
        {
            Console.WriteLine("喵喵喵");
        }
    }

    public class PigService : IAnimal
    {
        public void say()
        {
            Console.WriteLine("哼哼哼");
        }
    }

View Code

先看如下代码：

{
    //单抽象多继承
    ContainerBuilder builder = new ContainerBuilder();
    builder.RegisterType<DogService>().As<IAnimal>();
    builder.RegisterType<CatService>().As<IAnimal>();
    builder.RegisterType<PigService>().As<IAnimal>();
    IContainer container = builder.Build(); 
    var p = container.Resolve<IAnimal>();
    var ps = container.Resolve<IEnumerable<IAnimal>>(); 
}

p为最后注册的对象

C# Autofac 构造函数注入，属性注入，方法注入_构造函数_13

 

 ps为所有实现类对象集合

C# Autofac 构造函数注入，属性注入，方法注入_构造函数_14

 

 那么问题来了，我们该如何获取到指定的对象呢？

通过加入key来识别即可，如下

{
    //单抽象多继承
    ContainerBuilder builder = new ContainerBuilder();
    builder.RegisterType<DogService>().Keyed<IAnimal>("dog");
    builder.RegisterType<CatService>().Keyed<IAnimal>("cat");
    builder.RegisterType<PigService>().Keyed<IAnimal>("pig");
    IContainer container = builder.Build();
    //这里是狗
    var dog = container.ResolveKeyed<IAnimal>("dog");
    //这里是猫
    var cat = container.ResolveKeyed<IAnimal>("cat");
    //这里是猪
    var pig = container.ResolveKeyed<IAnimal>("pig"); 
}

自此结束

@天才卧龙的博客



好博客就要一起分享哦！分享海报

此处可发布评论

评论（0）展开评论

暂无评论，快来写一下吧

展开评论

您可能感兴趣的博客

c++求连续子数组的最大和

系统盘c盘爆满后怎么免费清理出几个G

常用正则

java开发的bbs论坛系统博客系统

java开发的bbs论坛系统博客系统

谷歌不允许跨域同策略跨域问题

一个工厂订单管理系统

vue实现图表统计折线图柱状图扇形图直方图

大一数据结构作业

jsp项目使用vue.js

MySQL8高版本groupby分组查询问题

第七章-springboot整合redis

7.前后端联调发送axios请求实现新增和修改

activity

nginx安装

部署前端vue项目

第三次课-新增和修改手游基础信息前端vue

13.springboot和vue实现文件上传

el表达式的常用方法

Navicat安装并破解

4.脚手架搭建vue前端

no17-日志框架学习

客服QQ 1913284695