# CodeGenerator

**Repository Path**: weijunhu/code-generator

## Basic Information

- **Project Name**: CodeGenerator
- **Description**: 代码生成器
- **Primary Language**: C#
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-04-19
- **Last Updated**: 2026-04-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# UA - UI Auto

**版本：** 1.0.0 | **Unity：** 2022.3+

一个 Unity UI 代码自动生成工具包，通过模板引擎将 UI 组件引用一键生成结构化的 C# 绑定代码，减少手写重复的 `GetComponent` 和事件绑定样板代码。

---

## 目录

- [安装](#安装)
- [核心概念](#核心概念)
- [快速上手](#快速上手)
- [模板语法](#模板语法)
- [扩展 Provider](#扩展-provider)
- [扩展 Generator](#扩展-generator)
- [API 参考](#api-参考)

---

## 安装

通过 Unity Package Manager 以本地路径或 Git URL 方式引入 `com.ua.uiauto`。

---

## 核心概念

| 概念             | 说明                                                                           |
| ---------------- | ------------------------------------------------------------------------------ |
| `UIComponents`   | **Runtime** 组件，挂载在 UI 根节点上，以数组形式存储所有需要绑定的 UI 组件引用 |
| `ProviderBase`   | 为每种 Unity 组件类型生成生命周期代码片段（声明 / 初始化 / 事件绑定等）        |
| `GeneratorBase`  | 代码生成器，负责读取模板、驱动 Provider、输出 C# 文件                          |
| `TemplateEngine` | 模板引擎，支持字段替换 `{{Field}}` 与组件迭代块 `{{#each components}}`         |

---

## 快速上手

### 第一步：挂载 UIComponents

在 UI 面板的根 GameObject 上添加 `UIComponents` 组件。

在 Inspector 中点击 **`+`** 按钮，将需要绑定的 UI 组件拖入列表并选择对应的组件类型。列表顺序即为代码中的索引顺序，可通过上下箭头调整，支持删除。

### 第二步：调用生成器

在 Editor 代码中创建 `Generator` 实例并调用 `Generate()`：

```csharp
UIComponents uiComponents = // ... 获取目标 UIComponents 组件
Generator.Generate(new GeneratorSample.SampleData("Login", "LoginForm", uiComponents));
```

执行后会在 `Assets/Scripts/RunTime/HotUpdate/Modules/Login/` 下生成 `LoginSampleData.cs`。

### 第三步：使用生成的代码

生成的文件包含完整的字段声明和初始化逻辑：

```csharp
internal class LoginForm
{
    private UIForm mUIForm;

    private Button mButton_Confirm;
    private TMP_InputField mTMP_InputField_Account;

    public void Init(UIForm form)
    {
        mUIForm = form;
        mButton_Confirm        = mUIForm.GetComponent<Button>(0);
        mTMP_InputField_Account = mUIForm.GetComponent<TMP_InputField>(1);
    }
}
```

---

## 模板语法

模板文件为纯文本（`.txt`），放置于 `Assets/Scripts/Editor/UA/Temp/` 目录下。生成器会优先加载外部模板文件，不存在时回退到代码内嵌模板。

### 字段替换

```
{{ModuleName}}
```

对应 `IGenerateData.ModuleName` 等字段，在生成时直接替换为对应字符串。

### 组件迭代块

```
{{#each components}}
    {{Define}}
    {{Init}}
    {{BindEvent}}
{{/each}}
```

对 `UIComponents.objs` 数组中的每个组件执行一次替换，每行独占一行的标签会保留模板缩进，空值标签所在整行会被自动移除。

**内置生命周期标签：**

| 标签              | 说明                                                           |
| ----------------- | -------------------------------------------------------------- |
| `{{Define}}`      | 字段声明，如 `private Button mButton_OK;`                      |
| `{{Init}}`        | 组件初始化，如 `mButton_OK = mUIForm.GetComponent<Button>(0);` |
| `{{BindEvent}}`   | 事件绑定代码                                                   |
| `{{UnbindEvent}}` | 事件解绑代码                                                   |
| `{{Dispose}}`     | 置空引用，如 `mButton_OK = null;`                              |
| `{{Functions}}`   | 回调方法实现                                                   |

### 完整模板示例

```
using System.Collections.Generic;

internal class {{ModuleName}}Form
{
    private UIForm mUIForm;

    {{#each components}}
    {{Define}}
    {{/each}}

    public void Init(UIForm form)
    {
        mUIForm = form;
        {{#each components}}
        {{Init}}
        {{/each}}
        {{#each components}}
        {{BindEvent}}
        {{/each}}
    }

    public void Dispose()
    {
        {{#each components}}
        {{UnbindEvent}}
        {{/each}}
        {{#each components}}
        {{Dispose}}
        {{/each}}
    }

    {{#each components}}
    {{Functions}}
    {{/each}}
}
```

---

## 扩展 Provider

当默认的 `Provider_Default` 不满足需求时（例如需要为 `Button` 自动生成点击事件绑定），可自定义 Provider。

1. 继承 `ProviderBase`
2. 添加 `[Provider("组件类型名")]` 特性，类型名须与 Unity 组件类名一致
3. 在 `GetLifecycle()` 中返回各生命周期代码片段

```csharp
[Provider("Button")]
public class Provider_Button : ProviderBase
{
    public override ComponentLifecycle GetLifecycle()
    {
        return new ComponentLifecycle
        {
            ["Define"]       = $"private Button {mPropertyName};",
            ["Init"]         = $"{mPropertyName} = mUIForm.GetComponent<Button>({mIndex});",
            ["BindEvent"]    = $"{mPropertyName}.onClick.AddListener(On{mObjName}Click);",
            ["UnbindEvent"]  = $"{mPropertyName}.onClick.RemoveListener(On{mObjName}Click);",
            ["Dispose"]      = $"{mPropertyName} = null;",
            ["Functions"]    = $"private void On{mObjName}Click() {{ }}"
        };
    }
}
```

`UA` 单例在初始化时会通过反射自动发现所有带有 `[Provider]` 特性的类，无需手动注册。

**`ProviderBase` 中可用的字段：**

| 字段            | 说明                                     |
| --------------- | ---------------------------------------- |
| `mComponent`    | 当前 Unity 组件实例                      |
| `mPropertyType` | 组件类型名，如 `Button`                  |
| `mPropertyName` | 自动生成的字段名，如 `mButton_OK`        |
| `mObjName`      | GameObject 去除类型前缀后的名称，如 `OK` |
| `mIndex`        | 在 `UIComponents.objs` 中的索引          |

---

## 扩展 Generator

如需生成不同结构的代码文件（例如同时生成 View 和 Presenter），可自定义 Generator。

1. 继承 `GeneratorBase`
2. 添加 `[Generator("DataType")]` 特性
3. 实现 `IGenerateData` 作为数据载体，`DataType` 须与特性中的字符串匹配
4. 实现 `GetTempStr()`、`GetModulePath()`、`DoGenerate()` 三个方法

```csharp
[Generator("MyUI")]
public class MyUIGenerator : GeneratorBase
{
    public override string GetTempStr(string fileName)
    {
        // 从文件或内嵌字符串返回模板内容
        string path = Path.Combine(Application.dataPath, "Templates", $"{fileName}.txt");
        return File.Exists(path) ? File.ReadAllText(path) : string.Empty;
    }

    public override string GetModulePath(string moduleName)
    {
        string dir = Path.Combine(Application.dataPath, "Generated", moduleName);
        Directory.CreateDirectory(dir);
        return dir;
    }

    public override void DoGenerate(IGenerateData data)
    {
        string template = GetTempStr("MyTemplate");

        var lifecycles = new List<ComponentLifecycle>();
        for (int i = 0; i < data.objs.Length; i++)
        {
            Component com = data.objs[i] as Component;
            if (com == null) continue;
            ProviderBase provider = UA.Instance.GetProvider(com.GetType().Name);
            provider.Init(com, data, i);
            lifecycles.Add(provider.GetLifecycle());
        }

        var fields = new Dictionary<string, string> { { "ModuleName", data.ModuleName } };
        string content = TemplateEngine.Process(template, fields, lifecycles);

        string savePath = Path.Combine(GetModulePath(data.ModuleName), $"{data.ModuleName}.cs");
        File.WriteAllText(savePath, content);
        AssetDatabase.Refresh();
    }
}

// 数据载体
public struct MyUIData : IGenerateData
{
    public string DataType => "MyUI";
    public string ModuleName { get; }
    public string SaveFileName { get; }
    public Object[] objs { get; }

    public MyUIData(string moduleName, UIComponents uiComponents)
    {
        ModuleName   = moduleName;
        SaveFileName = moduleName;
        objs         = uiComponents.objs;
    }
}
```

调用：

```csharp
Generator gen = new Generator();
gen.Generate(new MyUIData("Shop", shopUIComponents));
```

---

## API 参考

### `UIComponents`（Runtime）

```csharp
public Object   GetComponent(int index)
public T        GetComponent<T>(int index) where T : Object
public Object[] objs  // 已序列化的组件数组
```

### `TemplateEngine`（Editor）

```csharp
public static string Process(
    string template,
    Dictionary<string, string> fields,
    List<ComponentLifecycle> components
)
```

### `ComponentLifecycle`（Editor）

```csharp
lifecycle["Define"]      = "...";
lifecycle["Init"]        = "...";
lifecycle["BindEvent"]   = "...";
lifecycle["UnbindEvent"] = "...";
lifecycle["Dispose"]     = "...";
lifecycle["Functions"]   = "...";
```

### `GeneratorBase`（Editor）

```csharp
public abstract string GetTempStr(string fileName);
public abstract string GetModulePath(string moduleName);
public abstract void   DoGenerate(IGenerateData data);
public virtual  string GenerateTemplateField(string tempStr, Dictionary<string, string> defineDic);
```