QFramework

https://qf.readthedocs.io/zh-cn/latest/
Admin
QFramework is a game development framework for Unity that provides a comprehensive architecture...
Tokens:54,102
Snippets:270
Trust Score:8.3
Update:11 months ago
Show doc for...
Tokens:
Raw
### Unity MonoBehaviour Singleton - GameManager Example

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/09_singletonkit

Provides a basic MonoBehaviour singleton implementation for GameManager using MonoSingleton<T>. It demonstrates overriding OnSingletonInit, Awake, Start, and OnDestroy methods to log lifecycle events.

```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
```

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

### Examples of Using UIKit.OpenPanel in C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/06_uikit

Provides practical examples of calling the UIKit.OpenPanel method with different arguments. These examples illustrate how to specify UI level, pass initial data, and load panels using a specific prefab name.

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

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

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

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

### Asynchronous Initialization for WebGL in C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/05_reskit

Provides examples of how to asynchronously initialize the ResKit on WebGL platforms. This is crucial for handling asset loading efficiently in a web environment.

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

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

### Unity MonoBehaviour Singleton - AudioManager Example

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/09_singletonkit

Implements a MonoBehaviour-based singleton for AudioManager in Unity. It utilizes QMonoSingletonProperty for instance management and provides methods for playing and stopping sounds. The OnSingletonInit method is called upon initialization.

```csharp
namespace QFramework.Example
{
    [MonoSingletonPath("[Audio]/AudioManager")]
    public class AudioManager : ManagerBase,ISingleton
    {
        public static AudioManager Instance
        {
            get { return QMonoSingletonProperty<AudioManager>.Instance; }
        }

        public void OnSingletonInit()
        {

        }

        public void Dispose()
        {
            QMonoSingletonProperty<AudioManager>.Dispose();
        }


        public void PlaySound(string soundName)
        {

        }

        public void StopSound(string soundName)
        {

        }
    }
}
```

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

### C# Singleton - GameDataManager Example

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/09_singletonkit

Demonstrates a non-MonoBehaviour C# singleton implementation for GameDataManager. It uses a base Singleton class and overrides OnSingletonInit for initialization logic. The example shows how to log messages with an incrementing index.

```csharp
public class GameDataManager : Singleton<GameDataManager>
{
    private static int mIndex = 0;

    private Class2Singleton() {}

    public override void OnSingletonInit()
    {
        mIndex++;
    }

    public void Log(string content)
    {
        Debug.Log(""GameDataManager"" + mIndex + ":" + content);
    }
}

GameDataManager.Instance.Log("Hello");
// GameDataManager1:OnSingletonInit:Hello
GameDataManager.Instance.Log("Hello");
// GameDataManager1:OnSingletonInit:Hello
GameDataManager.Instance.Dispose();
```

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

### QFramework.cs Example: CounterAppController

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/01_introduction/01_introduction

