## 引言
**单例模式**是一种创建型设计模式，它的主要目的是确保某个类在应用程序中只有一个实例，并且这个实例能够被全局访问。在许多情况下，单例模式是非常有用的，比如说当你需要创建一个全局的配置类或者日志类时，单例模式可以让你轻松地实现这些功能。

在实现单例模式时，有两种常见的方法，“懒汉式”和“饿汉式”

### 懒汉式


```csharp
public class Singleton
{
    private static Singleton instance;
    
    private Singleton()
    {
        // 私有构造函数
    }
    
    public static Singleton GetInstance()
    {
        if(instance == null)
        {
            instance = new Singleton();
        }
        return instance;
    }
}

```

这种方式的特点是只有在需要的时候才会创建实例，而不是在类加载的时候就创建实例。这种方式可以节省系统资源，但是可能会影响性能。


### 懒汉式（双检锁）

上文中的实现方案中，并未考虑到线程安全，要确保在多线程环境下只有一个实例被创建，需要**使用双重检查锁定**，双检锁/双重校验锁（DCL，即 double-checked locking）。

```csharp
public class Singleton
{
    private static Singleton instance;
    private static readonly object lockObject = new object();

    private Singleton()
    {
        // 私有构造函数
    }

    public static Singleton GetInstance()
    {
        if (instance == null)
        {
            lock (lockObject)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

```
### 饿汉式


```csharp
public class Singleton
{
    private static Singleton instance = new Singleton();
    
    private Singleton()
    {
        // 私有构造函数
    }
    
    public static Singleton GetInstance()
    {
        return instance;
    }
}

```

这种方式的特点是在类加载的时候就创建实例，而不是在需要的时候才创建实例。这种方式可以保证线程安全，但是可能会浪费系统资源。

在使用“饿汉式”方式实现单例模式时，实例是在类加载时创建的。因此，不需要使用额外的线程安全技术。

## 总结
总的来说，单例模式是一种常见的设计模式，它能够确保某个类在应用程序中只有一个实例，并且这个实例能够被全局访问。但在使用“懒汉式”实现时，要注意线程安全问题。

重温设计模式 --- 单例模式

## 引言
**抽象工厂模式**一种创建型设计模式，它提供了一种方式来封装一组具有相同主题的工厂，而不必指定它们具体的类。这样，客户端代码就可以使用抽象工厂来创建一组相关的对象，而不必关心实际创建的具体类。


抽象工厂模式有以下几个主要角色：
- 抽象工厂（AbstractFactory）：声明用于创建抽象产品的操作的接口。

- 工厂实现（ConcreteFactory）：实现创建具体产品对象的操作。

- 抽象产品（AbstractProduct）：声明产品对象类型的接口。

- 产品实现（Product）：定义由相应的具体工厂创建的产品对象，实现AbstractProduct接口。

下面使用C#实现抽象工厂模式:

### 抽象工厂
定义一个抽象工厂接口，其中包含了创建不同产品的方法：
```csharp
public interface IAbstractFactory
{
    IProductA CreateProductA();
    IProductB CreateProductB();
}

```
### 工厂实现
定义具体的工厂类，实现抽象工厂接口：
```csharp
public class ConcreteFactory1 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

    public IProductB CreateProductB()
    {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

    public IProductB CreateProductB()
    {
        return new ConcreteProductB2();
    }
}

```
在上述示例中，我们定义了两个具体工厂类：`ConcreteFactory1`和`ConcreteFactory2`。这两个工厂类都实现了`IAbstractFactory`接口，并且分别提供了不同的产品实现。
### 抽象产品
```csharp
public interface IProductA
{
    string GetName();
}
```
### 产品实现
```csharp
public class ConcreteProductA1 : IProductA
{
    public string GetName()
    {
        return "ProductA1";
    }
}

public class ConcreteProductA2 : IProductA
{
    public string GetName()
    {
        return "ProductA2";
    }
}

public interface IProductB
{
    string GetName();
}

public class ConcreteProductB1 : IProductB
{
    public string GetName()
    {
        return "ProductB1";
    }
}

public class ConcreteProductB2 : IProductB
{
    public string GetName()
    {
        return "ProductB2";
    }
}
```

下面，我们可以使用抽象工厂来创建一组相关的对象：

