概述

ECS全稱Entity-Component-System，即實體-元件-系統。是一種面向資料(Data-Oriented Programming)的程式設計架構模式。
這種架構思想是在GDC的一篇演講《Overwatch Gameplay Architecture and Netcode》（翻成：守望先鋒的遊戲架構和網路程式碼）後受到了廣泛的學習討論。在程式碼設計上有一個原則「組合優於繼承」，它的核心設計思想是基於這一思想的「元件式設計」。

ECS職責定義

Entity（實體）：在ECS架構中表示「一個單位」，可以被ECS內部標識，可以掛載若干元件。
Component（元件）：掛載在Entity上的元件，負載實體某部分的屬性，是純資料結構不包含函數。
System（系統）：純函數不包含資料，只關心具有某些特定屬性（元件）的Entity，對這些屬性進行處理。

執行邏輯

某個業務系統篩選出擁有這個業務系統相關元件的實體，對這些實體的相關元件進行處理更新。

基本特點

Entity資料結構抽象：

PosiComp	MoveComp	AttrComp	...
Pos	Velocity	Hp	...
Map	-	Mp	...
-	-	ATK	...

元件內聚本業務相關的屬性，某個實體不同業務的屬性通過元件聚合在一起。
- 從資料結構角度上看，Entity類似一個2維的稀疏表，如上述Entity資料結構抽象
- OOP的思路知道型別就知道了這個物件的屬性，ECS的實體是知道了有哪些元件知道這個實體大概是什麼，有點像鴨子理論：如果走路像鴨子、說話像鴨子、長得像鴨子、啄食也像鴨子，那它肯定就是一隻鴨子。
業務系統收集所有具有本業務要求元件的Entity，集中批次的處理這些Entity的相關元件

推論

ECS的元件式設計，是高內聚、低耦合的，對千變萬化的業務需求十分友好
批次處理資料在這些資料在連續記憶體的場合下對CPU快取機制友好
低資料耦合可以減少資源競爭對並行友好
ECS處理資料的方式是批次處理的，一個實體需要連續處理的場合十分不友好

個人見解

個人認為ECS架構的核心是為了解決物件中複雜的聚合問題，能有效的管理程式碼的複雜度，至於某些場合下的效能的提升，在大多數情況下只是錦上添花的作用（一些SLG遊戲具有大量單位可能會有提升吧）。它沒有傳統OOP程式設計模式的複雜的繼承關係造成的不必要的耦合，結構更加扁平化，相比之下更易於業務的閱讀理解和拓展。但這種技術並非是完美無缺的，它十分不擅長單個實體需要連續處理業務（如序列化等）或實體之間相互關聯等場合（如更新兩個實體的距離），而且對於一些業務邏輯相對固定的模組或者一些底層模組來說，鬆耦合和管理複雜度可能不是首要問題，有可能在設計上硬拗ECS元件式設計反而帶來困擾。對於遊戲來說，ECS架構在GamePlay上的實用程度相對較高，在其他符合其特性的模組如（網路模組）也能提供一些不同以往的解題思路。

細節討論

單例元件

Q：有些資料只需要一份或被全域性存取等情況下，沒必要掛載在Entity上和篩選
A：使用單例元件，和其他元件一樣是純資料，但是可以通過單例全域性存取，即可以被任意系統任意存取。

工具方法

Q：有些處理方法，不適合進行批次處理（例如計算兩個單位的距離，沒必要弄個系統每個單位都相互計算距離）
A：用工具方法，它通常是無副作用的，不會改變任何狀態，只返回計算結果

System之間的依賴關係

Q: 假設有渲染系統和碰撞系統，要像在這一幀正確的渲染目標的位置，就需要碰撞系統先更新位置資訊，渲染系統在進行位置，需要正確處理系統間的前後依賴關係。

A：一個很自然的思路就是分層，根據不同層級的優先順序進行處理。由此提出流水線（Piepline）的抽象，定義一顆樹和相關節點，系統掛載在其節點上，執行時以某種順序（先序遍歷）展開，同一個節點的系統可以並行（沒有依賴）。有需要的話流水線還可以定義系統/實體/元件的初始化等其他問題。

System對Entity的篩選

Q：「原教旨主義」的ECS框架有ECS幀的概念，系統會在每一幀重新篩選需要處理的Entity。這種處理方式引起了很大的爭論，大家認為是有一些優化空間。

