設計6大原則和控制反轉(IoC)，依賴注入(DI)

1.單一職責原則(Single Responsibility Principle, SRP)：

（動物類就只需要實現和動物相關的信息，不可用來實現物品的信息）
一個類只負責一個功能領域中的相應職責，

2.開閉原則(Open-Closed Principle, OCP)：

（1.參數儘量以包裝的方式傳遞，2.實體和接口儘量不要修改，3.以擴展的形式進行程序修改和實現）
一個軟件實體應當對擴展開放，對修改關閉。即軟件實體應儘量在不修改原有代碼的情況下進行擴展。

3.里氏代換原則(Liskov Substitution Principle, LSP)：

（使用子類替換基類/父類不會出現錯誤和異常，反之則不可）
所有引用基類（父類）的地方必須能透明地使用其子類的對象
里氏代換原則告訴我們，在軟件中將一個基類對象替換成它的子類對象，程序將不會產生任何錯誤和異常，反過來則不成立，如果一個軟件實體使用的是一個子類對象的話，那麼它不一定能夠使用基類對象

4.接口隔離原則(Interface Segregation Principle, ISP)：

（接口儘可能的細小，獨立，專一/專門）

使用多個專門的接口，而不使用單一的總接口，即客戶端不應該依賴那些它不需要的接口。

5.迪米特法則(Law of Demeter, LoD)：

（不要和“陌生人”說話、只與你的直接朋友通信等）
一個軟件實體應當儘可能少地與其他實體發生相互作用。

6.依賴倒置:

（通過接口或基類的方式調用方法）
依賴倒置原則是五大原則之一:
1.上層模塊不應該依賴於下層模塊，它們共同依賴於一個抽象.
2.抽象不能依賴於具象，具象依賴於抽象.
什麼是上層?使用者就是上層,上例中,Test 類就是上層.
什麼是下層?被使用者就是下層.上例中,Test 類使用了 MyDependency 類, MyDependency 類就是下層.
上層不應該依賴下層,Test 類不應該依賴 MyDependency 類,因爲如果 MyDependency 類變化了,就是把這種變化所造成的影響傳遞到上層 Test 類.
因此,上例按照依賴倒置原則修改如下:

   public class Test
    {
        private IDepenency md = new MyDependency();

        public void Print()
        {
            md.Print();
        }
    } 
    public interface IDepenency
    {
        void Print();
    }
    public class MyDependency : IDepenency
    {
        public void Print()
        {
            Console.WriteLine("this is mydependency");
        }
    }

控制反轉(IoC):Inversion of Control

（將對象以參數的形式傳遞給使用的類，通過接口類型調用）
控制反轉是一種思想,所謂"控制反轉",就是反轉獲得依賴對象的過程.或許,叫"反轉控制"更容易理解.
上例雖然遵循了"依賴倒置原則",但是違背"開放封閉原則",因爲如果有一天想修改 md 爲 YourDependency 類的實例,則需要修改 Test 類.因此,我們需要反轉這種創建對象的過程.

    internal class Program
    {
        private static void Main(string[] args)
        {
            Test test = new Test(new MyDependency());
            test.Print();           
            Console.ReadKey();
        }
    }
    public class Test
    {
        private IDepenency md;

        public Test(IDepenency depenency)
        {
            md = depenency;
        }
        public void Print()
        {
            md.Print();
        }
    }    

上例中,將 md 的創建過程"反轉"給了調用者.

依賴注入(DI):Dependency Inject

（通過配置的思路，將類動態的獲取，然後以參數的方式傳入）
依賴注入設計模式是一種在類及其依賴對象之間實現控制反轉(IOC)思想的技術.
所謂依賴注入，就是由IoC容器在運行期間，動態地將某種依賴關係注入到對象之中。
我們先創建一個簡易的IoC容器(當然,實際的 IoC 容器複雜得多.):

    public class IoCContainer
    {
        private Dictionary<Type, Object> dic;

        public IoCContainer()
        {
            Init();
        }

        private void Init()
        {
            dic = new Dictionary<Type, object>
            {
                {typeof(IDepenency),new MyDependency() }
            };
        }

        public T GetInstance<T>()
        {
            return (T)dic[typeof(T)];
        }
    }

那麼,上例的調用,則可以修改成:

    internal class Program
    {
        private static void Main(string[] args)
        {
            IoCContainer container = new IoCContainer();//創建一個容器
            IDepenency dependency = container.GetInstance<IDepenency>();//獲取註冊的實例
            Test test = new Test(dependency);
            test.Print();
            Console.ReadKey();
        }
    }

依賴注入分爲3中:構造函數注入,屬性注入,方法注入,上例屬於構造函數注入.
ASP.NET Core 中的依賴注入
ASP.NET Core 內置的IoC容器,只支持構造函數注入,注入的方式如下:
在 Startup 類的 ConfigureServices 方法中註冊.

        public void ConfigureServices(IServiceCollection services)
        {            
　　　　　　  services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

            //DI
            services.AddTransient<IDependency, MyDependency>();
        }

使用:

    [Route("api/[controller]")]
    [ApiController]
    public class ValuesController : ControllerBase
    {
        private readonly IDepenency _dependency;
        public ValuesController(IDepenency dependency)
        {
            _dependency = dependency;
        }
        
        ...other codes
　　}

參考文章 (返回主頁 Matrix海 子)設計模式之六大原則（轉載）
(NET未來之路)ASP.NET Core 2.2 基礎知識(一) 依賴注入