```csharp
public class Client
{
    private IAbstractFactory factory;

    public Client(IAbstractFactory factory)
    {
        this.factory = factory;
    }

    public void Run()
    {
        var productA = factory.CreateProductA();
        var productB = factory.CreateProductB();

        Console.WriteLine(productA.GetName());
        Console.WriteLine(productB.GetName());
    }
}

static void Main(string[] args)
{
    var client1 = new Client(new ConcreteFactory1());
    client1.Run();

    var client2 = new Client(new ConcreteFactory2());
    client2.Run();
}
```
输出：

```csharp
ProductA1
ProductB1

ProductA2
ProductB2
```

## 总结

上面的示例中，我们使用抽象工厂模式来创建了一组相关的对象，但是需要注意的是，它适用于创建一组相关的产品对象，但是当产品族的变化引起整个工厂等级结构的变化时，抽象工厂模式就不适用了。

此外，抽象工厂模式还存在一些缺点，例如：
- 新增产品会导致工厂接口的扩展。如果需要新增产品，就需要修改所有的工厂类，这会带来一些不必要的麻烦。

- 可能会导致类层次结构的复杂度增加。如果有多个产品族，就需要定义多个工厂接口，这会增加类层次结构的复杂度。

因此，在使用抽象工厂模式时，需要根据具体情况进行权衡和选择。

重温设计模式 --- 抽象工厂模式

## 引言
SOLID是五个常见的面向对象设计原则的缩写，其目的是帮助开发者设计易于维护和扩展的软件系统

其中包含**单一职责原则(SRP)**，**开闭原则(OCP)**，**里氏替换原则(LSP)**，**接口隔离原则(ISP)**，**依赖反转原则(DIP)**。

除SOLID之外，后续又增加了**迪米特法则**。



## 单一职责原则

**单一职责原则（Single Responsibility Principle，SRP）**，这个原则指出一个类应该只有一个职责。也就是说，一个类应该只有一种修改的原因。如果一个类负责多个不同的职责，那么对其中一个职责的修改可能会影响到其他职责，从而导致系统的不稳定性。

## 开闭原则

**开闭原则（Open-Closed Principle，OCP）**，这个原则指出一个类应该对扩展开放，对修改关闭。也就是说，系统中的类应该能够方便地进行扩展，但是对于已经存在的类，尽量避免进行修改。这样可以减少代码的复杂性，提高系统的稳定性。



:::tip{title="提示"}
开闭原则需要避免过度设计，即在不必要的情况下进行扩展。同时，应该避免使用复杂的继承结构，而应该优先使用组合和接口实现扩展。
:::

## 里氏替换原则

**里氏替换原则（Liskov Substitution Principle，LSP）**，这个原则指出，如果一个子类不能完全替代它的父类，那么这个子类就不应该存在。换句话说，子类应该能够在不影响父类的前提下，完全替代父类的功能。这样才能保证系统的正确性和稳定性。



:::tip{title="提示"}
里氏替换原则需要注意继承关系的正确性。子类必须要遵循父类的约束，否则就会破坏LSP的原则。同时，在使用多态时需要注意类型的转换和类型检查的正确性。
:::

## 接口隔离原则

**接口隔离原则（Interface Segregation Principle，ISP）**，这个原则指出一个类不应该强制依赖它不需要的接口。如果一个类依赖了一个过于庞大的接口，那么当这个接口发生变化时，这个类也需要相应地进行修改。因此，一个类应该尽量只依赖于它需要的接口，避免不必要的依赖。

:::tip{title="提示"}
接口隔离原则需要避免接口的冗余和重复。接口应该根据不同的职责进行分离，避免一个接口承担过多的职责。同时，应该避免使用过于具体的接口，而应该优先使用更抽象的接口
:::

## 依赖反转原则

**依赖反转原则（Dependency Inversion Principle，DIP）**，这个原则指出，高层模块不应该依赖于低层模块，两者都应该依赖于抽象。同时，抽象不应该依赖于具体实现，具体实现应该依赖于抽象。这样可以减少系统的耦合度，提高系统的可扩展性和可维护性。

:::tip{title="提示"}
依赖反转原则需要注意依赖注入的方式和依赖倒置的层次。依赖注入应该使用构造函数注入、属性注入或方法注入，避免使用硬编码的依赖。同时，在依赖倒置时需要注意依赖的层次，避免高层模块依赖过于低层的模块。
:::

