### Implement Query Example App in C#

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/2. 架构篇：QFramework.cs/09. Query 介绍.md

This snippet demonstrates the implementation of a Query example application using QFramework. It includes model definitions, architecture setup, a concrete Query class for fetching school population, and UI elements for triggering the query.

```csharp
using System.Collections.Generic;
using UnityEngine;

namespace QFramework.Example
{
    public class QueryExampleController : MonoBehaviour,IController
    {
        public class StudentModel : AbstractModel
        {

            public List<string> StudentNames = new List<string>()
            {
                "张三",
                "李四"
            };
            
            protected override void OnInit()
            {
                
            }
        }
        
        public class TeacherModel : AbstractModel
        {
            public List<string> TeacherNames = new List<string>()
            {
                "王五",
                "赵六"
            };
                
            protected override void OnInit()
            {
                
            }
        }

        // Architecture
        public class QueryExampleApp : Architecture<QueryExampleApp>
        {
            protected override void Init()
            {
                this.RegisterModel(new StudentModel());
                this.RegisterModel(new TeacherModel());
            }
        }
        
        
        /// <summary>
        /// 获取学校的全部人数
        /// </summary>
        public class SchoolAllPersonCountQuery : AbstractQuery<int>
        {
            protected override int OnDo()
            {
                return this.GetModel<StudentModel>().StudentNames.Count +
                       this.GetModel<TeacherModel>().TeacherNames.Count;
            }
        }

        private int mAllPersonCount = 0;

        private void OnGUI()
        {
            GUILayout.Label(mAllPersonCount.ToString());

            if (GUILayout.Button("查询学校总人数"))
            {
                mAllPersonCount = this.SendQuery(new SchoolAllPersonCountQuery());
            }
        }

        public IArchitecture GetArchitecture()
        {
            return QueryExampleApp.Interface;
        }
    }
}
```

--------------------------------

### QFramework.cs Architecture Example

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/1. 介绍/01.简介.md

Demonstrates a typical controller implementation using QFramework.cs for managing application state and UI interactions. It shows how to get models, find UI components, and send commands.

```csharp
namespace QFramework.Exmaple
{
    public class CounterAppController : MonoBehaviour , IController
    {
        // View
        private Button mBtnAdd;
        private Button mBtnSub;
        private Text mCountText;
        
        // Model
        private ICounterAppModel mModel;

        void Start()
        {
            // 获取模型
            mModel = this.GetModel<ICounterAppModel>();
            
            // View 组件获取
            mBtnAdd = transform.Find("BtnAdd").GetComponent<Button>();
            mBtnSub = transform.Find("BtnSub").GetComponent<Button>();
            mCountText = transform.Find("CountText").GetComponent<Text>();
            
            
            // 监听输入
            mBtnAdd.onClick.AddListener(() =>
            {
                // 交互逻辑
                this.SendCommand<IncreaseCountCommand>();
            });
            
            mBtnSub.onClick.AddListener(() =>
            {
                // 交互逻辑
                this.SendCommand(new DecreaseCountCommand(/* 这里可以传参（如果有） */));
            });

            // 表现逻辑
            mModel.Count.RegisterWithInitValue(newCount => // -+
            {
                UpdateView();

            }).UnRegisterWhenGameObjectDestroyed(gameObject);
        }
        
        void UpdateView()
        {
            mCountText.text = mModel.Count.ToString();
        }

        public IArchitecture GetArchitecture()
        {
            return CounterApp.Interface;
        }

        private void OnDestroy()
        {
          
            mModel = null;
        }
    }
}
```

--------------------------------

### Comprehensive QFramework Architecture Setup

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

A more extensive example of registering numerous Systems, Models, and Utilities within the QFramework Architecture for a game project. This demonstrates a larger-scale application.

```csharp
using IndieGame.Models;
using IndieGame.Utility;
using QFramework;
using UnityEngine;
using UTGM;

namespace IndieGame
{
    public class LiangxiesGame : Architecture<LiangxiesGame>
    {
        public static bool IsTestMode = true;

        public static void SetTestMode(bool testMode)
        {
            IsTestMode = testMode;
        }

        protected override void Init()
        {
            RegisterSystem<ISaveSystem>(new SaveSystem());
            RegisterSystem<IInputSystem>(new InputSystem());
            RegisterSystem<ILevelSystem>(new LevelSystem());
            RegisterSystem<IBookSystem>(new BookSystem());
            RegisterSystem<IMapSystem>(new MapSystem());
            RegisterSystem<IGameTimeSystem>(new GameTimeSystem());
            RegisterSystem<IRankSystem>(new RankSystem());
            RegisterSystem<IGameSystem>(new GameSystem());
            RegisterSystem<ILuaSystem>(new LuaSystem());
            RegisterSystem<IAchievementSystem>(new AchievementSystem());
            RegisterSystem<IEnemyRecycleSystem>(new EnemyRecycleSystem());
            RegisterSystem<IUISystem>(new UISystem());
            RegisterSystem<IHurtSystem>(new HurtSystem());
            RegisterSystem<ILevelUpSystem>(new LevelUpSystem());
            RegisterSystem<ILevelConfigSystem>(new LevelConfigSystem());
        
            RegisterModel<ICoinModel>(new CoinModel());
            RegisterModel<ISettingModel>(new SettingModel());
            RegisterModel<IBookModel>(new BookModel());
            RegisterModel<IMechanismModel>(new MechanismModel());
            RegisterModel<IPlayerModel>(new PlayerModel());
            
            RegisterUtility<IStorage>(new EasySaveStorage());

            Application.persistentDataPath.CreateDirIfNotExists();
        }
    }
}
```

--------------------------------

### Counter App Controller Example

Source: https://github.com/liangxiegame/qframework/wiki/当前版本

Demonstrates a typical controller setup in QFramework.cs for managing a counter application, including view component retrieval, model access, and command sending for user interactions.

