c#-依賴注入-利用容器(DependencyInjection)建立依賴服務的生命週期

阿新 • • 發佈：2021-07-01

1 概要說明

1.1 AddSingleton<IA, A>();//建立單例項物件
1.2 AddTransient<IB, B>();//建立臨時物件

2 應用舉例

2.1 例1

2.1.1 程式碼

using System;
using Microsoft.Extensions.DependencyInjection;
 
namespace 依賴注入的生命週期
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine( 
"Hello World!");
            ServiceProvider RegisterServices()
            {
                IServiceCollection services = new ServiceCollection();
                services.AddSingleton<IA, A>();
                services.AddTransient<IB, B>();
                return services.BuildServiceProvider();
            }
             
using (ServiceProvider container = RegisterServices())
            {
                Console.WriteLine($"requesting {nameof(ControllerX)}");
                IA a = container.GetRequiredService<IA>();
                IA a2 = container.GetRequiredService<IA>();
                IB b = container.GetRequiredService<IB>();
                IB b2  
= container.GetRequiredService<IB>();
            }
 
            Console.ReadLine();
        }
    }
    interface IA
    {
        void fun();
    }
    interface IB
    {
        void fun();
    }
    public class A: IA
    {
        static int createNo = 0;
        public A()
        {
            createNo++;
            Console.WriteLine("A構造:" + createNo);
        }
    }
    public class B: IB
    {
        static int createNo = 0;
        public B()
        {
            createNo++;
            Console.WriteLine("B構造:" + createNo);
        }
    }
}

View Code

2.2 例2

2.2.1 程式碼

using System;
using Microsoft.Extensions.DependencyInjection;
 
namespace 依賴注入的生命週期
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            ServiceProvider RegisterServices()
            {
                IServiceCollection services = new ServiceCollection();
                services.AddSingleton<IA, A>();
                services.AddTransient<IB, B>();
                services.AddTransient<ControllerX>();
                //services.Add(new ServiceDescriptor(typeof(ControllerX), typeof(ControllerX), ServiceLifetime.Transient));
                return services.BuildServiceProvider();
            }
            using (ServiceProvider container = RegisterServices())
            {
                Console.WriteLine($"requesting {nameof(ControllerX)}");
                ControllerX x = container.GetRequiredService<ControllerX>();
                x.fun();
 
                Console.WriteLine($"requesting {nameof(ControllerX)}");
                ControllerX x2 = container.GetRequiredService<ControllerX>();
                x2.fun();
 
                /*
                IA a = container.GetRequiredService<IA>();
                IA a2 = container.GetRequiredService<IA>();
                IB b = container.GetRequiredService<IB>();
                IB b2 = container.GetRequiredService<IB>();
                */
 
 
            }
 
            Console.ReadLine();
        }
    }
    public interface IA
    {
        void fun();
    }
    public interface IB
    {
        void fun();
    }
    public class A: IA
    {
        static int createNo = 0;
        public A()
        {
            createNo++;
            Console.WriteLine("A構造:" + createNo);
        }
        public void fun()
        {
            Console.WriteLine("A呼叫:"+ createNo);    
        }
    }
    public class B: IB
    {
        static int createNo = 0;
        public B()
        {
            createNo++;
            Console.WriteLine("B構造:" + createNo);
        }
        public void fun()
        {
            Console.WriteLine("B呼叫:" + createNo);
        }
    }
    public class ControllerX
    {
        static int createNo = 0;
        private readonly IA mA;
        private readonly IB mB;
        public ControllerX(IA a, IB b)
        {
            createNo++;
            Console.WriteLine("C構造:" + createNo);
            mA = a;
            mB = b;
        }
        public void fun()
        {
            Console.WriteLine("C呼叫:" + createNo);
            mA.fun();
            mB.fun();
        }
    }
}

View Code

2.2.2 執行結果和程式碼分析

2.3 例3

2.3.1 程式碼

using System;
using Microsoft.Extensions.DependencyInjection;
 
