UH2S2L22——多函数替换和构造函数与析构函数替换

本章代码关键字

1
2
[".ctor"]        --xlua.hotfix内使用，用于添加构造函数逻辑（无法直接替换）
Finalize        --xlua.hotfix内使用，用于添加析构函数逻辑（无法直接替换）

多函数替换

我们可以使用另外一种写法，执行一次xlua.hotfix​，即可对多个方法进行热补丁操作

假设我们要对下面三个方法进行热补丁替换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class HotfixMain : MonoBehaviour
{
    void Update() { }

    public int Add(int a, int b)
    {
        return 0;
    }

    public static void Speak(string s)
    {
        Debug.Log("C# Speak");
    }
}

我们通过固定写法：xlua.hotfix(类, {函数名 = 函数, 函数名 = 函数....})​，即可对多个方法进行热补丁替换

1
2
3
4
5
6
7
8
9
10
11
xlua.hotfix(CS.HotfixMain, {
    Update = function(self)
        print(os.time())
    end,
    Add = function(self, a, b)
        return a + b
    end,
    Speak = function(a)
        print(a)
    end
})

构造函数替换

构造函数不能直接替换，原有的C#构造函数逻辑还是会执行，不过会在原有逻辑基础上执行Lua脚本代码

假设我们要对下面的类的各个方法进行热补丁替换

1
2
3
4
5
6
7
8
9
10
11
12
13
[Hotfix]
public class HotfixTest
{
    public HotfixTest() 
    {
        Debug.Log("HotfixTest构造函数");
    }

    public void Speak(string str)
    {
        Debug.Log(str);
    }
}

对于类的构造函数的热补丁替换，其索引为固定写法[".ctor"]​

1
2
3
4
5
6
7
8
9
xlua.hotfix(CS.HotfixTest, {
    -- 构造函数 热补丁固定写法
    [".ctor"] = function()
        print("Lua热补丁构造函数!")
    end,
    Speak = function(self, a)
        print("唐老狮说" .. a)
    end,
})

在这里可以发现，原来的构造函数方法并没有被替换，lua代码逻辑是在原构造函数的基础上添加的！

​image​

析构函数替换

析构函数同样不能直接替换，原有的C#构造函数逻辑还是会执行，不过会在原有逻辑基础上执行Lua脚本代码

对于类的构造函数的热补丁替换，其索引为固定写法Finalize​

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[Hotfix]
public class HotfixTest
{
    public HotfixTest() 
    {
        Debug.Log("HotfixTest构造函数");
    }

    public void Speak(string str)
    {
        Debug.Log(str);
    }
  
    //析构函数
    ~HotfixTest()
    {

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
xlua.hotfix(CS.HotfixTest, {
    -- 构造函数 热补丁固定写法
    [".ctor"] = function()
        print("Lua热补丁构造函数!")
    end,
    Speak = function(self, a)
        print("唐老狮说" .. a)
    end,
    -- 析构函数固定写法
    Finalize = function()
        print("对象销毁")
    end
})