```csharp
namespace QFramework.Exmaple
{
    public class CounterAppController : MonoBehaviour , IController
    {
        // View
        private Button mBtnAdd;
        private Button mBtnSub;
        private Text mCountText;
        
        // Model
        private ICounterAppModel mModel;

        void Start()
        {
            // 获取模型
            mModel = this.GetModel<ICounterAppAppModel>();
            
            // View 组件获取
            mBtnAdd = transform.Find("BtnAdd").GetComponent<Button>();
            mBtnSub = transform.Find("BtnSub").GetComponent<Button>();
            mCountText = transform.Find("CountText").GetComponent<Text>();
            
            
            // 监听输入
            mBtnAdd.onClick.AddListener(() =>
            {
                // 交互逻辑
                this.SendCommand<IncreaseCountCommand>();
            });
            
            mBtnSub.onClick.AddListener(() =>
            {
                // 交互逻辑
                this.SendCommand(new DecreaseCountCommand(/* 这里可以传参（如果有） */));
            });
        }
    }
}
```

--------------------------------

### Initial Setup and Event Listener Registration

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

This snippet shows the initial setup of UI components and the registration of event listeners for button clicks and data change events. It demonstrates how to send commands and register for events, ensuring cleanup when the GameObject is destroyed.

```csharp
            mBtnSub = transform.Find("BtnSub").GetComponent<Button>();
            mCountText = transform.Find("CountText").GetComponent<Text>();
            
            
            // 监听输入
            mBtnAdd.onClick.AddListener(() =>
            {
                // 交互逻辑
                this.SendCommand<IncreaseCountCommand>();
            });
            
            mBtnSub.onClick.AddListener(() =>
            {
                // 交互逻辑
                this.SendCommand(new DecreaseCountCommand(/* 这里可以传参（如果有） */));
            });
            
            UpdateView();
            
            // 表现逻辑
            this.RegisterEvent<CountChangeEvent>(e =>
            {
                UpdateView();

            }).UnRegisterWhenGameObjectDestroyed(gameObject);
        }
        
        void UpdateView()
        {
            mCountText.text = mModel.Count.ToString();
        }

        // 3.
        public IArchitecture GetArchitecture()
        {
            return CounterApp.Interface;
        }

        private void OnDestroy()
        {
            // 8. 将 Model 设置为空
            mModel = null;
        }
    }
}
```

--------------------------------

### QFramework Toolkits UI Panel Example

Source: https://github.com/liangxiegame/qframework/wiki/v1.0.28

Shows how to use QFramework's toolkits, specifically ResLoader and ActionKit, within a UI panel. This example demonstrates loading a prefab, instantiating it, and setting up button click listeners for UI interactions.

```csharp
using QFramework;
using UnityEngine;
using UnityEngine.UI;

namespace liangxiegame
{
    public partial class UIGamePanel : UIPanel
    {
        private ResLoader mResLoader;
        
        protected override void OnInit(IUIData uiData = null)
        {
            mResLoader = ResLoader.Allocate();
            
            mResLoader.LoadSync<GameObject>("GameplayRoot")
                .Instantiate()
                .Identity()
                .GetComponent<GameplayRoot>()
                .InitGameplayRoot();
            
            
            BtnPause.onClick.AddListener(() =>
            {
                AudioKit.PlaySound("btn_click");
                
                ActionKit.Sequence()

```

--------------------------------

### Registering Systems, Models, and Utilities in Architecture

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

Example of how to register various components like Systems, Models, and Utilities within the QFramework Architecture. This is a basic setup for a PointGame.

```csharp
namespace QFramework.PointGame
{
    public class PointGame : Architecture<PointGame>
    {
        protected override void Init()
        {
            RegisterSystem<IScoreSystem>(new ScoreSystem());
            RegisterSystem<ICountDownSystem>(new CountDownSystem());
            RegisterSystem<IAchievementSystem>(new AchievementSystem());

            RegisterModel<IGameModel>(new GameModel());

            RegisterUtility<IStorage>(new PlayerPrefsStorage());
        }
    }
}
```

--------------------------------

### QFramework Async Load Example

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/4. 解决方案篇/01. ResKit：资源管理&开发解决方案/03. 异步加载.md

Demonstrates a comprehensive asynchronous loading example using QFramework's ResKit and ResLoader. It initializes ResKit, loads multiple GameObjects with different loading patterns, and includes a delayed recycling of cached resources.

```csharp
using System.Collections;
using UnityEngine;

namespace QFramework.Example
{
    public class AsyncLoadExample : MonoBehaviour
    {
        IEnumerator Start()
        {
            yield return ResKit.InitAsync();

            var resLoader = ResLoader.Allocate();
            
            resLoader.Add2Load<GameObject>("AssetObj 1",(b, res) =>
            {
                if (b)
                {
                    res.Asset.As<GameObject>().Instantiate();
                }
            });

            // AssetBundleName + AssetName
            resLoader.Add2Load<GameObject>("assetobj 2_prefab","AssetObj 2",(b, res) =>
            {
                if (b)
                {
                    res.Asset.As<GameObject>().Instantiate();
                }
            });
            
            resLoader.Add2Load<GameObject>("AssetObj 3",(b, res) =>
            {
                if (b)
                {
                    res.Asset.As<GameObject>().Instantiate();
                }
            });

            resLoader.LoadAsync(() =>
            {
                // Load and recycle after 5 seconds
                ActionKit.Delay(5.0f, () =>
                {
                    resLoader.Recycle2Cache();

                }).Start(this);
            });
        }

    }
}
```

--------------------------------

### Comprehensive QFramework Architecture Initialization Example

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/2. 架构篇：QFramework.cs/13. Architecture 的好处.md

This example showcases a more extensive initialization of QFramework Architecture, registering numerous systems, models, and a utility. It also includes a static method for setting a test mode and a call to ensure the persistent data path exists.