This C# code snippet demonstrates a typical controller implementation within the QFramework.cs architecture, specifically for a CounterApp. It shows how to get models, find UI components, handle button clicks by sending commands, and update the view based on model changes. It adheres to the IController interface and unregisters listeners when the GameObject is destroyed.

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

        // Modelprivate 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()
        {


```

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

### C# Custom Panel Loader Implementation Example

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/06_uikit

This C# code provides an example of a custom panel loader for QFramework's UIKit. It shows how to inherit from AbstractPanelLoaderPool and implement IPanelLoader to define custom loading logic, such as loading prefabs from Resources.

```csharp
using System;
using UnityEngine;

namespace QFramework.Example
{
    public class CustomPanelLoaderExample : MonoBehaviour
    {
        public class ResourcesPanelLoaderPool : AbstractPanelLoaderPool
        {
            /// <summary>
            /// Load Panel from Resources
            /// </summary>
            public class ResourcesPanelLoader : IPanelLoader
            {
                private GameObject mPanelPrefab;

                public GameObject LoadPanelPrefab(PanelSearchKeys panelSearchKeys)
                {
                    mPanelPrefab = Resources.Load<GameObject>(panelSearchKeys.GameObjName);
                    return mPanelPrefab;
                }

                public void LoadPanelPrefabAsync(PanelSearchKeys panelSearchKeys, Action<GameObject> onPanelLoad)
                {
                    var request = Resources.LoadAsync<GameObject>(panelSearchKeys.GameObjName);

                    request.completed += operation => { onPanelLoad(request.asset as GameObject); };
                }

                public void Unload()
                {
                    mPanelPrefab = null;
                }
            }

            protected override IPanelLoader CreatePanelLoader()
            {
                return new ResourcesPanelLoader();
            }
        }

        void Start()
        {
            // 游戏启动时，设置一次
            UIKit.Config.PanelLoaderPool = new ResourcesPanelLoaderPool();
        }
    }
}
```

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

### Chained State Pattern Example using FSMKit in C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/10_fsmkit

Demonstrates the chained API for creating and managing states in FSMKit. Suitable for rapid development or when states are few. It defines states, transitions, and lifecycle methods like OnEnter, OnUpdate, and OnGUI.

```csharp
using UnityEngine;

namespace QFramework.Example
{
    public class IStateBasicUsageExample : MonoBehaviour
    {
        public enum States
        {
            A,
            B
        }

        public FSM<States> FSM = new FSM<States>();

        void Start()
        {
            FSM.State(States.A)
                .OnCondition(()=>FSM.CurrentStateId == States.B)
                .OnEnter(() =>
                {
                    Debug.Log("Enter A");
                })
                .OnUpdate(() =>
                {

                })
                .OnFixedUpdate(() =>
                {

                })
                .OnGUI(() =>
                {
                    GUILayout.Label("State A");
                    if (GUILayout.Button("To State B"))
                    {
                        FSM.ChangeState(States.B);
                    }
                })
                .OnExit(() =>
                {
                    Debug.Log("Enter B");

                });

            FSM.State(States.B)
                .OnCondition(() => FSM.CurrentStateId == States.A)
                .OnGUI(() =>
                {
                    GUILayout.Label("State B");
                    if (GUILayout.Button("To State A"))
                    {
                        FSM.ChangeState(States.A);
                    }
                });

            FSM.StartState(States.A);
        }

        private void Update()
        {
            FSM.Update();
        }

        private void FixedUpdate()
        {
            FSM.FixedUpdate();
        }

        private void OnGUI()
        {
            FSM.OnGUI();
        }

        private void OnDestroy()
        {
            FSM.Clear();
        }
    }
}

```

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

### Unity C# QFramework MVC 计数器完整控制器代码

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/02_qf_mvc

集成 QFramework 框架的 Unity C# 计数器控制器完整代码。包含了命名空间、UI 组件声明、Model 变量以及 `Start` 和 `UpdateView` 方法，展示了 MVC 架构的初步实现。

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

namespace QFramework.Example
{
    // Controllerpublic class CounterAppController : MonoBehaviour
    {
        // Viewprivate Button mBtnAdd;
        private Button mBtnSub;
        private Text mCountText;

        // Modelprivate int mCount = 0;

        void Start()
        {
            // View 组件获取
            mBtnAdd = transform.Find("BtnAdd").GetComponent<Button>();
            mBtnSub = transform.Find("BtnSub").GetComponent<Button>();
            mCountText = transform.Find("CountText").GetComponent<Text>();


            // 监听输入
            mBtnAdd.onClick.AddListener(() =>
            {
                // 交互逻辑
                mCount++;
                // 表现逻辑
                UpdateView();        
            });

            mBtnSub.onClick.AddListener(() =>
            {
                // 交互逻辑
                mCount--;
                // 表现逻辑
                UpdateView();
            });

            UpdateView();
        }

        void UpdateView()
        {
            mCountText.text = mCount.ToString();
        }
    }
}


```

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

### Unity MonoBehaviour Property Singleton - GameManager Example

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/09_singletonkit

Implements a MonoBehaviour singleton using MonoSingletonProperty<T> for GameManager. This pattern allows accessing the singleton instance via a static property. It also logs lifecycle events like OnSingletonInit, Awake, Start, and OnDestroy.

```csharp
public class GameManager : MonoBehaviour,ISingleton
{
    public static GameManager Instance
    {
        get { return MonoSingletonProperty<GameManager>.Instance; }
    }

    public void Dispose()
    {
        MonoSingletonProperty<GameManager>.Dispose();
    }

    public void OnSingletonInit()
    {
        Debug.Log(name + ":" + "OnSingletonInit");
    }

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

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

    protected void OnDestroy()
    {
        Debug.Log(name + ":" + "OnDestroy");
    }
}
var gameManager = GameManager.Instance;
// GameManager:OnSingletonInit
// GameManager:Awake
// GameManager:Start
// ---------------------
// GameManager:OnDestroy
```

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

### Custom Resource Loading in Unity with QFramework

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/05_reskit

Illustrates how to implement custom resource loading in Unity using QFramework's ResKit. This involves defining a custom `Res` class for loading logic and a `ResCreator` class to identify and instantiate the custom resource. The example shows how to add the custom creator and load a resource synchronously.

```csharp
using UnityEngine;

namespace QFramework
{
    public class CustomResExample : MonoBehaviour
    {
        // 自定义的 Respublic class MyRes : Res
        {
            public MyRes(string name)
            {
                mAssetName = name;
            }

            // 同步加载（自己实现）public override bool LoadSync()
            {
                // Asset = 加载的结果给 Asset 赋值 
                State = ResState.Ready;
                return true;
            }

            // 异步加载(自己实现)public override void LoadAsync()
            {
                // Asset = 加载的结果给 Asset 赋值 
                State = ResState.Ready;
            }


            // 释放资源（自己实现)protected override void OnReleaseRes()
            {
                // 卸载操作// Asset = null
                State = ResState.Waiting;
            }
        }

        // 自定义的 Res 创建器（包含识别功能）public class MyResCreator : IResCreator
        {
            // 识别public bool Match(ResSearchKeys resSearchKeys)
            {
                return resSearchKeys.AssetName.StartsWith("myres://");
            }

            // 创建public IRes Create(ResSearchKeys resSearchKeys)
            {
                return new MyRes(resSearchKeys.AssetName);
            }
        }

        void Start()
        {
            // 添加创建器
            ResFactory.AddResCreator<MyResCreator>();

            var resLoader = ResLoader.Allocate();

            var resSearchKeys = ResSearchKeys.Allocate("myres://hello_world");

            var myRes =  resLoader.LoadResSync(resSearchKeys);

            resSearchKeys.Recycle2Cache();

            Debug.Log(myRes.AssetName);
            Debug.Log(myRes.State);
        }
    }
}

```

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

### C# Property Singleton - GameDataManager Example

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/09_singletonkit

Demonstrates a C# property-based singleton for GameDataManager using SingletonProperty<T>. This non-MonoBehaviour approach provides a static Instance property for access and includes initialization and disposal methods.

```csharp
public class GameDataManager : ISingleton
{
  public static GameDataManager Instance
  {
      get { return SingletonProperty<GameDataManager>.Instance; }
  }

  private GameDataManager() {}

  private static int mIndex = 0;

  public void OnSingletonInit()
  {
      mIndex++;
  }

  public void Dispose()
  {
      SingletonProperty<GameDataManager>.Dispose();
  }

  public void Log(string content)
  {
      Debug.Log(""GameDataManager"" + mIndex + ":" + content);
  }
}


GameDataManager.Instance.Log(“”Hello””); // GameDataManager1:OnSingletonInit:Hello
GameDataManager.Instance.Log(“”Hello””); // GameDataManager1:OnSingletonInit:Hello
GameDataManager.Instance.Dispose();
```

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

### Class-Based State Pattern Example using FSMKit in C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/10_fsmkit

Illustrates the class-based approach for FSMKit, recommended for scenarios with numerous states or substantial state logic. It involves defining separate classes for each state, inheriting from AbstractState.

```csharp
using UnityEngine;

namespace QFramework.Example
{
    public class IStateClassExample : MonoBehaviour
    {

        public enum States
        {
            A,
            B,
            C
        }

        public FSM<States> FSM = new FSM<States>();

        public class StateA : AbstractState<States,IStateClassExample>
        {
            public StateA(FSM<States> fsm, IStateClassExample target) : base(fsm, target)
            {
            }

            protected override bool OnCondition()
            {
                return mFSM.CurrentStateId == States.B;
            }

            public override void OnGUI()
            {
                GUILayout.Label("State A");

                if (GUILayout.Button("To State B"))
                {
                    mFSM.ChangeState(States.B);
                }
            }
        }


        public class StateB: AbstractState<States,IStateClassExample>
        {
            public StateB(FSM<States> fsm, IStateClassExample target) : base(fsm, target)
            {
            }

            protected override bool OnCondition()
            {
                return mFSM.CurrentStateId == States.A;
            }

            public override void OnGUI()
            {
                GUILayout.Label("State B");

                if (GUILayout.Button("To State A"))
                {
                    mFSM.ChangeState(States.A);
                }
            }
        }

        private void Start()
        {
            FSM.AddState(States.A, new StateA(FSM, this));
            FSM.AddState(States.B, new StateB(FSM, this));

            // 支持和链式模式混用
            // FSM.State(States.C)
            //     .OnEnter(() =>
            //     {
            //
            //     });

            FSM.StartState(States.A);
        }

        private void OnGUI()
        {
            FSM.OnGUI();
        }

        private void OnDestroy()
        {
            FSM.Clear();
        }
    }
}

```

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

### C# UIElement Script Example

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/06_uikit

This C# script demonstrates the basic structure of a UIElement in QFramework, inheriting from UIElement and defining methods like Awake and OnBeforeDestroy. It's part of a generated UI panel structure.

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

namespace QFramework.Example
{
    public partial class SubPanel1 : UIElement    {
        private void Awake()
        {
        }
        protected override void OnBeforeDestroy()
        {
        }
    }
}
```

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

### UIPanel Lifecycle Methods in C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/06_uikit

Defines the standard lifecycle methods for a UIPanel in QFramework: OnInit, OnOpen, OnShow, OnHide, and OnClose. It explains when each method is called during panel operations like opening, hiding, and closing, with OnInit for initial setup and OnClose for cleanup.

```csharp
namespace QFramework.Example
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using UnityEngine;
    using UnityEngine.UI;


    public class UIBasicPanelData : QFramework.UIPanelData
    {
    }

    public partial class UIBasicPanel : QFramework.UIPanel
    {
        protected override void OnInit(QFramework.IUIData uiData)
        {
            mData = uiData as UIHomePanelData ?? new UIHomePanelData();
            // please add init code here


        }

        protected override void OnOpen(QFramework.IUIData uiData)
        {
        }

        protected override void OnShow()
        {

        }

        protected override void OnHide()
        {
        }

        protected override void OnClose()
        {
        }
    }
}
```

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

### Implement a Query to Get School's Total Person Count in C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/09_use_query

This C# code demonstrates how to implement a Query in QFramework to calculate the total number of people in a school by summing the counts from StudentModel and TeacherModel. It shows the definition of models, the architecture, the query class, and how to trigger the query within a UI button click.

```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;
        }
    }
}

