迪米特原则的理解与具体实现 C# Unity

目录

前言

一、概念阐释

二、应用案例

1.公司员工案例

2.游戏启动案例

---

前言

本篇文章将从迪米特原则的概念展开介绍，接着对实际案例进行分析，促进对该原则的理解

一、概念阐释

迪米特法则又叫作最少知识原则，一个类对于其他类知道的越少越好，就是说一个对象应当对其他对象有尽可能少的了解,只和朋友通信，不和陌生人说话。

迪米特法则可以简单说成：talk only to your immediate friends。 可以被解释为：一个软件实体应当尽可能少的与其他实体发生相互作用。每一个软件单位对其他的单位都只有最少的知识。

迪米特法则的初衷在于降低类之间的耦合。由于每个类尽量减少了对其他类的依赖，因此，很容易使得系统的功能模块功能独立，相互之间不存在（或很少有）依赖关系。

迪米特法则不希望类之间建立直接的联系。如果真的有需要建立联系，也希望能通过它的友元类（友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）来转达。

二、应用案例

1.公司员工案例

在实际应用上来说，迪米特原则是一个类在创建方法和属性时要遵守的原则，要求一个对象对其他对象（类）有最少的了解（调用）,只和直接朋友（类中的字段属性，类中方法的参数类型，方法的返回值）通信，如果和非朋友通信，那么就处于一个较高耦合的状态

例如管理总公司的员工和分公司的员工，在这个案例中，就可以很好的将迪米特原则使用。在一开始先设置好员工各自的ID属性

class HeadOfficeEmployee
    {
        public int ID { get; set; }
    }

    class BranchOfficeEmployee
    {
        public int ID { get; set; }
    }

在程序设计的过程中，遵守迪米特原则，对员工的操作应该是完全分开的，例如存储员工的数据并打印他们的ID信息，那么应该分别创建对应的manager，使其只与对应的“朋友”通信,如下建立了

HeadOfficeManager类和BranchOfficeManager类，可以看到manager类各自管理着对应的员工，彼此不通信

class HeadOfficeManager
    {
        public List<HeadOfficeEmployee> GetHeadOfficeEmployees()
        {
            List<HeadOfficeEmployee> list = new List<HeadOfficeEmployee>();
            for(int i = 0; i < 10; i++)
            {
                HeadOfficeEmployee employee = new HeadOfficeEmployee();
                employee.ID = i;
                list.Add(employee);
            }
            return list;
        }

        public void Print()
        {
            List<HeadOfficeEmployee> listHead = this.GetHeadOfficeEmployees();
            Debug.Log("总公司的员工ID是：");
            foreach (var item in listHead)
            {
                Debug.Log(item.ID);
            }
        }
    }

    class BranchOfficeManager
    {
        public List<BranchOfficeEmployee> GetBranchOfficeEmployees()
        {
            List<BranchOfficeEmployee> list = new List<BranchOfficeEmployee>();
            for (int i = 0; i < 10; i++)
            {
                BranchOfficeEmployee employee = new BranchOfficeEmployee();
                employee.ID = i;
                list.Add(employee);
            }
            return list;
        }

        public void Print()
        {
            List<BranchOfficeEmployee> listHead = this.GetBranchOfficeEmployees();
            Debug.Log("分公司的员工ID是：");
            foreach (var item in listHead)
            {
                Debug.Log(item.ID);
            }
        }
    }

HeadOfficeManger只管理总公司的员工，BranchOfficeManager只管理子公司的员工，两个类之间互相不了解，最终在start函数中单独调用实现

public class DiMiTePrinciple : MonoBehaviour
    {

        void Start()
        {
            HeadOfficeManager headOfficeManager = new HeadOfficeManager();
            BranchOfficeManager branchOfficeManager = new BranchOfficeManager();
            headOfficeManager.Print();
            branchOfficeManager.Print();
        }
    }

2.游戏启动案例

还有一种实现形式，例如游戏的启动一般需要初始化很多东西，顺序有时候也十分重要，但是如果将这些初始化全部写下来，一个个调用，会造成代码之间的耦合，一个对象对另外一个对象太了解了。

所以我们可以将顺序在对象中包装好，另外一个对象直接调用。这样另一个对象MainGame就不用太了解GameAbout对象，减少了耦合，体现了迪米特原则的思想

public class GameAbout
    {
        void UIprepare()
        {
            Debug.Log("加载UI");
        }
        void Personprepare()
        {
            Debug.Log("加载人物");
        }
        void Musicprepare()
        {
            Debug.Log("加载声音");
        }

        public void StartGame()
        {
            UIprepare();
            Personprepare();
            Musicprepare();
        }
    }

    public class MainGame
    {
        public void GameRun(GameAbout gameAbout)
        {
            /*UIprepare();
            Personprepare();
            Musicprepare();*/

            gameAbout.StartGame();
        }
    }