```csharp
using IndieGame.Models;
using IndieGame.Utility;
using QFramework;
using UnityEngine;
using UTGM;

namespace IndieGame
{
    public class LiangxiesGame : Architecture<LiangxiesGame>
    {
        public static bool IsTestMode = true;

        public static void SetTestMode(bool testMode)
        {
            IsTestMode = testMode;
        }

        protected override void Init()
        {
            RegisterSystem<ISaveSystem>(new SaveSystem());
            RegisterSystem<IInputSystem>(new InputSystem());
            RegisterSystem<ILevelSystem>(new LevelSystem());
            RegisterSystem<IBookSystem>(new BookSystem());
            RegisterSystem<IMapSystem>(new MapSystem());
            RegisterSystem<IGameTimeSystem>(new GameTimeSystem());
            RegisterSystem<IRankSystem>(new RankSystem());
            RegisterSystem<IGameSystem>(new GameSystem());
            RegisterSystem<ILuaSystem>(new LuaSystem());
            RegisterSystem<IAchievementSystem>(new AchievementSystem());
            RegisterSystem<IEnemyRecycleSystem>(new EnemyRecycleSystem());
            RegisterSystem<IUISystem>(new UISystem());
            RegisterSystem<IHurtSystem>(new HurtSystem());
            RegisterSystem<ILevelUpSystem>(new LevelUpSystem());
            RegisterSystem<ILevelConfigSystem>(new LevelConfigSystem());
        
            RegisterModel<ICoinModel>(new CoinModel());
            RegisterModel<ISettingModel>(new SettingModel());
            RegisterModel<IBookModel>(new BookModel());
            RegisterModel<IMechanismModel>(new MechanismModel());
            RegisterModel<IPlayerModel>(new PlayerModel());
            
            RegisterUtility<IStorage>(new EasySaveStorage());

            Application.persistentDataPath.CreateDirIfNotExists();
        }
    }
}

```

--------------------------------

### IOCContainer Basic Usage Example

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

Demonstrates how to register and retrieve services using QFramework's IOCContainer. This example shows registering a concrete class and an interface implementation.

```csharp
using System;
using UnityEngine;

namespace QFramework.Example
{
    public class IOCContainerExample : MonoBehaviour
    {
        
        public class SomeService
        {
            public void Say()
            {
                Debug.Log("SomeService Say Hi");
            }
        }
        
        
        public interface INetworkService
        {
            void Connect();
        }
        
        public class NetworkService : INetworkService
        {
            public void Connect()
            {
                Debug.Log("NetworkService Connect Succeed");
            }
        }

        private void Start()
        {
            var container = new IOCContainer();
            
            container.Register(new SomeService());
            
            container.Register<INetworkService>(new NetworkService());
            
            
            container.Get<SomeService>().Say();
            container.Get<INetworkService>().Connect();
        }
    }
}

// 输出结果:
// SomeService Say Hi
// NetworkService Connect Succeed
```

--------------------------------

### UniRx Integration Example

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/3. 工具篇：QFramework.Toolkits/04. ActionKit 时序动作执行系统/13. UniRx 集成.md

Demonstrates various ways to use UniRx observables with QFramework's ActionKit, including custom actions, UniRxAction, ToAction conversion, and sequential UniRx actions. Requires UniRx to be installed.

```csharp
using System;
using UniRx;
using UnityEngine;

namespace QFramework.Example
{
    public class UniRxExample : MonoBehaviour
    {
        void Start()
        {
            // 可以直接使用 Custom
            // directly use custom
            ActionKit.Custom(c =>
            {
                c.OnStart(() => { Observable.Timer(TimeSpan.FromSeconds(1.0f)).Subscribe(_ => c.Finish()); });
            }).Start(this, () => LogKit.I("1.0f"));

            // 使用 UniRxAction 不方便...
            // Use UniRxAction 
            UniRxAction<long>.Allocate(() => Observable.Timer(TimeSpan.FromSeconds(2.0f))).Start(this,()=>LogKit.I("2.0f"));


            // 使用 ToAction 方便易用
            // Use ToAction
            Observable.Timer(TimeSpan.FromSeconds(3.0f)).ToAction().Start(this, () => LogKit.I("3.0f"));

            ActionKit.Sequence()
                .UniRx(() => Observable.Timer(TimeSpan.FromSeconds(4.0f)))
                .Start(this, () => LogKit.I("4.0f"));
        }
    }
 
}
```

--------------------------------

### Create Basic Custom Action

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/3. 工具篇：QFramework.Toolkits/04. ActionKit 时序动作执行系统/09. 自定义 Custom.md

Use ActionKit.Custom to define a simple action with OnStart, OnExecute, and OnFinish callbacks. The action is started using Start(this).

```csharp
using UnityEngine;

namespace QFramework.Example
{
    public class CustomExample : MonoBehaviour
    {
        class SomeData
        {
            public int ExecuteCount = 0;
        }

        private void Start()
        {
            ActionKit.Custom(a =>
            {
                a
                    .OnStart(() => { Debug.Log("OnStart"); })
                    .OnExecute(dt =>
                    {
                        Debug.Log("OnExecute");

                        a.Finish();
                    })
                    .OnFinish(() => { Debug.Log("OnFinish"); });
            }).Start(this);
            
            // OnStart
            // OnExecute
            // OnFinish

            ActionKit.Custom<SomeData>(a =>
                {
                    a
                        .OnStart(() =>
                        {
                            a.Data = new SomeData()
                            {
                                ExecuteCount = 0
                            };
                        })
                        .OnExecute(dt =>
                        {
                            Debug.Log(a.Data.ExecuteCount);
                            a.Data.ExecuteCount++;

                            if (a.Data.ExecuteCount >= 5)
                            {
                                a.Finish();
                            }
                        }).OnFinish(() => { Debug.Log("Finished"); });
                })
                .Start(this);
            
            // 0
            // 1
            // 2
            // 3
            // 4
            // Finished

            // 还支持 Sequence、Repeat、Spawn 等
            // Also support sequence repeat spawn
            // ActionKit.Sequence()
            //     .Custom(c =>
            //     {
            //         c.OnStart(() => c.Finish());
            //     }).Start(this);
        }
    }
}
```

--------------------------------

### QFramework Architecture Example: Counter

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

This C# example demonstrates implementing a counter application following QFramework.cs architectural principles without using the QFramework.cs library directly. It defines models, commands, and UI interactions adhering to the architecture's structure.