## 迪米特法则
**迪米特法则(Law of Demeter,LoD)也称为最少知识原则(Least Knowledge Principle,LKP)**。
迪米特法则要求一个对象应该只与其直接的朋友通信，而不是跟朋友的朋友或者更远的对象通信。对象之间的耦合度越低，系统的灵活性、可维护性、可扩展性就越好，同时也降低了代码的复杂度和风险。
:::tip{title="提示"}
迪米特法则需要注意：
- 将方法中的参数尽量缩小，尽量不引入不需要的对象。
- 在类的设计中，尽量降低对其他类的依赖。
- 将依赖其他类的操作放到一个中介类中，由中介类负责和其他类的通信。
:::

## 结论

SOLID原则是一种很好的软件设计指导原则，能够帮助开发者设计出易于维护和扩展的软件系统。但是，这些原则并不是银弹，需要根据具体的情况进行灵活运用。同时，在应用这些原则时需要注意细节和实现细节，才能真正达到SOLID原则的设计目标。

设计原则 --- SOLID

## 引言

### AOP
**AOP（Aspect-Oriented Programming）** 编程思想是一种面向切面编程的编程范式。在日常的软件开发中，我们经常会遇到一些**横切关注点（cross-cutting concerns）**，如`日志记录`、`事务处理`、`权限控制`、`异常处理`等。这些横切关注点可能会存在于程序的多个模块中，使得程序的不同模块之间存在较强的耦合性，从而影响了程序的可维护性和可扩展性。AOP编程思想的目的就是将这些横切关注点从程序的业务逻辑中剥离出来，并将其模块化处理，从而提高程序的可维护性和可扩展性。


 
### 切面
在AOP编程思想中，切面（aspect）是指横切关注点的抽象概念，它通常用一个类或一个模块来表示。切面通过将横切关注点的代码封装到独立的模块中，使得这些代码可以在程序的不同模块之间共享和复用。切面通过定义切点（pointcut）和通知（advice）来实现对横切关注点的处理。

### 切点
切点定义了哪些代码片段需要被处理，通知则定义了在切点处执行的处理逻辑。在AOP编程中，通知可以分为前置通知（before advice）、后置通知（after advice）、环绕通知（around advice）等不同类型，具体使用哪种类型的通知取决于需要实现的功能。

## AOP 的优缺点

### 优点
1. **解耦**：AOP编程将横切关注点从业务逻辑中分离出来，使得程序各个模块之间的依赖关系降低，从而实现了解耦。
2. **复用**：AOP编程将横切关注点封装到独立的模块中，使得这些代码可以在程序的不同模块之间共享和复用。
3. **可维护性**：AOP编程将横切关注点的处理逻辑从业务逻辑中分离出来，使得程序的各个模块更加简单，易于维护。
4. **可扩展性**：AOP编程通过切面的定义和配置，可以很容易地扩展系统的功能，而不需要对原有的业务逻辑进行修改。

### 缺点
1. **增加复杂性**：AOP编程将程序的逻辑分散到多个模块中，增加了程序的复杂性，对于一些小规模的项目可能会显得过于复杂。
2. **难以调试**：由于横切关注点的代码可能被多个模块共享，所以在调试时可能会比较困难。

AOP编程思想增加了程序的复杂性，难以调试等。但总体来说，AOP编程思想对于大型软件系统的开发和维护是非常有用的。它可以使得程序的结构更加清晰、易于维护和扩展，同时也可以提高程序的重用性和可测试性。使用AOP编程思想可以让开发人员更加专注于业务逻辑的实现，而将横切关注点的处理交给AOP框架去处理，从而提高开发效率和代码质量。

## C# 利用AutoFac实现简单AOP

接下来我们借助`反射`，`Attribute`,三方容器`AutoFac`，实现一个简单AOP：

### 1. 创建动态代理

