NetCore依赖注入ioc使用三种方式

环境：

net 5

vs2022

目录

1、注入方式：

2、注入使用：

3、接口多实现

1、注入方式：

AddTransient、AddScoped、AddSingleton

 第一次调用：

 第二次调用：

可以看到单例保持一致， 作用于每次请求都是相同的

生命周期嵌套注入(扩展)：

Singleton中注入Scope、Transient，那么也同样保持单例

Scope中注入Transient，那仍保持Scope。注入Singleton，保持Singleton不变

Transient中注入Singleton、Scope，那么仍旧是Singleton、Scope

2、注入使用：

分别为属性、构造函数、方法特性(FromServices)使用注入

[Route("api/[controller]")]
    [ApiController]
    public class FirstController : ControllerBase
    {
        public ICalc _calc;

        /// <summary>
        /// 属性注入
        /// </summary>
        public ICalc Calc
        {
            set { _calc = value; }
        }

        /// <summary>
        /// 构造函数注入
        /// </summary>
        /// <param name="calc"></param>
        public FirstController(ICalc calc) 
        {
            _calc = calc;
        }


        // GET: api/<FirstController>
        [HttpGet]
        public IEnumerable<string> Get([FromServices] ICalc calc)
        {
            List<string> list = new List<string>();
            list.Add("value1");
            list.Add("value2");
            list.Add(calc.Add(1, 2).ToString());
            return list.ToArray();
        }
}

service: 

    public class CalcService : ICalc
    {
        public int Add(int x, int y)
        {
            return x + y;
        }
    }


    public interface ICalc
    {
        int Add(int x, int y);
    }

3、接口多实现

netcore原生DI注入：

定义接口和实现：

    public interface ISqlService
    {
        bool Insert<TEntity>(TEntity t);
        bool Update<TEntity>(TEntity t);

        bool Delete<TEntity>(TEntity t);
    }


public class MySqlService : ISqlService
    {
        public bool Delete<TEntity>(TEntity t)
        {
            Console.WriteLine("MySql删除成功");
            return true;
        }

        public bool Insert<TEntity>(TEntity t)
        {
            Console.WriteLine("MySql插入成功");
            return true;
        }

        public bool Update<TEntity>(TEntity t)
        {
            Console.WriteLine("MySql更新成功");
            return true;
        }
    }


public class OracleService : ISqlService
    {
        public bool Delete<TEntity>(TEntity t)
        {
            Console.WriteLine("Oracle删除成功");
            return true;
        }

        public bool Insert<TEntity>(TEntity t)
        {
            Console.WriteLine("Oracle插入成功");
            return true;
        }

        public bool Update<TEntity>(TEntity t)
        {
            Console.WriteLine("Oracle更新成功");
            return true;
        }
    }


public class SqlServerService : ISqlService
    {
        public bool Delete<TEntity>(TEntity t)
        {
            Console.WriteLine("SqlServer删除成功");
            return true;
        }

        public bool Insert<TEntity>(TEntity t)
        {
            Console.WriteLine("SqlServer插入成功");
            return true;
        }

        public bool Update<TEntity>(TEntity t)
        {
            Console.WriteLine("SqlServer更新成功");
            return true;
        }
    }

Api:

 [Route("api/[controller]")]
    [ApiController]
    public class SqlController : ControllerBase
    {
        private readonly ISqlService _mysqlServices;
        private readonly ISqlService _sqlServerServices;
        private readonly ISqlService _oracleServices;

        private readonly ISqlService _mysqlServices1;
        private readonly ISqlService _sqlServerServices1;
        private readonly ISqlService _oracleServices1;

        /// <summary>
        /// 默认按照最后的注入实现
        /// </summary>
        private readonly ISqlService _defaultServices;
        public SqlController(IEnumerable<ISqlService> sqlServices, ISqlService sqlService, Func<Type, ISqlService> sqlServiceFunc)
        {
            _defaultServices = sqlService;

             //接口多实现方式一
            _mysqlServices = sqlServices.FirstOrDefault(f => f.GetType().Equals(typeof(MySqlService)));
            _sqlServerServices = sqlServices.FirstOrDefault(f => f.GetType().Equals(typeof(SqlServerService)));
            _oracleServices = sqlServices.FirstOrDefault(f => f.GetType().Equals(typeof(OracleService)));


            //接口多实现方式二
            _mysqlServices1 = sqlServiceFunc(typeof(MySqlService));
            _sqlServerServices1 = sqlServiceFunc(typeof(SqlServerService));
            _oracleServices1 = sqlServiceFunc(typeof(OracleService));

        }

        [HttpGet]
        public Task<string> SqlTest()
        {
            Console.WriteLine("**********mysql************");
            _mysqlServices.Update(default(object));
            _mysqlServices.Delete(default(object));
            _mysqlServices.Insert(default(object));

            Console.WriteLine("**********sqlServer************");
            _sqlServerServices.Update(default(object));
            _sqlServerServices.Delete(default(object));
            _sqlServerServices.Insert(default(object));

            Console.WriteLine("**********oracle************");
            _oracleServices.Update(default(object));
            _oracleServices.Delete(default(object));
            _oracleServices.Insert(default(object));

            Console.WriteLine("**********default************");
            _defaultServices.Update(default(object));
            _defaultServices.Delete(default(object));
            _defaultServices.Insert(default(object));

            Console.WriteLine("**********接口多实现类************");

            Console.WriteLine("**********mysql1************");
            _mysqlServices1.Update(default(object));
            _mysqlServices1.Delete(default(object));
            _mysqlServices1.Insert(default(object));

            Console.WriteLine("**********sqlServer1************");
            _sqlServerServices1.Update(default(object));
            _sqlServerServices1.Delete(default(object));
            _sqlServerServices1.Insert(default(object));

            Console.WriteLine("**********oracle1************");
            _oracleServices1.Update(default(object));
            _oracleServices1.Delete(default(object));
            _oracleServices1.Insert(default(object));

            return Task.FromResult("");
        }
    }

startup: 

            //方式一
                {
                    services.AddTransient<ISqlService, MySqlService>();
                    services.AddTransient<ISqlService, SqlServerService>();
                    services.AddTransient<ISqlService, OracleService>();
                }

                //方式二
                {
                    services.AddTransient<MySqlService>();
                    services.AddTransient<SqlServerService>();
                    services.AddTransient<OracleService>();
                    services.AddTransient(sp =>
                    {
                        Func<Type, ISqlService> accesor = key =>
                        {
                            if (key == typeof(SqlServerService))
                                return sp.GetService<SqlServerService>();
                            else if (key == typeof(OracleService))
                                return sp.GetService<OracleService>();
                            else if (key == typeof(MySqlService))
                                return sp.GetService<MySqlService>();
                            else
                                throw new KeyNotFoundException($"不支持的DI Key: {key}");
                        };
                        return accesor;
                    });

结果：

参考：NetCore自带DI容器的三种生命周期浅析_冗码一生的博客-CSDN博客_netcore生命周期