```csharp
using System;
using System.Collections.Generic;
using UnityEngine;

namespace QFramework.Example
{
    public class ArchitectureInHeartExample : MonoBehaviour
    {

        #region Framework

        public interface ICommand
        {
            void Execute();
        }

        public class BindableProperty<T>
        {
            private T mValue = default;

            public T Value
            {
                get => mValue;
                set
                {
                    if (mValue != null && mValue.Equals(value)) return;
                    mValue = value;
                    OnValueChanged?.Invoke(mValue);
                }
            }

            public event Action<T> OnValueChanged = _ => { };
        }

        #endregion


        #region 定义 Model

        public static class CounterModel
        {
            public static BindableProperty<int> Counter = new BindableProperty<int>()
            {
                Value = 0
            };
        }
        
        #endregion

        #region 定义 Command
        public struct IncreaseCountCommand : ICommand
        {
            public void Execute()
            {
                CounterModel.Counter.Value++;
            }
        }
        
        public struct DecreaseCountCommand : ICommand
        {
            public void Execute()
            {
                CounterModel.Counter.Value--;
            }
        }
        #endregion


        private void OnGUI()
        {
            if (GUILayout.Button("+"))
            {
                new IncreaseCountCommand().Execute();
            }

            GUILayout.Label(CounterModel.Counter.Value.ToString());

            if (GUILayout.Button("-"))
            {
                new DecreaseCountCommand().Execute();
            }
        }
    }
}
```

--------------------------------

### Advanced Asynchronous Resource Loading Example

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

An in-depth example of asynchronous loading using ResLoader, including initialization, adding multiple resources with callbacks, and handling post-load actions like delayed recycling.

```csharp
using System.Collections;
using UnityEngine;

namespace QFramework.Example
{
    public class AsyncLoadExample : MonoBehaviour
    {
        IEnumerator Start()
        {
            yield return ResKit.InitAsync();

            var resLoader = ResLoader.Allocate();
            
            resLoader.Add2Load<GameObject>("AssetObj 1",(b, res) =>
            {
                if (b)
                {
                    res.Asset.As<GameObject>().Instantiate();
                }
            });

            // AssetBundleName + AssetName
            resLoader.Add2Load<GameObject>("assetobj 2_prefab","AssetObj 2",(b, res) =>
            {
                if (b)
                {
                    res.Asset.As<GameObject>().Instantiate();
                }
            });
            
            resLoader.Add2Load<GameObject>("AssetObj 3",(b, res) =>
            {
                if (b)
                {
                    res.Asset.As<GameObject>().Instantiate();
                }
            });

            resLoader.LoadAsync(() =>
            {
                // 加载成功 5 秒后回收
                ActionKit.Delay(5.0f, () =>
                {
                    resLoader.Recycle2Cache();

                }).Start(this);
            });
        }

    }
}
```

--------------------------------

### Asynchronous Initialization of ResKit

Source: https://github.com/liangxiegame/qframework/wiki/v1.0.28

Shows how to asynchronously initialize the ResKit using a coroutine or by starting an asynchronous action.

```csharp
StartCoroutine(ResKit.InitAsync());
// 或者
ResKit.InitAsync().ToAction().StartGlobal();
```

--------------------------------

### Use DictionaryPool

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/3. 工具篇：QFramework.Toolkits/09. PoolKit 对象池套件.md

Shows how to get a dictionary from the pool, add key-value pairs, and release it back.

```csharp
var infos = DictionaryPool<string,string>.Get()
infos.Add("name","liangxie");

infos.Release2Pool();
// or DictionaryPool<string,string>.Release(names);
```

--------------------------------

### MonoSingleton Implementation Example

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/3. 工具篇：QFramework.Toolkits/08. SingletonKit 单例套件/03. Mono 单例.md

Example of a GameManager inheriting from MonoSingleton. Override OnSingletonInit for initialization logic. Awake, Start, and OnDestroy are Unity lifecycle methods. Access the instance using GameManager.Instance.

```csharp
public class GameManager : MonoSingleton<GameManager>
{
    public override void OnSingletonInit()
    {
        Debug.Log(name + ":" + "OnSingletonInit");
    }

    private void Awake()
    {
        Debug.Log(name + ":" + "Awake");
    }

    private void Start()
    {
        Debug.Log(name + ":" + "Start");
    }

    protected override void OnDestroy()
    {
        base.OnDestroy();
		
        Debug.Log(name + ":" + "OnDestroy");
    }
}

var gameManager = GameManager.Instance;
// GameManager:OnSingletonInit
// GameManager:Awake
// GameManager:Start
// ---------------------
// GameManager:OnDestroy
```

--------------------------------

### Delay Example in C#

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

Demonstrates how to use ActionKit.Delay to execute a callback after a specified time in seconds. The action is started on a MonoBehaviour.

```csharp
using UnityEngine;

namespace QFramework.Example
{
    public class DelayExample : MonoBehaviour
    {
        void Start()
        {
            Debug.Log("Start Time:" + Time.time);
            
            ActionKit.Delay(1.0f, () =>
            {
                Debug.Log("End Time:" + Time.time);
                
            }).Start(this);
        }
    }
}

// 输出结果
// Start Time: 0
// End Time: 1.00781
```

--------------------------------

### Comprehensive QFramework Architecture Initialization

Source: https://github.com/liangxiegame/qframework/wiki/v1.0.28

This example demonstrates a more extensive initialization of QFramework Architecture, registering numerous Systems, Models, and Utilities. It also includes a utility for creating directories if they don't exist.