```

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

### UI Panel Initialization and Event Handling in C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/01_introduction/01_introduction

Demonstrates initializing a UI panel, loading game resources, and setting up button click listeners for game interactions like sound playback, animations, and opening other UI panels. It uses QFramework's UI and Action kits for efficient management.

```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;
        }
    }
}
```

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

### QFramework CounterAppModel 数据管理 (C#)

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/06_use_system

CounterAppModel 用于管理计数器的状态。它包含了 Count 属性，并通过 PlayerPrefs 进行持久化存储。OnInit 方法负责加载初始值，并注册数据变更事件。

```csharp
public class CounterAppModel : AbstractModel
{
    private int mCount;

    public int Count
    {
        get { return 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);
        });
    }
}
```

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

### 定义 Model、Utility 和 Architecture - C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/06_use_system

定义 CounterAppModel 数据模型、Storage 工具类和 CounterApp 架构。Model 管理计数状态并通过 PlayerPrefs 持久化存储，Utility 提供数据存储接口，Architecture 负责注册和管理 Model 和 Utility。

```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.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());
        }
    }
}
```

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

### AudioKit Audio Settings Toggles

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/07_audiokit

Provides examples for controlling the enable/disable states for background music, sound effects, and voice playback using AudioKit's settings.

```csharp
btnSoundOn.onClick.AddListener(() => { AudioKit.Settings.IsSoundOn.Value = true; });

