XLua官方Examples 08_Hotfix 热补丁的示例【2】

最新推荐文章于 2023-05-10 12:20:05 发布
最新推荐文章于 2023-05-10 12:20:05 发布
阅读量293 收藏
点赞数
分类专栏： # xlua
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhx956058885/article/details/109045307
版权

目录

0.代码备注

1.C# StatefullTest

2.C# HotfixTest2

3.调试

XLua官方教程目录 总结篇

 

0.代码备注

自己划分了一下模块，方便学习debug测试

1.C# StatefullTest

using UnityEngine;

namespace XLuaTest
{
    [XLua.Hotfix]
    public class StatefullTest
    {
        public StatefullTest()
        {

        }

        public StatefullTest(int a, int b)
        {
            if (a > 0)
            {
                return;
            }

            Debug.Log("a=" + a);
            if (b > 0)
            {
                return;
            }
            else
            {
                if (a + b > 0)
                {
                    return;
                }
            }
            Debug.Log("b=" + b);
        }

        public int AProp
        {
            get;
            set;
        }

        public event System.Action<int, double> AEvent;

        public int this[string field]
        {
            get
            {
                return 1;
            }
            set
            {
            }
        }

        public void Start()
        {

        }

        void Update()
        {

        }

        public void GenericTest<T>(T a)
        {

        }

        static public void StaticFunc(int a, int b)
        {
        }
        static public void StaticFunc(string a, int b, int c)
        {
        }

        ~StatefullTest()
        {
            Debug.Log("~StatefullTest");
        }
    }
}

2.C# HotfixTest2

using UnityEngine;
using XLua;

namespace XLuaTest
{
    [Hotfix]
    public class HotfixCalc
    {
        public int Add(int a, int b)
        {
            return a - b;
        }

        public Vector3 Add(Vector3 a, Vector3 b)
        {
            return a - b;
        }

        public int TestOut(int a, out double b, ref string c)
        {
            b = a + 2;
            c = "wrong version";
            return a + 3;
        }

        public int TestOut(int a, out double b, ref string c, GameObject go)
        {
            return TestOut(a, out b, ref c);
        }

        public T Test1<T>()
        {
            return default(T);
        }

        public T1 Test2<T1, T2, T3>(T1 a, out T2 b, ref T3 c)
        {
            b = default(T2);
            return a;
        }

        public static int Test3<T>(T a)
        {
            return 0;
        }

        public static void Test4<T>(T a)
        {
        }

        public void Test5<T>(int a, params T[] arg)
        {

        }
    }

    public class NoHotfixCalc
    {
        public int Add(int a, int b)
        {
            return a + b;
        }
    }

    [Hotfix]
    public class GenericClass<T>
    {
        T a;

        public GenericClass(T a)
        {
            this.a = a;
        }

        public void Func1()
        {
            Debug.Log("a=" + a);
        }

        public T Func2()
        {
            return default(T);
        }
    }

    [Hotfix]
    public class InnerTypeTest
    {
        public void Foo()
        {
            _InnerStruct ret = Bar();
            Debug.Log("{x=" + ret.x + ",y= " + ret.y + "}");
        }

        struct _InnerStruct
        {
            public int x;
            public int y;
        }

        _InnerStruct Bar()
        {
            return new _InnerStruct { x = 1, y = 2 };
        }
    }

    public class BaseTestHelper
    {

    }

    public class BaseTestBase<T> : BaseTestHelper
    {
        public virtual void Foo(int p)
        {
            Debug.Log("BaseTestBase<>.Foo, p = " + p);
        }
    }

    [Hotfix]
    [LuaCallCSharp]
    public class BaseTest : BaseTestBase<InnerTypeTest>
    {
        public override void Foo(int p)
        {
            Debug.Log("BaseTest<>.Foo, p = " + p);
        }

        public void Proxy(int p)
        {
            base.Foo(p);
        }

        public override string ToString()
        {
            return base.ToString();
        }
    }

    [Hotfix]
    public struct StructTest
    {
        GameObject go;
        public StructTest(GameObject go)
        {
            this.go = go;
        }

        public GameObject GetGo(int a, object b)
        {
            return go;
        }

        public override string ToString()
        {
            return base.ToString();
        }

        public string Proxy()
        {
            return base.ToString();
        }
    }

    [Hotfix]
    public struct GenericStruct<T>
    {
        T a;

        public GenericStruct(T a)
        {
            this.a = a;
        }