```csharp
using IndieGame.Models;
using IndieGame.Utility;
using QFramework;
using UnityEngine;
using UTGM;

namespace IndieGame
{
    public class LiangxiesGame : Architecture<LiangxiesGame>
    {
        public static bool IsTestMode = true;

        public static void SetTestMode(bool testMode)
        {
            IsTestMode = testMode;
        }

        protected override void Init()
        {
            RegisterSystem<ISaveSystem>(new SaveSystem());
            RegisterSystem<IInputSystem>(new InputSystem());
            RegisterSystem<ILevelSystem>(new LevelSystem());
            RegisterSystem<IBookSystem>(new BookSystem());
            RegisterSystem<IMapSystem>(new MapSystem());
            RegisterSystem<IGameTimeSystem>(new GameTimeSystem());
            RegisterSystem<IRankSystem>(new RankSystem());
            RegisterSystem<IGameSystem>(new GameSystem());
            RegisterSystem<ILuaSystem>(new LuaSystem());
            RegisterSystem<IAchievementSystem>(new AchievementSystem());
            RegisterSystem<IEnemyRecycleSystem>(new EnemyRecycleSystem());
            RegisterSystem<IUISystem>(new UISystem());
            RegisterSystem<IHurtSystem>(new HurtSystem());
            RegisterSystem<ILevelUpSystem>(new LevelUpSystem());
            RegisterSystem<ILevelConfigSystem>(new LevelConfigSystem());
        
            RegisterModel<ICoinModel>(new CoinModel());
            RegisterModel<ISettingModel>(new SettingModel());
            RegisterModel<IBookModel>(new BookModel());
            RegisterModel<IMechanismModel>(new MechanismModel());
            RegisterModel<IPlayerModel>(new PlayerModel());
            
            RegisterUtility<IStorage>(new EasySaveStorage());

            Application.persistentDataPath.CreateDirIfNotExists();
        }
    }
}
```

--------------------------------

### Get UI Camera in QFramework

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/4. 解决方案篇/02. UIKit：界面管理&快速开发解决方案/05. 剩下的 API.md

Retrieves the camera associated with the UIRoot. No specific setup is required beyond having a UIRoot instance.

```csharp
var uiCamera = UIKit.Root.Camera;
```

--------------------------------

### CounterApp Example with Model, Utility, and Commands

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/2. 架构篇：QFramework.cs/06. 引入 System.md

Demonstrates the basic structure of a QFramework application, including defining a Model (CounterAppModel), a Utility (Storage), registering them with an Architecture (CounterApp), and implementing Commands (IncreaseCountCommand, DecreaseCountCommand) to modify model data and trigger events.

```csharp
using UnityEngine;
using UnityEngine.UI;

namespace QFramework.Example
{
    
    // 1. 定义一个 Model 对象
    public class CounterAppModel : AbstractModel
    {
        private int mCount;

        public int Count
        {
            get => mCount;
            set
            {
                if (mCount != value)
                {
                    mCount = value;
                    PlayerPrefs.SetInt(nameof(Count),mCount);
                }
            }
        }

        protected override void OnInit()
        {
            var storage = this.GetUtility<Storage>();

            Count = storage.LoadInt(nameof(Count));

            // 可以通过 CounterApp.Interface 监听数据变更事件
            CounterApp.Interface.RegisterEvent<CountChangeEvent>(e =>
            {
                this.GetUtility<Storage>().SaveInt(nameof(Count), Count);
            });
        }
    }

    // 定义 utility 层
    public class Storage : IUtility
    {
        public void SaveInt(string key, int value)
        {
            PlayerPrefs.SetInt(key,value);
        }

        public int LoadInt(string key, int defaultValue = 0)
        {
            return PlayerPrefs.GetInt(key, defaultValue);
        }
    }


    // 2.定义一个架构（提供 MVC、分层、模块管理等）
    public class CounterApp : Architecture<CounterApp>
    {
        protected override void Init()
        {
            // 注册 Model
            this.RegisterModel(new CounterAppModel());
            
            // 注册存储工具的对象
            this.RegisterUtility(new Storage());
        }
    }
    
    // 定义数据变更事件
    public struct CountChangeEvent // ++
    {
        
    }
    
    // 引入 Command
    public class IncreaseCountCommand : AbstractCommand 
    {
        protected override void OnExecute()
        {
            this.GetModel<CounterAppModel>().Count++;
            this.SendEvent<CountChangeEvent>(); // ++
        }
    }
    
    public class DecreaseCountCommand : AbstractCommand
    {
        protected override void OnExecute()
        {
            this.GetModel<CounterAppModel>().Count--;
            this.SendEvent<CountChangeEvent>(); // ++
        }
    }

    // Controller
    public class CounterAppController : MonoBehaviour , IController /* 3.实现 IController 接口 */
    {
        // View
        private Button mBtnAdd;
        private Button mBtnSub;
        private Text mCountText;
        
        // 4. Model
        private CounterAppModel mModel;

        void Start()
        {
            // 5. 获取模型
            mModel = this.GetModel<CounterAppModel>();
            
            // View 组件获取
            mBtnAdd = transform.Find("BtnAdd").GetComponent<Button>();
            mBtnSub = transform.Find("BtnSub").GetComponent<Button>();
            mCountText = transform.Find("CountText").GetComponent<Text>();
            
            
            // 监听输入
            mBtnAdd.onClick.AddListener(() =>
            {
                // 交互逻辑
                this.SendCommand<IncreaseCountCommand>();
            });
            
            mBtnSub.onClick.AddListener(() =>
            {
                // 交互逻辑
                this.SendCommand(new DecreaseCountCommand(/* 这里可以传参（如果有） */));
            });
            
            UpdateView();
            
            // 表现逻辑
            this.RegisterEvent<CountChangeEvent>(e =>
            {
                UpdateView();

            }).UnRegisterWhenGameObjectDestroyed(gameObject);
        }
        
        void UpdateView()
        {
            mCountText.text = mModel.Count.ToString();
        }

        // 3. 
        public IArchitecture GetArchitecture()
        {
            return CounterApp.Interface;
        }

        private void OnDestroy()
        {
            // 8. 将 Model 设置为空
            mModel = null;
        }
    }
}
```

--------------------------------

### Frame Delay and Next Frame Examples in C#

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

Illustrates using ActionKit.DelayFrame to wait for a specific number of frames and ActionKit.NextFrame to execute an action on the next frame. Both are started on a MonoBehaviour.

```csharp
using UnityEngine;

namespace QFramework.Example
{
    public class DelayFrameExample : MonoBehaviour
    {
        void Start()
        {
            Debug.Log("Delay Frame Start FrameCount:" + Time.frameCount);
            
            ActionKit.DelayFrame(1, () => { Debug.Log("Delay Frame Finish FrameCount:" + Time.frameCount); })
                .Start(this);


            ActionKit.Sequence()
                .DelayFrame(10)
                .Callback(() => Debug.Log("Sequence Delay FrameCount:" + Time.frameCount))
                .Start(this);

            // ActionKit.Sequence()
            //      .NextFrame()
            //      .Start(this);

            ActionKit.NextFrame(() => { }).Start(this);
        }
    }
}

// 输出结果
// Delay Frame Start FrameCount:1
// Delay Frame Finish FrameCount:2
// Sequence Delay FrameCount:11
```