A：社群中幾乎沒人贊同「原教旨主義」的做法，原因很簡單：很多Entity在整個生命週期中都沒元件的增刪操作，還有相當部分有的有增刪操作的Entity其操作頻率也很低，每幀都遍歷重新篩選代價相對太過昂貴，所以有人提出了快取、分類、延遲增刪操作等思路。一種思路是：Entity的增刪/元件的增刪的操作進行快取，延遲到該系統執行時在進行評估篩選，以減少遍歷和重複操作。

Entity是否在執行期動態更改元件分類&System是否每幀篩選Entity分類

Q：並不是每個Entity執行期都會改變動態變更元件，有些Entity在執行期壓根就不變更元件，甚至它只被編譯期就知道的指定System處理。也有些System不在執行期篩選Entity，要麼編譯期就知道處理哪些Entity，要麼是處理一些單例元件。所以有人提出要不要對Entity和System對它們是否在執行期動態操作進行分類，以提升效率。

A：個人認為，Entity不變更元件，本身變動訊息就很少只有增刪，配合一些快取、延遲篩選等方法其實沒什麼影響。不動態篩選Entity的System倒是可以分型別關閉Entity篩選。

是否加入響應式處理

Q：ECS是「自驅式」的更新，就像是U3D的Mono的Update方法更新。還有一種響應式的更新，即基於訊息事件的通知。「原教旨主義」式的ECS框架是完全自驅的，沒有訊息機制。系統之間「訊息傳遞」是通過元件的資料傳遞的，所以在處理「當進入地圖時」這種場合，只能使用「HasEnterMap」或者「Enum.EnterMap」之類的標籤，或者新增一個「EnterMapComponent"來處理。

A：個人傾向於加入一些訊息的處理機制，可以更靈活些。基本思路是：給System新增一個收件箱，收到的訊息放在收件箱的佇列裡。Entity相關變更（增刪、變更元件）的一些訊息單獨使用一個佇列管道，在系統重新整理的時候首先處理Entity變更訊息，進行評估篩選Entity,然後處理信箱裡的其他訊息，然後在處理System的更新邏輯。

記憶體效率優化

Q：批次處理資料在實體記憶體連續的場合有利於CPU快取機制，關鍵是如何讓資料的記憶體連續。首先想到的是使用陣列，那麼是元件使用陣列還是Entity使用陣列呢？
A：如果是元件使用陣列，那麼當系統處理的Entity包含多個元件的話，那麼記憶體存取會在不同的陣列中「跳來跳去」，優化效果十分有限。個人認為若是一定要優化記憶體存取，關鍵是保證元件一樣的Entity存放在連續記憶體（Chuck）中，這樣保證System存取Entity的記憶體連續，具體實現方案可以參考U3D的ECS設計Archetype和Chuck。另外，也有物件池的優化空間。上面提到，ECS並不是主要解決效能問題的，只是順帶的，不必太過於執著，當然有也是極好的~。

Unity ECS引入了Archetype和Chuck兩個概念，Archetype即為Entity對應的所有元件的一個組合，然後多個Archetypes會打包成一個個Archetype chunk，按照順序放在記憶體裡，當一個chunck滿了，會在接下來的記憶體上的位置建立一個新的chunk。因此，這樣的設計在CPU定址時就會更容易找到Entity相關的component

原型Demo範例

using System;
using System.Collections.Generic;
using System.Threading;

namespace ECSDemo
{
    public class Singleton<T> where T : Singleton<T>, new()
    {
        private static T inst;

        public static T Inst
        {
            get
            {
                if (inst == null)
                    inst = new T();
                return inst;
            }
        }
    }

    #region Component 元件
    public class Component
    {

    }

    public class SingleComp<T> : Singleton<T> where T : Singleton<T>, new()
    {
        //
    }
    #endregion 

    #region Entity 實體

    public class EntityFactory
    {
        static long eid = 0;

        public static Entity Create()
        {
            Entity e = new Entity(eid);
            eid++;
            EntityChangedMsg.Inst.Pub(e);
            return e;
        }

        public static Entity CreatePlayer()
        {
            var e = Create();
            e.AddComp(new PosiComp());
            e.AddComp(new NameComp() { name = "Major" });
            return e;
        }

        public static Entity CreateMonster(string name)
        {
            var e = Create();
            e.AddComp(new PosiComp());
            e.AddComp(new NameComp() { name = name });

            return e;
        }
    }

    public class Entity
    {
        long instID = 0;

        public long InstID { get => instID; }

        public Entity(long id) { instID = id; }

        // 預計一個Entity元件不會很多，故使用連結串列...
        List<Component> comps = new();

        public void AddComp<T>(T t) where T : Component
        {
            comps.Add(t);
            EntityChangedMsg.Inst.Pub(this);
        }