btnSoundOff.onClick.AddListener(() => { AudioKit.Settings.IsSoundOn.Value = false; });

btnMusicOn.onClick.AddListener(() => { AudioKit.Settings.IsMusicOn.Value = true; });

btnMusicOff.onClick.AddListener(() => { AudioKit.Settings.IsMusicOn.Value = false; });

btnVoiceOn.onClick.AddListener(() => { AudioKit.Settings.IsVoiceOn.Value = true; });

btnVoiceOff.onClick.AddListener(() => { AudioKit.Settings.IsVoiceOn.Value = false; });
```

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

### QFramework System 接口定义 (C#)

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/10_architecture_spec_and_recommended_usage

定义了 QFramework 系统层（System）的接口。ISystem 继承自 IBelongToArchitecture，并提供了设置架构、获取模型和工具、注册和发送事件以及获取系统的能力。系统层用于处理跨多个表现层共享的逻辑。

```csharp
#region System
public interface ISystem : IBelongToArchitecture, ICanSetArchitecture, ICanGetModel, ICanGetUtility,ICanRegisterEvent, ICanSendEvent, ICanGetSystem
{
    void Init();
}


```

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

### Unity MonoSingletonPath Attribute Usage

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/09_singletonkit

Shows how to use the [MonoSingletonPath] attribute to specify a custom path for a MonoBehaviour singleton within the Unity hierarchy. This example defines a class `ClassUseMonoSingletonPath` and demonstrates accessing its instance.

```csharp
namespace QFramework.Example
{
    using UnityEngine;