--------------------------------

### Start Action on Current Scene Change in C#

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/3. 工具篇：QFramework.Toolkits/04. ActionKit 时序动作执行系统/14. 切换场景时停止.md

Use StartCurrentScene to automatically stop and recycle Actions when the current scene changes. The example restarts the scene, demonstrating that subsequent actions after the scene reload are not executed.

```csharp
using UnityEngine;
using UnityEngine.SceneManagement;

namespace QFramework.Example
{
    public class StartCurrentSceneExample : MonoBehaviour
    {
        void Start()
        {
            ActionKit.Sequence()
                .Delay(1.0f)
                .Callback(() =>
                {
                    Debug.Log("printed");
                    SceneManager.LoadScene(SceneManager.GetActiveScene().name);
                })
                .Delay(1.0f)
                .Callback(() =>
                {
                    Debug.Log("Not print");
                })
                .StartCurrentScene();
        }
    }
}
```

--------------------------------

### UI Panel Initialization and Event Handling

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/3. 工具篇：QFramework.Toolkits/01. QFramework.Toolkits 简介.md

Demonstrates initializing a UI panel, loading a game object, and setting up an event listener for a button click. The button click triggers audio playback, UI animation, and opens another panel. Uses ResLoader for resource management and ActionKit for sequence execution.

```csharp
using QFramework;
using UnityEngine;
using UnityEngine.UI;

namespace liangxiegame
{
    public partial class UIGamePanel : UIPanel
    {
        private ResLoader mResLoader;
        
        protected override void OnInit(IUIData uiData = null)
        {
            mResLoader = ResLoader.Allocate();
            
            mResLoader.LoadSync<GameObject>("GameplayRoot")
                .Instantiate()
                .Identity()
                .GetComponent<GameplayRoot>()
                .InitGameplayRoot();
            
            
            BtnPause.onClick.AddListener(() =>
            {
                AudioKit.PlaySound("btn_click");
                
                ActionKit.Sequence()
                    .Callback(() => BtnPause.interactable = false)
                    .Callback(() => BtnPause.PlayBtnFadeAnimation())
                    .Delay(0.3f)
                    .Callback(() => UIKit.OpenPanel<UIPausePanel>())
                    .Start(this);
            });
        }

        protected override void OnClose()
        {
            mResLoader.Recycle2Cache();
            mResLoader = null;
        }
    }
}
```

--------------------------------

### UI Panel Initialization and Event Handling

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

Demonstrates initializing a UI panel, loading resources, instantiating a game object, and setting up an event listener for a button click. The button click triggers sound, animation, and opens another UI panel.

```csharp
using QFramework;
using UnityEngine;
using UnityEngine.UI;

namespace liangxiegame
{
    public partial class UIGamePanel : UIPanel
    {
        private ResLoader mResLoader;
        
        protected override void OnInit(IUIData uiData = null)
        {
            mResLoader = ResLoader.Allocate();
            
            mResLoader.LoadSync<GameObject>("GameplayRoot")
                .Instantiate()
                .Identity()
                .GetComponent<GameplayRoot>()
                .InitGameplayRoot();
            
            
            BtnPause.onClick.AddListener(() =>
            {
                AudioKit.PlaySound("btn_click");
                
                ActionKit.Sequence()
                    .Callback(() => BtnPause.interactable = false)
                    .Callback(() => BtnPause.PlayBtnFadeAnimation())
                    .Delay(0.3f)
                    .Callback(() => UIKit.OpenPanel<UIPausePanel>())
                    .Start(this);
            });
        }

        protected override void OnClose()
        {
            mResLoader.Recycle2Cache();
            mResLoader = null;
        }
    }
}
```

--------------------------------

### Start Coroutine with ActionKit

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/3. 工具篇：QFramework.Toolkits/04. ActionKit 时序动作执行系统/10. 协程 Coroutine.md

Demonstrates starting a coroutine using ActionKit.Coroutine. This requires the MonoBehaviour instance to be passed as the 'this' argument.

```csharp
using System.Collections;
using UnityEngine;

namespace QFramework.Example
{
    public class CoroutineExample : MonoBehaviour
    {
        private void Start()
        {
            ActionKit.Coroutine(SomeCoroutine).Start(this);
            
            SomeCoroutine().ToAction().Start(this);

            ActionKit.Sequence()
                .Coroutine(SomeCoroutine)
                .Start(this);
        }

        IEnumerator SomeCoroutine()
        {
            yield return new WaitForSeconds(1.0f);
            Debug.Log("Hello:" + Time.time);
        }
    }
}

// 输出结果
// Hello:1.002077
// Hello:1.002077
// Hello:1.002077
```

--------------------------------

### QFramework.Toolkits UI Panel Example

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/1. 介绍/01.简介.md

Shows a typical UI panel implementation using QFramework.Toolkits, including resource loading, UI element interaction, and animation sequencing. It utilizes ResLoader for asset management and ActionKit for sequential actions.

```csharp
using QFramework;
using UnityEngine;
using UnityEngine.UI;

namespace liangxiegame
{
    public partial class UIGamePanel : UIPanel
    {
        private ResLoader mResLoader;
        
        protected override void OnInit(IUIData uiData = null)
        {
            mResLoader = ResLoader.Allocate();
            
            mResLoader.LoadSync<GameObject>("GameplayRoot")
                .Instantiate()
                .Identity()
                .GetComponent<GameplayRoot>()
                .InitGameplayRoot();
            
            
            BtnPause.onClick.AddListener(() =>
            {
                AudioKit.PlaySound("btn_click");
                
                ActionKit.Sequence()
                    .Callback(() => BtnPause.interactable = false)
                    .Callback(() => BtnPause.PlayBtnFadeAnimation())
                    .Delay(0.3f)
                    .Callback(() => UIKit.OpenPanel<UIPausePanel>()) // Corrected closing parenthesis
                    .Start(this);
            });
        }

        protected override void OnClose()
        {
            mResLoader.Recycle2Cache();
            mResLoader = null;
        }
    }
}
```