namespace 依賴注入的生命週期
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            ServiceProvider RegisterServices()
            {
                IServiceCollection services = new ServiceCollection();
                services.AddSingleton<IA, A>();
                //services.AddTransient<IB, B>();
                services.AddScoped<IB, B>();
                return services.BuildServiceProvider();
            }
            using (ServiceProvider container = RegisterServices())
            {
                using (IServiceScope scope1 = container.CreateScope())
                {
                    Console.WriteLine("start of scope1");
                    IA a1 = scope1.ServiceProvider.GetService<IA>();
                    IA a2 = scope1.ServiceProvider.GetService<IA>();
                    IB b = scope1.ServiceProvider.GetService<IB>();
                    IB b2 = scope1.ServiceProvider.GetService<IB>();
                }
                using (IServiceScope scope2 = container.CreateScope())
                {
                    Console.WriteLine("start of scope1");
                    IA a1 = scope2.ServiceProvider.GetService<IA>();
                    IA a2 = scope2.ServiceProvider.GetService<IA>();
                    IB b = scope2.ServiceProvider.GetService<IB>();
                    IB b2 = scope2.ServiceProvider.GetService<IB>();
                }
            }
 
            Console.ReadLine();
        }
    }
    public interface IA
    {
        void fun();
    }
    public interface IB
    {
        void fun();
    }
    public class A: IA
    {
        static int createNo = 0;
        public A()
        {
            createNo++;
            Console.WriteLine("A構造:" + createNo);
        }
        public void fun()
        {
            Console.WriteLine("A呼叫:"+ createNo);    
        }
    }
    public class B: IB
    {
        static int createNo = 0;
        public B()
        {
            createNo++;
            Console.WriteLine("B構造:" + createNo);
        }
        public void fun()
        {
            Console.WriteLine("B呼叫:" + createNo);
        }
    }
}

View Code

2.3.2 執行結果和程式碼分析

2.4 例項4

2.4.1 程式碼

using System;
using Microsoft.Extensions.DependencyInjection;
 
namespace 依賴注入的生命週期
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            ServiceProvider RegisterServices()
            {
                IServiceCollection services = new ServiceCollection();
                services.AddSingleton<IA, A>();
                services.AddScoped<IB, B>();
                services.AddTransient<ControllerX>();
                //services.Add(new ServiceDescriptor(typeof(ControllerX), typeof(ControllerX), ServiceLifetime.Transient));
                return services.BuildServiceProvider();
            }
            using (ServiceProvider container = RegisterServices())
            {
                using (IServiceScope scope1 = container.CreateScope())
                {
                    Console.WriteLine("start of scope1");
                    ControllerX x = scope1.ServiceProvider.GetService<ControllerX>();
                    x.fun();
                }
                using (IServiceScope scope2 = container.CreateScope())
                {
                    Console.WriteLine("start of scope2");
                    ControllerX x2 = scope2.ServiceProvider.GetService<ControllerX>();
                    x2.fun();
                }
 
            }
 
            Console.ReadLine();
        }
    }
    public interface IA
    {
        void fun();
    }
    public interface IB
    {
        void fun();
    }
    public class A: IA
    {
        static int createNo = 0;
        public A()
        {
            createNo++;
            Console.WriteLine("A構造:" + createNo);
        }
        public void fun()
        {
            Console.WriteLine("A呼叫:"+ createNo);    
        }
    }
    public class B: IB
    {
        static int createNo = 0;
        public B()
        {
            createNo++;
            Console.WriteLine("B構造:" + createNo);
        }
        public void fun()
        {
            Console.WriteLine("B呼叫:" + createNo);
        }
    }
    public class ControllerX
    {
        static int createNo = 0;
        private readonly IA mA;
        private readonly IB mB;
        public ControllerX(IA a, IB b)
        {
            createNo++;
            Console.WriteLine("C構造:" + createNo);
            mA = a;
            mB = b;
        }
        public void fun()
        {
            Console.WriteLine("C呼叫:" + createNo);
            mA.fun();
            mB.fun();
        }
    }
}

View Code

2.4.2 執行結果和程式碼分析

————————————————
版權宣告：本文為CSDN博主「科學的發展-只不過是讀大自然寫的程式碼」的原創文章，遵循CC 4.0 BY-SA版權協議，轉載請附上原文出處連結及本宣告。
原文連結：https://blog.csdn.net/xie__jin__cheng/article/details/104292474

c#-依賴注入-利用容器(DependencyInjection)建立依賴服務的生命週期

1 概要說明 1.1 AddSingleton<IA, A>();//建立單例項物件1.2 AddTransient<IB, B>();//建立臨時物件

理解PHP 依賴注入與容器

<?php //依賴注入與容器 class Luntai{ function roll(){ echo \"這是輪胎類：：\"; } } class Bmw{

spring 依賴注入_Spring核心機制：依賴注入

技術標籤：spring 依賴注入spring依賴注入spring依賴注入的三種方式spring呼叫mybatis的dao時是怎樣的

ASP.NET CORE 依賴注入服務生命週期

技術標籤：C#.NET CORE 生命週期依賴注入服務有3種生命週期：Transient；Scoped；Singleton