    [MonoSingletonPath("[Example]/MonoSingeltonPath")]
    class ClassUseMonoSingletonPath : QMonoSingleton<ClassUseMonoSingletonPath>
    {

    }

    public class MonoSingletonPath : MonoBehaviour
    {
        private void Start()
        {
            var intance = ClassUseMonoSingletonPath.Instance;
        }
    }
}
```

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

### QFramework CounterApp 架构实现 (C#)

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/06_use_system

定义了 QFramework 应用程序的架构，包括注册系统、模型和工具。此代码展示了如何初始化和配置应用程序的核心组件。

```csharp
public class CounterApp : Architecture<CounterApp>
{
    protected override void Init()
    {
        // 注册 System 
        this.RegisterSystem(new AchievementSystem()); // +

        // 注册 Model
        this.RegisterModel(new CounterAppModel());

        // 注册存储工具的对象
        this.RegisterUtility(new Storage());
    }
}
```

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

### QFramework Query 接口定义 (C#)

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/10_architecture_spec_and_recommended_usage

定义了 QFramework 查询（Query）的接口。IQuery<TResult> 继承自 IBelongToArchitecture，并提供了设置架构、获取模型、系统以及发送查询的能力。查询负责数据的检索。

```csharp
public interface IQuery<TResult> : IBelongToArchitecture, ICanSetArchitecture, ICanGetModel, ICanGetSystem,ICanSendQuery
{
    TResult Do();
}


```

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

### 加载 Resources 目录资源 - QFramework C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/05_reskit

从 Unity 项目的 Resources 目录中加载资源，如纹理贴图。使用 ResLoader 的 LoadSync 方法以 "resources://" 协议前缀加载资源，无需调用 ResKit.Init()。资源使用完毕后需调用 Recycle2Cache() 进行释放。

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

namespace QFramework.Example
{
    public class LoadResourcesResExample : MonoBehaviour
    {
        public RawImage RawImage;

        private ResLoader mResLoader = ResLoader.Allocate();

        private void Start()
        {
            //  加载 Resources 目录里的资源不用调用 ResKit.Init

            RawImage.texture = mResLoader.LoadSync<Texture2D>("resources://TestTexture");
        }

        private void OnDestroy()
        {
            Debug.Log("On Destroy ");
            mResLoader.Recycle2Cache();
            mResLoader = null;
        }
    }
}
```

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

### Asynchronous Panel Loading in C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/06_uikit

Illustrates how to asynchronously load UI panels using Coroutines or the OpenPanelAsync method, which returns an object that can be started. This is particularly useful on platforms like WebGL where AssetBundle loading is asynchronous.

```csharp
StartCoroutine(UIKit.OpenPanelAsync<UIHomePanel>());
// 或者
UIKit.OpenPanelAsync<UIHomePanel>().ToAction().Start(this);
```

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

### QFramework AchievementSystem 成就逻辑 (C#)

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/06_use_system

AchievementSystem 负责监听计数变化，并根据计数器的值触发不同的成就。当计数达到特定值时，会打印日志提示成就触发。

```csharp
public class AchievementSystem : AbstractSystem // +
{
    protected override void OnInit()
    {
        var model = this.GetModel<CounterAppModel>();

        this.RegisterEvent<CountChangeEvent>(e =>
        {
            if (model.Count == 10)
            {
                Debug.Log("触发 点击达人 成就");
            }
            else if (model.Count == 20)
            {
                Debug.Log("触发 点击专家 成就");
            } else if (model.Count == -10)
            {
                Debug.Log("触发 点击菜鸟 成就");
            }
        });
    }
}
```

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

### Unity PersistentMonoSingleton Behavior

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/09_singletonkit