--------------------------------

### IOCContainer Register and Get Instance

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework API.md

Register an instance of a type T with the IOC container. Retrieve an instance of T using the Get<T>() method.

```csharp
public void Register<T>(T instance)
{
    // Implementation omitted for brevity
}
```

```csharp
public T Get<T>() where T : class
{
    // Implementation omitted for brevity
}
```

--------------------------------

### ResKit Asset Loading Example

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

Shows how to initialize ResKit and load GameObjects using both asset name and asset bundle name. Ensure ResKit is initialized before loading assets.

```csharp
using UnityEngine;

namespace QFramework.Example
{
    public class ResKitExample : MonoBehaviour
    {
        // 每个脚本都需要
        private ResLoader mResLoader = ResLoader.Allocate();

        private void Start()
        {
            // 项目启动只调用一次即可
            ResKit.Init();
            
            // 通过资源名 + 类型搜索并加载资源（更方便）
            var prefab = mResLoader.LoadSync<GameObject>("AssetObj");
            var gameObj = Instantiate(prefab);
            gameObj.name = "这是使用通过 AssetName 加载的对象";

            // 通过 AssetBundleName 和 资源名搜索并加载资源（更精确）
            prefab = mResLoader.LoadSync<GameObject>("assetobj_prefab", "AssetObj");
            gameObj = Instantiate(prefab);
            gameObj.name = "这是使用通过 AssetName  和 AssetBundle 加载的对象";
        }

        private void OnDestroy()
        {
            // 释放所有本脚本加载过的资源
            // 释放只是释放资源的引用
            // 当资源的引用数量为 0 时，会进行真正的资源卸载操作
            mResLoader.Recycle2Cache();
            mResLoader = null;
        }
    }
}
```

--------------------------------

### Delay Frame Action in QFramework

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/3. 工具篇：QFramework.Toolkits/04. ActionKit 时序动作执行系统/04. 帧延时 DelayFrame.md

Use ActionKit.DelayFrame to execute a callback after a specified number of frames. The action is started using 'Start(this)'.

```csharp
using UnityEngine;

namespace QFramework.Example
{
    public class DelayFrameExample : MonoBehaviour
    {
        void Start()
        {
            Debug.Log("Delay Frame Start FrameCount:" + Time.frameCount);
            
            ActionKit.DelayFrame(1, () => { Debug.Log("Delay Frame Finish FrameCount:" + Time.frameCount); })
                .Start(this);


            ActionKit.Sequence()
                .DelayFrame(10)
                .Callback(() => Debug.Log("Sequence Delay FrameCount:" + Time.frameCount))
                .Start(this);

            // ActionKit.Sequence()
            //      .NextFrame()
            //      .Start(this);

            ActionKit.NextFrame(() => { }).Start(this);
        }
    }
}
```

--------------------------------

### Open Panel Examples

Source: https://github.com/liangxiegame/qframework/wiki/v1.0.28

Demonstrates practical usage of UIKit.OpenPanel with different parameters, including specifying UI level, passing initial data, and loading from a specific prefab name.

```csharp
// 在 Forward 层级打开
UIKit.OpenPanel<UIBasicPanel>(UILevel.Forward);
```

```csharp
// 传递初始数据给 UIHomePanel
UIKit.OpenPanel<UIBasicPanel>(new UIHomePanelData()
{
    Coin = 10
});
```

```csharp
// 从 UIHomePanelTest.prefab 加载界面 
UIKit.OpenPanel<UIBasicPanel>(prefabName: "UIBasicPanel");
```

--------------------------------

### DynaGrid Output Example

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/3. 工具篇：QFramework.Toolkits/14. 补充内容：动态二维格子数据结构 DynaGrid（GridKit）.md

Illustrates the expected output when iterating through the DynaGrid populated in the example. This shows the coordinates and associated data keys.

```text
// 1 1 Hero
// -1 -10 Enemy
```

--------------------------------

### QFramework Screen Transitions

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

Demonstrates how to use QFramework's ActionKit for various screen transitions like FadeIn, FadeOut, and FadeInOut. Includes examples with custom colors and durations.

```csharp
using UnityEngine;

namespace QFramework.Example
{
    public class ScreenTransitionsExample : MonoBehaviour
    {
        private void OnGUI()
        {
            IMGUIHelper.SetDesignResolution(640,360);
            
            if (GUILayout.Button("FadeIn"))
            {
                ActionKit.ScreenTransition
                    .FadeIn()
                    .Start(this);
            }
            
            if (GUILayout.Button("FadeOut"))
            {
                ActionKit.ScreenTransition
                    .FadeOut()
                    .Start(this);
            }
            
            if (GUILayout.Button("FadeInOut"))
            {
                ActionKit.ScreenTransition
                    .FadeInOut()
                    .OnInFinish(() =>
                    {
                        Debug.Log("load scene here");
                    })
                    .Start(this);
            }
            
            if (GUILayout.Button("FadeIn White"))
            {
                ActionKit.ScreenTransition
                    .FadeIn()
                    .Color(Color.white)
                    .Start(this);
            }
            
            if (GUILayout.Button("FadeOut Red"))
            {
                ActionKit.ScreenTransition
                    .FadeOut()
                    .Color(Color.red)
                    .Start(this);
            }
            
            if (GUILayout.Button("FadeInOut 0.5s in green out blue"))
            {
                ActionKit.ScreenTransition
                    .FadeInOut()
                    .In(fadeIn=>fadeIn
                        .Duration(0.5f)
                        .Color(Color.green))
                    .Out(fadeOut=>fadeOut.Duration(0.5f)
                        .Color(Color.blue))
                    .Start(this);
            }
        }
    }
}
```

--------------------------------

### Integrate Coroutine with ActionKit

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

Shows how to start a Unity coroutine using ActionKit.Coroutine and convert a coroutine to an action using .ToAction(). Both methods are started with a MonoBehaviour.