```csharp
    internal class DynamicProxy<T> : DispatchProxy
    {
        public T? decorated { get; set; }//目标类
        
        public Action<object?[]?>? _BeforeAction { get; set; } // 动作之前执行
        
        public Action<object?[]?, object>? _AfterAction { get; set; }  // 动作之后执行
        
        public Action<Exception>? _CatchExceptionAction { get; set; }  // 捕获异常之后执行

        protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
        {
            Exception exception = null;

            Before(args);

            object result = null;
            try
            {
                //调用实际目标对象的方法
                result = targetMethod?.Invoke(decorated, args);
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            After(args, result);

            //调用完执行方法后的委托，如果有异常，抛出异常
            if (exception != null)
            {
                CatchException(exception);
            }
            return result;
        }

        /// <summary>
        /// 创建代理实例
        /// </summary>
        /// <param name="decorated">代理的接口类型</param>
        /// <param name="beforeAction">方法执行前执行的事件</param>
        /// <param name="afterAction">方法执行后执行的事件</param>
        /// <param name="catchException">异常捕获后执行的事件</param>
        /// <returns></returns>
        public T Create(T decorated, Action<object?[]?> beforeAction, Action<object?[]?, object> afterAction, Action<Exception> catchException)
        {
            // 调用DispatchProxy 的Create  创建一个新的T
            object proxy = Create<T, DynamicProxy<T>>();

            DynamicProxy<T> proxyDecorator = (DynamicProxy<T>)proxy;

            proxyDecorator.decorated = decorated;

            //把自定义的方法委托给代理类
            proxyDecorator._AfterAction = afterAction;

            proxyDecorator._BeforeAction = beforeAction;

            proxyDecorator._CatchExceptionAction = catchException;

            return (T)proxy;
        }

        private void Before(object?[]? args)
        {
            try
            {
                _BeforeAction.Invoke(args);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"执行之前异常：{ex.Message}");
            }
        }

        private void After(object?[]? args, object? result)
        {
            try
            {
                _AfterAction.Invoke(args, result);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"执行之后异常：{ex.Message}");
            }
        }

        private void CatchException(Exception ex)
        {
            _CatchExceptionAction(ex);
        }
    }
```
### 2. 创建拦截器属性
标记AOP切点的**Attribute--InterceptAttribut**(拦截器属性)

```csharp
    /// <summary>
    /// 自定义拦截器特性
    /// </summary>
    [AttributeUsage(AttributeTargets.Class)]
    internal class InterceptAttribut : Attribute
    {
        public Type Type { get; set; }
        public InterceptAttribut(Type type)
        {
            this.Type = type;
        }
    }
```


### 3. 创建动态代理工厂类
它是泛型工厂,用于创建不同类型的代理类

```csharp
    class DynamicProxyFactory
    {
        /// <summary>
        /// 创建代理实例
        /// </summary>
        /// <param name="decorated">代理的接口类型</param>
        /// <returns></returns>
        public static T Create<T>()
        {
            var decorated = ServiceHelp.GetService<T>(typeof(T));
            
            var type = decorated.GetType();
            
            var interceptAttribut = type.GetCustomAttribute<InterceptAttribut>();
            
            var interceptor = ServiceHelp.GetService<IInterceptor>(interceptAttribut.Type);
            //创建代理类
            var proxy = new DynamicProxy<T>().Create(decorated, interceptor.BeforeExecuted, interceptor.AfterExecuted, interceptor.CatchException);
            
            return proxy;
        }
    }
```
### 4. 创建ServiceHelp
ServiceHelp用于获取实例,其核心就是以Autofac这个IOC容器去注册及获取服务.

```csharp
    internal class ServiceHelp
    {
        //实例化Autofac容器
        private static ContainerBuilder builder = new ContainerBuilder();

        public static IContainer? serviceProvider { get; set; }

        public static void BuildServiceProvider()
        {
            //注册InstanceModule组件
            builder.RegisterModule<InstanceModule>();
            //创建容器
            serviceProvider = builder.Build();
        }

        internal static T GetService<T>(Type serviceType)
        {
            if (serviceProvider.IsRegistered(serviceType))
            {
                return (T)serviceProvider.Resolve(serviceType);
            }
            return default(T);
        }
    }
```
### 5. 创建AOP切面