Illustrates the behavior of PersistentMonoSingleton<T> in Unity. When multiple instances exist, it ensures only the first one persists across scene loads or GameObject instantiations. The example shows how to access the instance and verifies its persistence.

```csharp
public class GameManager : PersistentMonoSingleton<GameManager>
{

}

IEnumerator Start()
{
    var gameManager = GameManager.Instance;

    var newGameManager = new GameObject().AddComponent<GameManager>();

    yield return new WaitForEndOfFrame();

    Debug.Log(FindObjectOfTypes<GameManager>().Length);
    // 1
    Debug.Log(gameManager == null);
    // false
    Debug.Log(newGameManager == null);
    // true
}
```

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

### QFramework Utility 接口定义 (C#)

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/10_architecture_spec_and_recommended_usage

定义了 QFramework 工具层（Utility）的接口。IUtility 接口作为工具层的基础，负责提供基础设施服务，如存储、序列化、网络连接等，可以集成第三方库或封装 API。

```csharp
#region Utility
public interface IUtility
{
}

#endregion
```

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

### C# UILoginView.Designer.cs Script Example

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/06_uikit

This C# script, typically a designer file (UILoginView.Designer.cs), shows how UI elements like buttons are serialized and managed within a QFramework UI panel. It includes fields for UI components and methods for clearing them.

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

namespace QFramework.Example
{
    public partial class SubPanel1    {
        [SerializeField] public UnityEngine.UI.Button BtnStart2;
        [SerializeField] public UnityEngine.UI.Button BtnStart3;
        public void Clear()
        {
            BtnStart2 = null;
            BtnStart3 = null;
        }
        public override string ComponentName
        {
            get { return "SubPanel1";}
        }
    }
}
```

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

### Registering Modules in QFramework using C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/08_dependency_inversion_principle

This C# pseudocode demonstrates how to define an architecture and register various systems, models, and utilities within the QFramework framework. It shows how to register an AchievementSystem, CounterAppModel, and EasySaveStorage, illustrating the ease of switching storage solutions.

```csharp
    // 定义一个架构（用于管理模块）
    public class CounterApp : Architecture<CounterApp>
    {
        protected override void Init()
        {
            // 注册成就系统
            this.RegisterSystem<IAchievementSystem>(new AchievementSystem());

            this.RegisterModel<ICounterAppModel>(new CounterAppModel());

            // 注册存储工具对象
            // this.RegisterUtility<IStorage>(new Storage());
            this.RegisterUtility<IStorage>(new EasySaveStorage());
        }
    }

```

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

### C# Opening Multiple Panel Instances Example

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/06_uikit

This C# code snippet demonstrates how to open multiple instances of the same UI panel (UIMultiPanel) using QFramework's UIKit API, specifying a custom data object and allowing multiple instances.

```csharp
UIKit.OpenPanel<UIMultiPanel>(new UIMultiPanelData(), PanelOpenType.Multiple);
```

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

### QFramework Model 接口定义 (C#)

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/10_architecture_spec_and_recommended_usage

定义了 QFramework 数据层（Model）的接口。IModel 继承自 IBelongToArchitecture，并提供了设置架构、获取工具以及发送事件的能力。数据层负责数据的定义和数据操作方法的提供。

```csharp
public interface IModel : IBelongToArchitecture, ICanSetArchitecture, ICanGetUtility, ICanSendEvent
{
    void Init();
}

```

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

### Load Image from PersistentDataPath in Unity

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/05_reskit

Shows how to load an image file from the device's persistent data path into a Unity UI Image. This method uses ResLoader and expects the image file to be present at the specified path. The example includes a placeholder for the local image URL.

```csharp
namespace QFramework.Example
{
    using System.Collections;
    using UnityEngine.UI;
    using UnityEngine;

    public class ImageLoaderExample : MonoBehaviour
    {
        private ResLoader mResLoader = null;

        private IEnumerator Start()
        {
            ResMgr.Init();

            mResLoader = ResLoader.Allocate();

            // local imagevar localImageUrl = "file://" + Application.persistentDataPath + "/Workspaces/lM1wmsLQtfzRQc6fsdEU.jpg";

            mResLoader.Add2Load(localImageUrl.ToLocalImageResName(),
                delegate(bool b, IRes res)
                {
                    Debug.LogError(b);
                    if (b)
                    {
                        var texture2D = res.Asset as Texture2D;
                        transform.Find("Image").GetComponent<Image>().sprite = Sprite.Create(texture2D,
                            new Rect(0, 0, texture2D.width, texture2D.height), Vector2.one * 0.5f);
                    }
                });

            mResLoader.LoadAsync();


            yield return new WaitForSeconds(5.0f);
            mResLoader.Recycle2Cache();
            mResLoader = null;
        }
    }
}