```csharp
using System.Collections;
using UnityEngine;

namespace QFramework.Example
{
    public class CoroutineExample : MonoBehaviour
    {
        private void Start()
        {
            ActionKit.Coroutine(SomeCoroutine).Start(this);
            
            SomeCoroutine().ToAction().Start(this);

            ActionKit.Sequence()
                .Coroutine(SomeCoroutine)
                .Start(this);
        }

        IEnumerator SomeCoroutine()
        {
            yield return new WaitForSeconds(1.0f);
            Debug.Log("Hello:" + Time.time);
        }
    }
}

// 输出结果
// Hello:1.002077
// Hello:1.002077
// Hello:1.002077

```

--------------------------------

### UI Panel Script Example

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/4. 解决方案篇/02. UIKit：界面管理&快速开发解决方案/01. 简介与快速入门.md

This script demonstrates how to initialize a UI panel and add a listener to a button. Ensure the UI Kit code generation is complete before implementing this.

```csharp
using UnityEngine;
using UnityEngine.UI;
using QFramework;

namespace QFramework.Example
{
	public class UIBasicPanelData : UIPanelData
	{
	}
	public partial class UIBasicPanel : UIPanel
	{
		protected override void OnInit(IUIData uiData = null)
		{
			mData = uiData as UIBasicPanelData ?? new UIBasicPanelData();
			
			BtnStart.onClick.AddListener(() =>
			{
				Debug.Log("开始游戏");
			});
		}
		
		protected override void OnOpen(IUIData uiData = null)
		{
		}
		
		protected override void OnShow()
		{
		}
		
		protected override void OnHide()
		{
		}
		
		protected override void OnClose()
		{
		}
	}
}
```

--------------------------------

### QFramework UI Panel Example

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

Shows a typical UI panel implementation using QFramework's toolkits, including resource loading, event handling, and animation sequencing. Use this for creating and managing UI elements.

```csharp
using QFramework;
using UnityEngine;
using UnityEngine.UI;

namespace liangxiegame
{
    public partial class UIGamePanel : UIPanel
    {
        private ResLoader mResLoader;
        
        protected override void OnInit(IUIData uiData = null)
        {
            mResLoader = ResLoader.Allocate();
            
            mResLoader.LoadSync<GameObject>("GameplayRoot")
                .Instantiate()
                .Identity()
                .GetComponent<GameplayRoot>()
                .InitGameplayRoot();
            
            
            BtnPause.onClick.AddListener(() =>
            {
                AudioKit.PlaySound("btn_click");
                
                ActionKit.Sequence()
                    .Callback(() => BtnPause.interactable = false)
                    .Callback(() => BtnPause.PlayBtnFadeAnimation())
                    .Delay(0.3f)
                    .Callback(() => UIKit.OpenPanel<UIPausePanel>())
                    .Start(this);
            });
        }

        protected override void OnClose()
        {
            mResLoader.Recycle2Cache();
            mResLoader = null;
        }
    }
}   }}
```

--------------------------------

### Initialize and Use SimpleObjectPool

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/3. 工具篇：QFramework.Toolkits/09. PoolKit 对象池套件.md

Demonstrates creating a SimpleObjectPool for a custom class, allocating and recycling objects, and checking the current count. Also shows initialization for GameObjects with custom creation and reset logic.

```csharp
class Fish
{
             
}

var pool = new SimpleObjectPool<Fish>(() => new Fish(),initCount:50);
 
Debug.Log(pool.CurCount);
// 50 
var fish = pool.Allocate();
 
Debug.Log(pool.CurCount);
// 49
pool.Recycle(fish);

Debug.Log(pool.CurCount);
// 50


// ---- GameObject ----
var gameObjPool = new SimpleObjectPool<GameObject>(() =>
{
    var gameObj = new GameObject("AGameObject");
    // init gameObj code 

    // gameObjPrefab = Resources.Load<GameObject>("somePath/someGameObj");
                
    return gameObj;
}, (gameObj) =>
{
    // reset code here
});
```

--------------------------------

### ISystem Interface Definition

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/2. 架构篇：QFramework.cs/10. 架构规范 与 推荐用法.md

Defines the ISystem interface for the System layer. Systems can get models and utilities, register and send events, and get other systems. They also have an initialization method.

```csharp
#region System

public interface ISystem : IBelongToArchitecture, ICanSetArchitecture, ICanGetModel, ICanGetUtility,ICanRegisterEvent, ICanSendEvent, ICanGetSystem
{
    void Init();
}

```

--------------------------------

### Unity C# Sequence with Callbacks and Delays

Source: https://github.com/liangxiegame/qframework/blob/master/QFramework.Unity2018+/Assets/QFramework/Toolkits/_CoreKit/Internal/Guidline/Editor/Resources/EditorGuideline/3. 工具篇：QFramework.Toolkits/04. ActionKit 时序动作执行系统/03. 序列 Sequence.md

Use ActionKit.Sequence to chain actions like callbacks and delays. The sequence is started with 'Start(this, ...)' which requires a MonoBehaviour context and a completion callback.

```csharp
using UnityEngine;

namespace QFramework.Example
{
    public class SequenceAndCallback : MonoBehaviour
    {
        void Start()
        {
            Debug.Log("Sequence Start:" + Time.time);

            ActionKit.Sequence()
                .Callback(() => Debug.Log("Delay Start:" + Time.time))
                .Delay(1.0f)
                .Callback(() => Debug.Log("Delay Finish:" + Time.time))
                .Start(this, _ => { Debug.Log("Sequence Finish:" + Time.time); });
        }
    }
}
```

--------------------------------

### ISystem Interface Definition

Source: https://github.com/liangxiegame/qframework/blob/master/Doc.md

Defines the ISystem interface for the System layer. It includes methods for initialization and capabilities for setting the architecture, getting models and systems, registering and sending events, and getting utilities.

```csharp
#region System

public interface ISystem : IBelongToArchitecture, ICanSetArchitecture, ICanGetModel, ICanGetUtility,ICanRegisterEvent, ICanSendEvent, ICanGetSystem
{
    void Init();
}

```