        public void RemoveComp<T>(T t) where T : Component
        {
            comps.Remove(t);
            EntityChangedMsg.Inst.Pub(this);
        }

        public T GetComp<T>() where T : Component
        {
            foreach (var comp in comps)
                if (comp is T) return comp as T;

            return default(T);
        }

        public bool ContrainComp(Type type)
        {
            foreach (var comp in comps)
                if (comp.GetType() == type) return true;
            return false;
        }
    }
    #endregion

    #region System 系統
    public class System
    {
        protected SystemMsgBox msgBox = new();

        public virtual void Run()
        {
            msgBox.Each();
            OnRun();
        }

        public virtual void OnRun()
        {

        }
    }

    public class SSystem : System
    {
        //
    }

    public class DSystem : System
    {
        protected Dictionary<long, Entity> entities = new();
        protected List<Type> conds = new();
        HashSet<Entity> evalSet = new();

        public DSystem()
        {
            msgBox.Sub(EntityChangedMsg.Inst, (msg) => {
                var body = (EntityChangedMsg.MsgBody)msg;
                var e = body.Value;
                evalSet.Add(e);
            });
        }

        public void Evalute(Entity e)
        {
            var id = e.InstID;
            bool test = true;
            foreach (var cond in conds)
                if (!e.ContrainComp(cond))
                {
                    test = false;
                    break;
                }

            Entity cache;
            entities.TryGetValue(id, out cache);
            if (test)
                if (cache == null) entities.Add(id, e);
                else
                if (cache != null) entities.Remove(id);
        }

        public override void Run()
        {
            msgBox.EachEntityMsg();
            foreach (var e in evalSet)
                Evalute(e);
            evalSet.Clear();
            msgBox.Each();
            OnRun();
        }
    }
    #endregion

    #region Pipline 流水線
    public class Pipeline<ENode, V>
    {
        public class Node<NENode, NV>
        {
            List<NV> items = new();
            NENode node;
            Node<NENode, NV> parent;
            List<Node<NENode, NV>> childern = new();

            public List<Node<NENode, NV>> Childern { get => childern; }
            public List<NV> Items { get => items; }

            public Node(NENode n)
            {
                node = n;
            }

            public void AddChild(Node<NENode, NV> c)
            {
                childern.Add(c);
                c.parent = this;
            }

            public void RemoveChild(Node<NENode, NV> c)
            {
                childern.Remove(c);
                c.parent = null;
            }

            public void AddItem(NV v)
            {
                items.Add(v);
            }

            public void RemoveItem(NV v)
            {
                items.Remove(v);
            }

        }

        Node<ENode, V> root;
        Dictionary<ENode, Node<ENode, V>> dict = new();
        public Pipeline(ENode node)
        {
            root = new Node<ENode, V>(node);
            dict.Add(node, root);
        }

        public void AddNode(ENode n)
        {
            Node<ENode, V> p = root;
            AddNode(n, p);
        }

        public void AddNode(ENode n, Node<ENode, V> p)
        {
            var node = new Node<ENode, V>(n);
            p.AddChild(node);
            dict.Add(n, node);
        }

        public void AddNode(ENode n, ENode p)
        {
            Node<ENode, V> node;
            dict.TryGetValue(p, out node);
            if (node != null)
                AddNode(n, node);
        }

        public void AddItem(ENode n, V item)
        {
            Node<ENode, V> node;
            dict.TryGetValue(n, out node);
            if (node != null)
                node.AddItem(item);
        }

        public void RemoveItem(ENode n, V item)
        {
            Node<ENode, V> node;
            dict.TryGetValue(n, out node);
            if (node != null)
                node.RemoveItem(item);
        }

        protected void Traveral(Action<V> action)
        {
            TraveralInner(root, action);
        }

        protected void TraveralInner(Node<ENode, V> node, Action<V> action)
        {
            var childern = node.Childern;
            var items = node.Items;
            foreach (var child in childern)
                TraveralInner(child, action);
            foreach (var item in items)
                action(item);
        }
    }

    public class SystemPipeline : Pipeline<ESystemNode, System>
    {
        public SystemPipeline(ESystemNode en) : base(en)
        {
            //
        }

        public void Update()
        {
            Traveral((sys) => sys.Run());
        }
    }

    public enum ESystemNode : int
    {
        Root = 0,
        Base = 1,
        FrameWork = 2,
        GamePlay = 3,
    }

    
    #endregion

    #region World 世界
    public class World : Singleton<World>
    {
        SystemPipeline sysPipe;

        public void Init()
        {
            sysPipe = SystemPipelineTemplate.Create();
        }

