使用和不使用框架依赖注入的注入方式

下面将为展示四个完整的控制台例子，分别展示如何在使用依赖注入框架和不使用依赖注入框架的情况下，进行属性注入和方法注入。

### 1. 使用依赖注入框架的属性注入方式

我们继续使用 .NET Core 的内置依赖注入框架来实现属性注入。

```csharp
using System;
using Microsoft.Extensions.DependencyInjection;

namespace DIExample
{
    // 定义 Mailable 接口
    interface Mailable
    {
        void Send();
    }

    // 实现 Mailable 接口的具体类
    class Email : Mailable
    {
        public void Send()
        {
            Console.WriteLine("发送邮件通知用户");
        }
    }

    // 订单类
    class Order
    {
        [ActivatorUtilitiesConstructor]
        public Order() {}

        // 属性注入
        public Mailable Mail { get; set; }

        public void Complete()
        {
            Console.WriteLine("订单已完成，状态已更新");
            Mail?.Send();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var serviceProvider = new ServiceCollection()
                .AddTransient<Mailable, Email>()
                .AddTransient<Order>()
                .BuildServiceProvider();

            var order = serviceProvider.GetService<Order>();
            order.Mail = serviceProvider.GetService<Mailable>();

            order.Complete();
            Console.ReadLine();
        }
    }
}
```

### 2. 使用依赖注入框架的方法注入方式

```csharp
using System;
using Microsoft.Extensions.DependencyInjection;

namespace DIExample
{
    interface Mailable
    {
        void Send();
    }

    class Email : Mailable
    {
        public void Send()
        {
            Console.WriteLine("发送邮件通知用户");
        }
    }

    class Order
    {
        [ActivatorUtilitiesConstructor]
        public Order() {}

        public void Complete(Mailable mail)
        {
            Console.WriteLine("订单已完成，状态已更新");
            mail.Send();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var serviceProvider = new ServiceCollection()
                .AddTransient<Mailable, Email>()
                .AddTransient<Order>()
                .BuildServiceProvider();

            var order = serviceProvider.GetService<Order>();
            var mail = serviceProvider.GetService<Mailable>();

            order.Complete(mail);
            Console.ReadLine();
        }
    }
}
```

### 3. 不使用框架的属性注入方式

```csharp
using System;

namespace DIExample
{
    interface Mailable
    {
        void Send();
    }

    class Email : Mailable
    {
        public void Send()
        {
            Console.WriteLine("发送邮件通知用户");
        }
    }

    class Order
    {
        // 属性注入
        public Mailable Mail { get; set; }

        public void Complete()
        {
            Console.WriteLine("订单已完成，状态已更新");
            Mail?.Send();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Order order = new Order();
            order.Mail = new Email();

            order.Complete();
            Console.ReadLine();
        }
    }
}
```

### 4. 不使用框架的方法注入方式

```csharp
using System;

namespace DIExample
{
    interface Mailable
    {
        void Send();
    }

    class Email : Mailable
    {
        public void Send()
        {
            Console.WriteLine("发送邮件通知用户");
        }
    }

    class Order
    {
        public void Complete(Mailable mail)
        {
            Console.WriteLine("订单已完成，状态已更新");
            mail.Send();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Order order = new Order();
            Mailable mail = new Email();

            order.Complete(mail);
            Console.ReadLine();
        }
    }
}
 

这四个例子分别展示了在使用和不使用依赖注入框架的情况下，进行属性注入和方法注入的方法。

总结一下：
1. 使用框架的属性注入和方法注入更为简洁，但需要了解和配置框架。
2. 不使用框架的属性注入和方法注入则更为直接，适用于简单场景或对框架不熟悉的情况下。

### 使用依赖注入框架的构造函数注入方式

using System;
using Microsoft.Extensions.DependencyInjection;

namespace DIExample
{
    interface IMailable
    {
        void Send();
    }

    class Email : IMailable
    {
        public void Send()
        {
            Console.WriteLine("发送邮件通知用户");
        }
    }

    class Order
    {
        private readonly IMailable _mail;

        // 构造函数注入
        public Order(IMailable mail)
        {
            _mail = mail;
        }

        public void Complete()
        {
            Console.WriteLine("订单已完成，状态已更新");
            _mail.Send();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var serviceProvider = new ServiceCollection()
                .AddTransient<IMailable, Email>()
                .AddTransient<Order>()
                .BuildServiceProvider();

            var order = serviceProvider.GetService<Order>();
            order.Complete();
            Console.ReadLine();
        }
    }
}
 

### 不使用依赖注入框架的构造函数注入方式

using System;

namespace DIExample
{
    interface IMailable
    {
        void Send();
    }

    class Email : IMailable
    {
        public void Send()
        {
            Console.WriteLine("发送邮件通知用户");
        }
    }

    class Order
    {
        private readonly IMailable _mail;

        // 构造函数注入
        public Order(IMailable mail)
        {
            _mail = mail;
        }

        public void Complete()
        {
            Console.WriteLine("订单已完成，状态已更新");
            _mail.Send();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            IMailable mail = new Email();
            Order order = new Order(mail);

            order.Complete();
            Console.ReadLine();
        }
    }
}