```

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

### QFramework Command 接口定义 (C#)

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/10_architecture_spec_and_recommended_usage

定义了 QFramework 命令（Command）的接口。ICommand 继承自 IBelongToArchitecture，并提供了发送命令、获取系统、模型、工具、注册事件以及发送查询的能力。命令负责数据的增删改操作。

```csharp
public interface ICommand : IBelongToArchitecture, ICanSetArchitecture, ICanGetSystem, ICanGetModel, ICanGetUtility,ICanSendEvent, ICanSendCommand, ICanSendQuery
{
    void Execute();
}


```

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

### ReplaceableMonoSingleton Behavior with Multiple Instances (C#)

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/09_singletonkit

Demonstrates the ReplaceableMonoSingleton pattern in C#. When multiple instances of a class inheriting from ReplaceableMonoSingleton exist in a scene, this code shows that the last created instance is retained. It uses a GameManager example, creating two instances and verifying which one persists.

```csharp
public class GameManager : ReplaceableMonoSingleton<GameManager>
{

}

IEnumerator Start()
{
    var gameManager = GameManager.Instance;

    var newGameManager = new GameObject().AddComponent<GameManager>();

    yield return new WaitForEndOfFrame();

    Debug.Log(FindObjectOfTypes<GameManager>().Length);
    // 1
    Debug.Log(gameManager == null);
    // true
    Debug.Log(newGameManager == null);
    // false
}
```

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

### Utilize ListPool and DictionaryPool for Collection Pooling in C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/11_poolkit

Shows how to efficiently manage List and Dictionary collections using specialized pools provided by PoolKit. It demonstrates getting a pooled collection, adding elements, and releasing it back to the pool to reduce garbage collection overhead.

```csharp
var names = ListPool<string>.Get()
names.Add("Hello");

names.Release2Pool();
// or ListPool<string>.Release(names);
var infos = DictionaryPool<string,string>.Get()
infos.Add("name","liangxie");

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

```

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

### Player.Designer 增量生成脚本 - C#

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/03_toolkits/03_codegenkit

CodeGenKit 支持增量生成，每次添加新的 Bind 组件时，Player.Designer.cs 会自动更新新增的引用，而 Player.cs 保持不变。此示例展示添加 GroundCheck 引用后的生成结果。

```csharp
// Generate Id:f512c2ed-6243-4a89-897e-bdaaabe50d63using UnityEngine;

// 1.请在菜单 编辑器扩展/Namespace Settings 里设置命名空间
// 2.命名空间更改后，生成代码之后，需要把逻辑代码文件（非 Designer）的命名空间手动更改
namespace QFramework.Example
{
    public partial class Player
    {

        public Transform Weapon;

        public Transform GroundCheck;

    }
}
```

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

### BindableProperty Basic Usage - C#/Unity

Source: https://qf.readthedocs.io/zh-cn/latest/QFramework_v1.0_Guide/02_architecture/17_bindableproperty

Demonstrates how to create and use BindableProperty instances for reactive data binding in Unity. Shows initialization with default values, event registration with Register() and RegisterWithInitValue() methods, and automatic unregistration on GameObject destruction. The example increments an integer property on mouse click and logs changes.

```csharp
using UnityEngine;

namespace QFramework.Example
{
    public class BindablePropertyExample : MonoBehaviour
    {
        private BindableProperty<int> mSomeValue = new BindableProperty<int>(0);

        private BindableProperty<string> mName = new BindableProperty<string>("QFramework");

        void Start()
        {
            mSomeValue.Register(newValue =>
            {
                Debug.Log(newValue);
            }).UnRegisterWhenGameObjectDestroyed(gameObject);

            mName.RegisterWithInitValue(newName =>
            {
                Debug.Log(mName);
            }).UnRegisterWhenGameObjectDestroyed(gameObject);
        }

        void Update()
        {
            if (Input.GetMouseButtonDown(0))
            {
                mSomeValue.Value++;
            }
        }
    }
}

// Output:
// QFramework
// On left mouse click, output:
// 1
// On left mouse click, output:
// 2
```
Tokens:
Raw