        public T GetA(int p)
        {
            return a;
        }
    }

    public class HotfixTest2 : MonoBehaviour
    {
        void Start()
        {
            LuaEnv luaenv = new LuaEnv();
            HotfixCalc calc = new HotfixCalc();
            NoHotfixCalc ordinaryCalc = new NoHotfixCalc();

            #region 使用or不使用热更新性能对比
            //int CALL_TIME = 100 * 1000 * 1000;
            //var start = System.DateTime.Now;
            //for (int i = 0; i < CALL_TIME; i++)
            //{
            //    calc.Add(2, 1);
            //}
            //var d1 = (System.DateTime.Now - start).TotalMilliseconds;
            //Debug.Log("Hotfix using:" + d1);

            //start = System.DateTime.Now;
            //for (int i = 0; i < CALL_TIME; i++)
            //{
            //    ordinaryCalc.Add(2, 1);
            //}
            //var d2 = (System.DateTime.Now - start).TotalMilliseconds;
            //Debug.Log("No Hotfix using:" + d2);

            //Debug.Log("drop:" + ((d1 - d2) / d1));
            #endregion

            #region  热更修复HotfixCalc Add方法 支持重载
            //    Debug.Log("Before Fix: 2 + 1 = " + calc.Add(2, 1));
            //    Debug.Log("Before Fix: Vector3(2, 3, 4) + Vector3(1, 2, 3) = " + calc.Add(new Vector3(2, 3, 4), new Vector3(1, 2, 3)));
            //    luaenv.DoString(@"
            //    xlua.hotfix(CS.XLuaTest.HotfixCalc, 'Add', function(self, a, b)
            //        return a + b
            //    end)
            //");
            //    Debug.Log("After Fix: 2 + 1 = " + calc.Add(2, 1));
            //    Debug.Log("After Fix: Vector3(2, 3, 4) + Vector3(1, 2, 3) = " + calc.Add(new Vector3(2, 3, 4), new Vector3(1, 2, 3)));
            #endregion

            #region  热更修复HotfixCalc TestOut方法 函数返回值 ref out参数
            double num;
            string str = "hehe";

            //    int ret = calc.TestOut(100, out num, ref str);
            //    Debug.Log("ret = " + ret + ", num = " + num + ", str = " + str);

            //    luaenv.DoString(@"
            //    xlua.hotfix(CS.XLuaTest.HotfixCalc, 'TestOut', function(self, a, c, go)
            //            print('TestOut', self, a, c, go)
            //            if go then error('test error') end
            //            return a + 10, a + 20, 'right version'
            //        end)
            //");
            //    str = "hehe";
            //    ret = calc.TestOut(100, out num, ref str);
            //    Debug.Log("ret = " + ret + ", num = " + num + ", str = " + str);
            #endregion

            #region  热更修复HotfixCalc table提供一组函数 多个函数一起修复
            //    luaenv.DoString(@"
            //    xlua.hotfix(CS.XLuaTest.HotfixCalc, {
            //         Test1 = function(self)
            //            print('Test1', self)
            //            return 1
            //         end;
            //         Test2 = function(self, a, b)
            //             print('Test2 a:',  a )
            //             print('Test2 b:',   b)
            //             return a + 10, 1024, 'this is third args'
            //         end;
            //         Test3 = function(a)
            //            print(a)
            //            return 10
            //         end;
            //         Test4 = function(a)
            //            print(a)
            //         end;
            //         Test5 = function(self, a, ...)
            //            print('Test4', self, a, ...)
            //         end
            //    })
            //");

            //    int r1 = calc.Test1<int>();
            //    double r2 = calc.Test1<double>();

            //    Debug.Log("r1:" + r1 + ",r2:" + r2);

            //    string ss = "heihei";
            //    r2 = 2;
            //    int r3 = calc.Test2(r1,out r2, ref ss);
            //    Debug.Log("r1:" + r1 + ",r2:" + r2 + ",r3:" + r3 + ",ss:" + ss);

            //    r3 = HotfixCalc.Test3("test3");
            //    r3 = HotfixCalc.Test3(2);
            //    r3 = HotfixCalc.Test3(this);
            //    Debug.Log("r3:" + r3);
            //    HotfixCalc.Test4(this);
            //    HotfixCalc.Test4(2);
            //    calc.Test5(10, "a", "b", "c");//不定参数
            //    calc.Test5(10, 1, 3, 5);
            #endregion

            #region 热更修复StatefullTest 【类全部重构】 构造函数、属性、索引器、事件、费静态方法、静态方法、泛型方法、析构函数
            /*
            Debug.Log("----------------------before------------------------");
            TestStateful();
            System.GC.Collect();//手动GC 强制垃圾回收
            System.GC.WaitForPendingFinalizers();//等待所有终结器完成后再继续
            luaenv.DoString(@"
            local util = require 'xlua.util'
            xlua.hotfix(CS.XLuaTest.StatefullTest, {
--构造函数
                ['.ctor'] = function(csobj)
                    util.state(csobj, {evt = {}, start = 0, prop = 0})
                end;

--属性
                set_AProp = function(self, v)
                    print('set_AProp', v)
                    self.prop = v
                end;
                get_AProp = function(self)
                    return self.prop
                end;

--索引器
                get_Item = function(self, k)
                    print('get_Item', k)
                    return 1024
                end;
                set_Item = function(self, k, v)
                    print('set_Item', k, v)
                end;

--event 事件
                add_AEvent = function(self, cb)
                    print('add_AEvent', cb)
                    table.insert(self.evt, cb)
                end;
                remove_AEvent = function(self, cb)
                   print('remove_AEvent', cb)
                   for i, v in ipairs(self.evt) do
                       if v == cb then
                           table.remove(self.evt, i)
                           break
                       end
                   end
                end;

--非静态方法
                Start = function(self)
                    print('Start')
                    for _, cb in ipairs(self.evt) do
                        cb(self.start, 2)
                    end
                    self.start = self.start + 1
                end;

--静态方法
                StaticFunc = function(a, b, c)
                   print(a, b, c)
                end;

--泛型方法
                GenericTest = function(self, a)
                   print(self, a)
                end;

--析构函数
                Finalize = function(self)
                   print('Finalize', self)
                end
           })
        ");
            Debug.Log("----------------------after------------------------");
            TestStateful();
            luaenv.FullGc();//lua GC、lua垃圾回收
            System.GC.Collect();
            System.GC.WaitForPendingFinalizers();
            */
            #endregion

            #region 热更修复 泛型类
            var genericObj = new GenericClass<double>(1.1);

            //    genericObj.Func1();
            //    Debug.Log(genericObj.Func2());
            //    luaenv.DoString(@"
            //    xlua.hotfix(CS.XLuaTest.GenericClass(CS.System.Double), {
            //        ['.ctor'] = function(obj, a)
            //            print('GenericClass<double>', obj, a)
            //        end;
            //        Func1 = function(obj)
            //            print('GenericClass<double>.Func1', obj)
            //        end;
            //        Func2 = function(obj)
            //            print('GenericClass<double>.Func2', obj)
            //            return 1314
            //        end
            //    })
            //");
            //    genericObj = new GenericClass<double>(1.1);
            //    genericObj.Func1();
            //    Debug.Log(genericObj.Func2());
            #endregion

            #region 热更修复 内置类型 结构体
            //    InnerTypeTest itt = new InnerTypeTest();
            //    itt.Foo();
            //    luaenv.DoString(@"
            //    xlua.hotfix(CS.XLuaTest.InnerTypeTest, 'Bar', function(obj)
            //            print('lua Bar', obj)
            //            return {x = 10, y = 20}
            //        end)
            //");
            //    itt.Foo();
            #endregion

            #region 热更修复 结构体、泛型结构体
            //    StructTest st = new StructTest(gameObject);
            //    Debug.Log("go=" + st.GetGo(123, "john"));
            //    luaenv.DoString(@"
            //    xlua.hotfix(CS.XLuaTest.StructTest, 'GetGo', function(self, a, b)
            //            print('GetGo', self, a, b)
            //            return nil
            //        end)
            //");
            //    Debug.Log("go=" + st.GetGo(123, "john"));

            //    GenericStruct<int> gs = new GenericStruct<int>(1);
            //    Debug.Log("gs.GetA()=" + gs.GetA(123));
            //    luaenv.DoString(@"
            //    xlua.hotfix(CS.XLuaTest.GenericStruct(CS.System.Int32), 'GetA', function(self, a)
            //            print('GetA',self, a)
            //            return 789
            //        end)
            //");
            //    Debug.Log("gs.GetA()=" + gs.GetA(123));

            //    try
            //    {
            //        calc.TestOut(100, out num, ref str, gameObject);
            //    }
            //    catch (LuaException e)
            //    {
            //        Debug.Log("throw in lua an catch in c# ok, e.Message:" + e.Message);
            //    }
            #endregion

            #region 热更修复 基类
            BaseTestBase<InnerTypeTest> bt = new BaseTest();
            bt.Foo(1);
            Debug.Log(bt);

            luaenv.DoString(@"
            xlua.hotfix(CS.XLuaTest.BaseTest, 'Foo', function(self, p)
                    print('BaseTest', p)
                end)
            xlua.hotfix(CS.XLuaTest.BaseTest, 'ToString', function(self)
                    return '>>>' .. base(self):ToString()
                end)
        ");
            bt.Foo(2);
            Debug.Log(bt);
            #endregion
        }

        void TestStateful()
        {
            StatefullTest sft = new StatefullTest();
            sft.AProp = 10;
            Debug.Log("sft.AProp:" + sft.AProp);
            sft["1"] = 3;
            Debug.Log("sft['1']:" + sft["1"]);
            System.Action<int, double> cb = (a, b) =>
            {
                Debug.Log("a:" + a + ",b:" + b);
            };
            sft.AEvent += cb;
            sft.Start();
            sft.Start();
            sft.AEvent -= cb;
            sft.Start();
            StatefullTest.StaticFunc(1, 2);
            StatefullTest.StaticFunc("e", 3, 4);
            sft.GenericTest(1);
            sft.GenericTest("hehe");
        }
    }
}

3.调试

HotfixTest2挂载到场景运行即可，这个里面测试的方法比较多，把看懂的注释掉，这样看比较清晰

Jack Yan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
build_xlua_with_libs.zip
11-30
《集成xlua与第三方库：pbc、rapidjson与WebGLPlugins配置详解》 在现代游戏开发中，lua脚本语言因其轻量级、高效和易于集成的特点，被广泛应用于游戏逻辑和热更新等方面。xlua是针对Unity引擎的一个lua绑定库，它...
Unity3d 基于xlua热更新实现系列二：Xlua脚本动态加载（半热更新）源码
03-21
Unity3d 基于xlua热更新实现系列二：Xlua脚本动态加载（半热更新）源码 建议先看说明：https://blog.csdn.net/qq_33789001/article/details/123637629
Unity Xlua之Hotfix热补丁 (一)
zzzsss123333的博客
03-18 1349
Unity Xlua之Hotfix热补丁 (一) 一.第一个热补丁 想要打热补丁的类前需要加上[Hotfix]特性 第一次打热补丁需要加上宏HOTFIX_ENABLE 点击生成代码 点击注入热补丁 例如我想修改如下代码中的两个方法，无论是公有方法还是私有方法都可以修改 [Hotfix] public class HotfixMain : MonoBehaviour { private void Start() { LuaMgr.GetInstance().Init();
Unity热更之旧项目救星——Xlua热补丁修复
糯米团子的博客
07-12 2519
Xlua官方开源地址：https://github.com/Tencent/xlua首先先说明下，因为我们的项目是比较旧的项目，所以当时并未使用任何热更技术，所有的代码都是用c#写的，导致到项目后期才忽然想使用热更就非常困难了。当时研究了不少热更框架发现大部分都无法再弥补过去的疏忽，直到出现了Xlua，作者宣称项目可以继续由C#编写，只有在热更修复的时候才是用lua，我觉得有戏就研究了下。根据方法...
Unity热更新Xlua&Xlua的Hotfix静态标签不起作用的解决办法
博客的博客的博客
05-10 593
关于Xlua对unity热更的处理
使用xlua 进行Unity3D 热更新
居安思危，游戏人生。
06-06 2496
xlua, 不但可以做纯lua的逻辑更新,还可以做 C# 代码的bug hotfix.就是可以在保持项目使用C#逻辑开发的前提下,出现bug后使用lua来修复.听起来很棒棒.github地址 : xlua试用一下之后,发现xlua的hotfix原理也很简单, 就是通过反射取出打上了 [hotfix] 标记的类,然后对需要fix的函数执行下列伪代码1234567void Start(){  if(_...
XLua资源热更、代码热补丁DEMO
MagicianThirteen
07-22 615
（一）导入热补丁资源和工具 xlua源代码中assets文件夹中的plugins文件夹和xlua文件夹，放到unity工程中的asset目录下，xlua中的tools文件夹，放在项目的asset目录的同级目录下。 然后配置playersetting，最后编辑器会出现热补丁注入的选项，如图所示 （二）资源热更，代码热补丁的原理和流程，步骤 步骤： 1.做一个客户端demo 2.服务器放上要更换的资源 3.客户端下载服务器要更新的资源 4.客户端使用服务端的更新资源 5.代码热补丁，实现demo中不同的功能
build_xlua_with_libs-master_lua_Unity热更新_unity3D游戏_androidunity_
10-02
4. 示例场景和测试代码：帮助开发者理解和学习如何在实际项目中应用这个热更新方案。 通过这个项目，开发者可以学习到如何在Unity中集成和使用Lua，以及如何构建一个完整的热更新系统。这不仅可以提高开发效率，还...
XLua_2018最新版
12-26
* [08_Hotfix](Assets/XLua/Examples/08_Hotfix/): 热补丁的示例（需要开启热补丁特性，如何开启请看[指南](Assets/XLua/Doc/hotfix.md)）。 * [09_GenericMethod](Assets/XLua/Examples/09_GenericMethod/): 泛化...
XLua官方教程
06-08
xLua为Unity、 .Net、 Mono等C#环境增加Lua脚本编程的能力，借助xLua，这些Lua代码可以方便的和C#相互调用。
Unity XLua学习笔记（四）：Hotfix热补丁
qq_42393139的博客
01-26 4039
上篇文章： Unity XLua学习笔记（三）：Lua调用C# 热补丁主要作用是用Lua替换C#中的方法 在做热补丁前，需要将GitHub上下载的XLua工程中的Tools文件夹导入到项目中 导入时注意路径，需要放在Assets文件的同级路径下 回到Unity中，打开PlayerSettings，做如下设置 输入：HOTFIX_ENABLE C#测试代码 using System.Collections; using System.Collections.Generic; using UnityEn
优化Xlua框架内存释放Lua调用C#智能提示
qq_35647121的博客
05-11 1715
凡是使用this.的地方，脚本销毁的时候把this.设置为nil 对象池回收之前，执行一下LuaManager.luaEnv.FullGc();，把lua和c#之间的关联打断，回收一下lua中可回收的东西 做智能提示 需要用到一个 解压缩之后把文件放到 然后依次点击xlua下的第一个选项，第二个选项 在下面的文件夹下有四个压缩包依次解压 然后 选择目录 一直点下一步就可以 每次C#代码修改过后，要执行依次...
Unity XLua 官方案例学习
weixin_30904593的博客
04-23 571
1. Helloworld 1 using UnityEngine; 2 using XLua; 3 4 public class Helloworld : MonoBehaviour { 5 // Use this for initialization 6 void Start () { 7 LuaEnv luaenv = new...
Unity 关于Xlua HotFix中会报的一些错
qq_37421018的博客
09-22 2418
首先明确一下xlua热更新的函数是： xlua.hotfix(CS.C#类型, "函数名", function(self) CS.UnityEngine.Debug.Log("修改了代码") end 然后提下错误 xlua.access, can not find c# type 这个是由于类型名没有使用HotFix标签或者不在配置文件的类里面（配置文件的设置请查看官...
使用XLua 与 Lua 热重载 （记录 3）
蛰伏--当你不够强大时，就不要放弃努力
07-11 946
使用XLua 与 Lua 热重载 （记录 3） ////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////// ...
Xlua学习笔记
m0_56399931的博客
09-12 691
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
XLua官方demo5-避免c#和lua间值类型的GC分析
https://github.com/Bot80926
03-21 3970
  代码里的几个标签解释：         · XLua.GCOptimize： gc代码优化。对于一个c#纯值类型(官网指一个只包含值类型的struct，可以嵌套其它只包含值类型的struct)或者c#枚举值加上了这个配置，会使得该类型在lua和c#间传递不产生gc alloc，该类型的数组访问也不会产生gc。         (除枚举之外，包含无参构造函数的复杂类型，都会生成lua table...
C#设计模式之：状态模式（State）
D.D.U的博客
09-13 2401
状态模式State 当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类 状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同状态的一系列类当中，可以复杂的判断逻辑简化。 UML 代码 abstract class State { public abstract void Handle...
xlua 如何热更代码
最新发布
06-10
2. 将需要热更的 Lua 脚本代码放到热更目录中，并在代码中使用 xlua 的 require 方法加载其他 Lua 模块。 3. 在游戏启动时，使用 xlua 的热更管理器加载热更目录中的 Lua 脚本代码。 4. 在游戏运行时，如果需要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jack Yan

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值