        public void Update()
        {
            sysPipe.Update();
        }
    }
    #endregion

    #region Event 事件
    public class Event<T> : Singleton<Event<T>>
    {
        List<Action<T>> actions = new();

        public void Sub(Action<T> action)
        {
            actions.Add(action);
        }

        public void UnSub(Action<T> action)
        {
            actions.Remove(action);
        }

        public void Pub(T t)
        {
            foreach (var action in actions)
                action(t);
        }
    }

    public class EveEntityChanged : Event<Entity> { }

    public interface IMsgBody
    {
        Type Type();
    }

    public interface IMsg
    {
        void Sub(MsgBox listener);
        void UnSub(MsgBox listener);
    }

    public class Msg<T> : Singleton<Msg<T>>, IMsg
    {
        public class MsgBody : IMsgBody
        {
            public MsgBody(T v, Type ty) { Value = v; type = ty; }
            Type type;
            public T Value { private set; get; }

            public Type Type()
            {
                return type;
            }
        }

        List<MsgBox> listeners = new();

        public void Sub(MsgBox listener)
        {
            listeners.Add(listener);
        }

        public void UnSub(MsgBox listener)
        {
            listeners.Remove(listener);
        }

        public void Pub(T t)
        {
            var msgBody = new MsgBody(t, this.GetType());
            foreach (var listener in listeners)
                listener.OnMsg(msgBody);
        }
    }

    public class EntityChangedMsg : Msg<Entity> { }

    public class MsgBox
    {
        protected Queue<IMsgBody> msgs = new();
        protected Dictionary<Type, Action<IMsgBody>> handles = new();

        public virtual void OnMsg(IMsgBody body)
        {
            msgs.Enqueue(body);
        }


        public void Sub(IMsg msg, Action<IMsgBody> cb)
        {
            msg.Sub(this);
            handles.Add(msg.GetType(), cb);
        }

        public void UnSub(IMsg msg, Action<IMsgBody> cb)
        {
            msg.UnSub(this);
            handles.Remove(msg.GetType());
        }

        public virtual void Each()
        {
            while (msgs.Count != 0)
            {
                var msg = msgs.Dequeue();
                var type = msg.Type();
                Action<IMsgBody> handle;
                handles.TryGetValue(type, out handle);
                if (handle != null)
                    handle(msg);
            }
        }
    }

    public class SystemMsgBox : MsgBox
    {
        Queue<IMsgBody> entityMsgs = new();

        public override void OnMsg(IMsgBody body)
        {
            if (body.Type() == typeof(EntityChangedMsg))
                entityMsgs.Enqueue(body);
            else
                msgs.Enqueue(body);
        }

        public void EachEntityMsg()
        {
            while (entityMsgs.Count != 0)
            {
                var msg = entityMsgs.Dequeue();
                var type = msg.Type();
                Action<IMsgBody> handle;
                handles.TryGetValue(type, out handle);
                if (handle != null)
                    handle(msg);
            }
        }

        public override void Each()
        {
            while (msgs.Count != 0)
            {
                var msg = msgs.Dequeue();
                var type = msg.Type();
                Action<IMsgBody> handle;
                handles.TryGetValue(type, out handle);
                if (handle != null)
                    handle(msg);
            }
        }
    }

    #endregion

    #region AppTest

    public class AppComp : SingleComp<AppComp>
    {
        public bool hasInit;
    }

    public class MapComp : SingleComp<MapComp>
    {
        public bool hasInit;
        public int monsterCnt = 2;
    }

    public class PosiComp : Component
    {
        public int x;
        public int y;
    }

    public class NameComp : Component
    {
        public string name = "";
    }

    public class AppSystem : SSystem
    {
        public override void OnRun()
        {
            if (!AppComp.Inst.hasInit)
            {
                AppComp.Inst.hasInit = true;
                Console.WriteLine("App 啟動");
            }
        }
    }

    public class SystemPipelineTemplate
    {
        public static SystemPipeline Create()
        {
            SystemPipeline pipeline = new(ESystemNode.Root);

            // 基本系統
            pipeline.AddNode(ESystemNode.Base, ESystemNode.Root);
            pipeline.AddItem(ESystemNode.Base, new AppSystem());

            pipeline.AddNode(ESystemNode.GamePlay, ESystemNode.Root);
            pipeline.AddItem(ESystemNode.GamePlay, new PlayerSystem());
            pipeline.AddItem(ESystemNode.GamePlay, new MapSystem());

            return pipeline;
        }
    }