```csharp
    /// <summary>
    /// 自定义拦截器接口
    /// </summary>
    interface IInterceptor
    {
        /// <summary>
        /// 执行前
        /// </summary>
        /// <param name="args"></param>
        void BeforeExecuted(object?[]? args);
        /// <summary>
        /// 执行后
        /// </summary>
        /// <param name="args">参数</param>
        /// <param name="result">返回值</param>
        void AfterExecuted(object?[]? args, object? result);

        void CatchException(Exception ex);

    }
    /// <summary>
    /// 方法执行的切面
    /// </summary>
    class ExecutAOP : IInterceptor
    {
        public void AfterExecuted(object?[]? args, object? result)
        {
            Console.WriteLine($"拦截器中方法后执行~~~~");
        }

        public void BeforeExecuted(object?[]? args)
        {
            if (args != null && args.Length > 0 && args[0] == null)
                throw new Exception("参数错误");
            Console.WriteLine($"拦截器中方法前执行~~~~");

        }
        public void CatchException(Exception ex)
        {
            Console.WriteLine($"拦截器中捕获到了异常~~~~\r\n{ex.InnerException.Message}");
        }
    }
```
### 6. 创建测试模型
设定一个业务场景,有一个交通工具`ITransportation`有两个公共方法` Run()` 、`Eat()`,以及其实现`Hours`类
```csharp
    interface ITransportation
    {
        public void Run();
        
        public void Eat(string food);
    }

    [InterceptAttribut(typeof(ExecutAOP))]
    class Horse : ITransportation
    {
        public void Eat(string food)
        {
            Console.WriteLine($"小马儿吃了{food}~~~~~~~~~~~~");
        }

        public void Run()
        {
            Console.WriteLine("马儿马儿快马加鞭~~~~~~~~~~~~");
            throw new Exception("小马儿掉沟里了");
        }
    }
```
### 7.测试场景

1. 测试切面方法执行前和执行后

    
```csharp
    static void Main(string[] args)
    {
        ServiceHelp.BuildServiceProvider();

        var hours = DynamicProxyFactory.Create<ITransportation>();

        hours.Eat("新鲜牧草");

        Console.ReadLine();
    }

```
输出:

![image.png](https://niuery.com/static/img/bcace5bd480606ac5fb97bc4b7c3bb7e.image.png)

从控制台输出可以看到，`Horse`再执行`Eat`方法前和方法后都被拦截，并输出了预期结果

2. 测试切面方法异常处理
```csharp
    static void Main(string[] args)
    {
        ServiceHelp.BuildServiceProvider();

        var hours = DynamicProxyFactory.Create<ITransportation>();

        hours.Run();

        Console.ReadLine();
    }

```
输出:

![image.png](https://niuery.com/static/img/4c115bd6a04fd809bc1148e2eace0ee1.image.png)
再`Horse`的`Run`方法中我们主动抛出了异常，然后从控制台输出可以看到，异常也被拦截器拦截，并做了处理输出`拦截器中捕获到了异常`及异常信息。

## 总结
总之，AOP编程思想是一种非常有用的编程范式，它可以使得程序的结构更加清晰、易于维护和扩展，同时也可以提高程序的重用性和可测试性。在日常的软件开发中，我们可以使用AOP框架来实现AOP编程思想，从而提高开发效率和代码质量。

AOP --- 面向切面编程

## 引言

IOC，全称为 Inversion of Control（控制反转），是一种重要的编程思想，它可以帮助我们更好地管理程序中的依赖关系。在IOC的基础上，依赖注入（Dependency Injection，DI）是一种实现IOC的技术手段，它可以提高代码**可测试性**，**可维护性**，**可拓展性**。


## 什么是IOC？

在传统的程序设计中，我们通常会使用直接依赖的方式来实现功能，这意味着我们需要自己创建并管理对象之间的依赖关系。这种方式有一个很明显的缺点，就是代码之间的耦合度非常高，一旦某个类发生了改变，所有依赖于它的类都需要修改。

而IOC则是一种反转控制的方式，它将对象的创建、依赖管理等控制权从程序员手中转移到了容器中，容器会根据配置信息来自动创建对象、管理依赖关系。这样做的好处在于，我们只需要关注自己的业务逻辑，而不需要关心对象的创建、销毁等底层细节

## 什么是依赖注入？
依赖注入是实现IOC的一种方式，它是指将对象所需要的依赖关系通过构造函数、属性、方法等方式传递给对象。通常情况下，我们会使用**构造函数注入**、**Setter方法注入**、**接口注入**等方式来实现依赖注入。

以构造函数注入为例，我们可以将对象所需要的依赖关系通过构造函数的参数传递进来，这样做的好处在于，我们可以在对象创建的时候就确定它所依赖的对象，从而避免了后续修改依赖关系的麻烦。

## 直接依赖可能存在的问题

### 1. 高度耦合
在应用程序中使用紧密耦合的代码会导致代码难以维护和扩展。当一个组件的代码更改时，需要更改其他依赖于该组件的组件的代码。这种高度耦合的代码可能难以单元测试，因为测试需要创建所有依赖项的实例，这可能会使测试变得复杂

### 2. 硬编码依赖项
如果应用程序使用硬编码依赖项，即在代码中直接实例化依赖项，那么应用程序的可测试性将受到影响。这是因为在测试时，不可能轻松地用模拟对象或者桩来替换硬编码的依赖项，这样可能会使测试变得非常困难

### 3. 依赖项管理困难
如果没有使用IOC容器，那么将需要手动管理依赖项的生命周期，包括创建、初始化和销毁。这可能会使代码更加复杂，容易出错，也会导致代码可维护性的下降。

### 4. 缺乏灵活性
没有使用IOC，可能会导致应用程序的灵活性下降。因为依赖项在代码中硬编码，所以更改依赖项需要更改代码。而使用IOC，只需要更改配置即可更改依赖项，从而提高了应用程序的灵活性

### 5. 代码重复
如果没有使用IOC，那么可能会在应用程序中出现大量的重复代码。因为每个组件都需要手动实例化它们的依赖项，这可能导致重复的代码。而使用IOC，可以将依赖项的创建和管理交给IOC容器，从而避免代码重复

## 依赖注入的实现方式
依赖注入的实现方式有很多种，常见的有构造函数注入、Setter方法注入、接口注入等。

### 1. 构造函数注入
构造函数注入是最常见的依赖注入方式，它可以将对象所需要的依赖关系通过构造函数的参数传递进来。这种方式的好处在于，可以在对象创建的时候就确定它所依赖的对象，从而避免了后续修改依赖关系的麻烦。

```csharp
public class MyService
{
    private readonly ILogger _logger;
    private readonly IEmailService _emailService;

    public MyService(ILogger logger, IEmailService emailService)
    {
        _logger = logger;
        _emailService = emailService;
    }

    public void DoSomething()
    {
        // 业务逻辑代码
        // ...
        _logger.Log("DoSomething has been executed");
        _emailService.SendEmail("someone@example.com", "DoSomething has been executed");
    }
}

```

### 2. Setter方法注入
Setter方法注入是另一种常见的依赖注入方式，它可以将对象所需要的依赖关系通过Setter方法进行注入。这种方式的好处在于，可以将对象的依赖关系动态地进行修改，从而更加灵活地管理依赖关系。


```csharp
public class MyService
{
    private ILogger _logger;
    private IEmailService _emailService;

    public void SetLogger(ILogger logger)
    {
        _logger = logger;
    }

    public void SetEmailService(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public void DoSomething()
    {
        // 业务逻辑代码
        // ...
        _logger.Log("DoSomething has been executed");
        _emailService.SendEmail("someone@example.com", "DoSomething has been executed");
    }
}
```

### 3. 接口注入
接口注入是一种比较高级的依赖注入方式，它可以将对象所需要的依赖关系通过接口进行注入。这种方式的好处在于，可以通过接口来进行依赖管理，从而更加灵活地实现对象之间的交互。

```csharp
public interface ILogger
{
    void Log(string message);
}

public interface IEmailService
{
    void SendEmail(string toAddress, string message);
}

public class MyService : IServiceDependency
{
    private readonly ILogger _logger;
    private readonly IEmailService _emailService;

    public MyService(IServiceProvider serviceProvider)
    {
        _logger = serviceProvider.GetService<ILogger>();
        _emailService = serviceProvider.GetService<IEmailService>();
    }

    public void DoSomething()
    {
        // 业务逻辑代码
        // ...
        _logger.Log("DoSomething has been executed");
        _emailService.SendEmail("someone@example.com", "DoSomething has been executed");
    }
}

public interface IServiceDependency
{
}

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddMyServices(this IServiceCollection services)
    {
        services.AddSingleton<ILogger, ConsoleLogger>();
        services.AddSingleton<IEmailService, SmtpEmailService>();
        services.AddSingleton<IServiceDependency>(serviceProvider => new MyService(serviceProvider));
        return services;
    }
}

public class Program
{
    static void Main(string[] args)
    {
        var services = new ServiceCollection();
        services.AddMyServices();

        using (var serviceProvider = services.BuildServiceProvider())
        {
            var myService = serviceProvider.GetService<IServiceDependency>();
            myService.DoSomething();
        }
    }
}

```
## 总结

依赖注入是一种实现IOC的技术手段，它可以帮助我们更好地管理程序中的依赖关系，降低代码耦合度，提高代码复用性和可测试性。当我们掌握了依赖注入的技术，就可以更加轻松地编写高质量、可维护的代码。