ASP.NET Web API中的依賴注入什麼是依賴注入ASP.NET Web API依賴解析器使用Unity解析依賴配置依賴解析

什麼是依賴注入依賴，就是一個物件需要的另一個物件，比如說，這是我們通常定義的一個用來處理資料訪問的儲存，讓我們用一個例子來解釋，首先，定義一個領域模型如下:

單例bean依賴原型bean的如何保證原型bean生命週期

簡介：　　將原型bean注入到單例bean，會破壞原型bean的生命週期，使其的生命週期變成與單例bean相同。

容器編排系統之Pod生命週期、健康/就緒狀態探測以及資源限制

　　前文我們瞭解了在k8s上的資源標籤、標籤選擇器以及資源註解相關話題，回顧請參考https://www.cnblogs.com/qiuhom-1874/p/14141080.html；今天我們來聊下k8s上的核心資源pod生命週期、健康/就緒狀態探測以及pod資

Spring原始碼之IOC容器建立、BeanDefinition載入和註冊和IOC容器依賴注入

總結在SpringApplication#createApplicationContext()執行時建立IOC容器，預設DefaultListableBeanFactory

C#中的依賴注入和IoC容器

在本文中，我們將通過用C#重構一個非常簡單的程式碼示例來解釋依賴注入和IoC容器。

詳解C#中的依賴注入和IoC容器

在本文中，我們將通過用C#重構一個非常簡單的程式碼示例來解釋依賴注入和IoC容器。

PHP依賴注入容器知識點淺析

依賴注入容器理解耦合一個好的程式碼結構設計一定是鬆耦合的，這也是很多通用設計模式的宗旨，就是把分散在各處的同一個功能的程式碼匯聚到一起，形成一個模組，然後在不同模組之間通過一些細小的、明確的渠道進行

C#控制檯程式中使用官方依賴注入的實現

asp.net core 中已經自帶了一個官方的依賴注入框架，現在想把它應用到控制檯程式中，控制檯程式是最簡潔的程式碼結構，摒除了其他一堆嵌入的框架程式碼，只包含最簡潔的入口函式，是學習基礎類庫框架的最佳選擇，為什

詳解C# 依賴注入

前言　　好久沒有寫微博了，因為前段時間由於家庭原因決定從工作了3年多的北京轉移到上海去。依賴注入在學習net core的時候也有寫過類似的東西，只是實踐的較少，結果來到上海新公司系統框架涉及到了這塊知識點，所

php設計模式-簡單依賴注入容器+自動繫結特性

class C { public function sayHello() { echo \'I am C\'; } } class B { private $_c; public function __construct(C $c)

php容器 -- 控制反轉 -- 依賴注入

容器簡介 Swoft 基於 PSR-11 規範設計了自己容器，並基於註解增強了它的功能。容器是 Swoft 最重要的設計，稱得上是 Swoft 的核心精髓，也是 Swoft 各模組的實現基礎。本章節將會對容器的相關基礎知識做一個介紹，

RESTful日#2:使用Unity容器和載入程式在Web api中使用依賴注入實現控制反轉

下載databasescript.zip - 1 KB 下載PdfArticle.zip - 3 MB 下載WebApiSourceCodeDay1 - 4 MB 下載WebApi.zip source code - 4.4 MB

Spring-IoC-DI-基於註解方式的依賴注入（案例一：簡單物件建立）

1.什麼是註解（1）註解是程式碼特殊標記，格式：@註解名稱(屬性名稱=屬性值,屬性名稱=屬性值…)

Microsoft.Extensions.DependencyInjection的Singleton依賴注入關係，只是對於同一個ServiceProvider是單例的

在Microsoft.Extensions.DependencyInjection中，Singleton代表單例依賴注入，但是這個單例也只是對於相同的ServiceProvider物件而言。

Microsoft.Extensions.DependencyInjection中的Transient依賴注入關係，使用不當會造成記憶體洩漏

Microsoft.Extensions.DependencyInjection中（下面簡稱DI）的Transient依賴注入關係，表示每次DI獲取一個全新的注入物件。但是使用Transient依賴注入關係時，最好要配合IServiceScope來一起使用，因為通過Transient

Spring基礎，DI（重點：依賴注入）構造方式注入，set方式注入，c命名和p名稱空間注入

1，構造器注入 <bean id=\"user\" class=\"com.king.pojo.User\">

c#-依賴注入-利用容器(DependencyInjection)建立依賴服務的生命週期

1 概要說明

2 應用舉例

2.3 例3

2.4 例項4

相關推薦