    public class MapSystem : DSystem
    {
        public MapSystem() : base()
        {
            conds.Add(typeof(PosiComp));
            conds.Add(typeof(NameComp));
        }

        public override void OnRun()
        {
            if (!MapComp.Inst.hasInit)
            {
                MapComp.Inst.hasInit = true;
                for (int i = 0; i < MapComp.Inst.monsterCnt; i++)
                    EntityFactory.CreateMonster($"Monster{i + 1}");

                Console.WriteLine($"進入地圖 生成{MapComp.Inst.monsterCnt}只小怪");
            }

            foreach (var (id, e) in entities)
            {
                var name = e.GetComp<NameComp>().name;
                var x = e.GetComp<PosiComp>().x;
                var y = e.GetComp<PosiComp>().y;

                Console.WriteLine($"【{name}】 在地圖的 x = {x}, y = {y}");

            }
        }
    }

    public class PlayerComp : SingleComp<PlayerComp>
    {
        public Entity Major;
    }

    public class PlayerSystem : SSystem
    {
        public override void OnRun()
        {
            base.OnRun();
            if (PlayerComp.Inst.Major == null)
                PlayerComp.Inst.Major = EntityFactory.CreatePlayer();

            if (Console.KeyAvailable)
            {
                int dx = 0;
                int dy = 0;
                ConsoleKeyInfo key = Console.ReadKey(true);
                switch (key.Key)
                {
                    case ConsoleKey.A:
                        dx = -1;
                        break;
                    case ConsoleKey.D:
                        dx = 1;
                        break;
                    case ConsoleKey.W:
                        dy = 1;
                        break;
                    case ConsoleKey.S:
                        dy = -1;
                        break;


                    default:
                        break;
                }

                if (dx != 0 || dy != 0)
                {
                    var comp = PlayerComp.Inst.Major.GetComp<PosiComp>();
                    if (comp != null)
                    {
                        Console.WriteLine($"玩家移動 Delta X = {dx}, Delta Y = {dy}");
                        comp.x += dx;
                        comp.y += dy;
                    }
                }
            }
        }
    }

    #endregion

    class Program
    {
        static void Main(string[] args)
        {
            World.Inst.Init();
            while (true)
                Loop();
        }

        public static void Loop()
        {
            World.Inst.Update();
            Console.WriteLine("--------------------------------------------");
            Thread.Sleep(1000);
        }
    }
}

Demo包含了ECS的基本定義和分層、篩選、訊息等機制，簡單的原型多看下應該可以看明白。
當XXX的訊息使用元件的資料HasInit實現，當然也可以使用訊息，思路是：給System加虛擬函式Awake、Start、End、Destory等虛擬函式，SystemPipeline初始化時兩次遍歷分別Awake、Start，同樣，清理時兩次遍歷呼叫End、Destory函數。可以在Start時監聽一些訊息，在End時清理。
Pipeline流水線有一種更加自動化的繫結節點的方法：使用C#的特性（Attribute）標記System，在程式啟動通過反射自動組裝。大概類似這樣：

[AttributeUsage(AttributeTargets.Class)]
public class SystemPipelineAttr : Attribute
{
    public ESystemNode Type;

    public SystemPipelineAttr(Type type = null)
    {
        this.Type = type;
    }
}

[SystemPipelineAttr(ESystemNode.GamePlay)]
public class MapSystem {} // ...

// ...
public static Dictionary<string, Type> GetAssemblyTypes(params Assembly[] args)
{
        Dictionary<string, Type> types = new Dictionary<string, Type>();

        foreach (Assembly ass in args)
        {
            foreach (Type type in ass.GetTypes())
            {
                types[type.FullName] = type;
            }
        }

        return types;
}

// ...
foreach (Type type in types[typeof (SystemPipelineAttr)])
{
	object[] attrs = type.GetCustomAttributes(typeof(SystemPipelineAttr), false);
	foreach (object attr in attrs)
	{
		SystemPipelineAttr attribute = attr as SystemPipelineAttr;
		// ...
	}
}

備註

ECS的架構目前使用的非常的多，很多有名的框架設計都或多或少的受到了其影響，有：
- U3D的ECS架構：不是指原來的GameObj那套，有專門的外掛，有記憶體優化
- UE4的元件設計：採用了特殊的元件實現父子關係
- ET框架：訊息 + ECS，採用ECS解耦，更注重訊息驅動的響應式設計，Entity和Comp的思路也獨特：Entity同時是元件，並有父子關係
- 雲風大佬的引擎：好像未開源，只有一些blog在討論ECS，貌似連引擎層面和Lua側都涉及ECS的設計思想

ECS架構分析

概述