热更新、Xlua中Lua调用C#代码
每日一句：保持须臾的浪漫，理想的喧嚣，平等的热情
什么是冷更新？
开发者将测试好的代码，发布到应用商店的审核平台，平台方会进行稳定性及性能测试。测试成功后，用户即可在AppStore看到应用的更新信息，用户点击应用更新后，需要先关闭应用，再进行更新
什么是热更新？
广义：无需关闭应用，不停机状态下恢复漏洞，更新资源等，重点是更新逻辑代码
狭义定义（ios热更新）：无需将代码重新打包提交至AppStore，即可更新客户端的执行代码，即不用下载app 而自动更新程序
现状：苹果禁止了C#的部分反射操作，禁止JIT（即时编译，程序运行时创建并运行新代码），不允许逻辑热更新，只允许使用AssetBundle进行资源热更新
注意：2017年，苹果更新了热更新政策说明，上线后的项目一旦发现使用热更新，一样会以下架处理
为何要热更新？
缩短用户获取新版应用的客户端的流程，改善用户体验，具体到ios平台的应用上，有以下几个原因
AppStore的审核周期难控制
手机应用更新频繁
对于大型应用，更新成本太大
终极目标
不重新下载，不停机状态下完全变换一个应用内容
每个平台如何做热更新？
Android 、PC(C#)
将执行代码预编译为AssemblyDLL
将代码作为TextAsset打包进AssetBundle
运行时调用AssemblyDLL代码
更新相应的AssetBundle即可实现热更新
ios(lua)
苹果官方禁止ios下的程序热更新：JIT在ios下无效
热更新方案：Unity+Lua插件
常见的Unity热更新插件
slua:最快的Lua插件
tolua:由ulua发展而来的，第三代Lua热更新方案
xlua：特性最先进的Lua插件
ILRuntime:纯C#实现的热更新插件
链接：https://pan.baidu.com/s/1er3OBGur5mA1PdIljfq8FQ?pwd=dpvj
提取码：dpvj
xlua-master分享
解决办法删掉
即可
Xlua中Lua调用C#代码 为什么？
C#实现的系统，因为Lua可以调用，所以完成可以换成Lua实现，因为Lua可以即时更改，即时运行，所以游戏的代码逻辑就可以随时修改
实现和C#相同效果的系统，如何实现？
Lua调用Unity的各种API，从而实现C#开发系统同样的效果
using XLua;
public class First : MonoBehaviour
{
void Start()
{
//lua是解释型语言，所以需要获得lua的解析器
//xLua解析器获得
LuaEnv env = new LuaEnv();
//解析器运行Lua代码，把字符串当成Lua代码执行
env.DoString("print('Hello world ### !')");
//解析器释放
env.Dispose();
}
}
_______________________________________________________________________
using UnityEngine;
using XLua;
//使用Lua调用C#
public class DoString : MonoBehaviour
{
void Start()
{
LuaCallCSharpCode();
}
public void LuaCallCSharpCode()
{
LuaEnv env = new LuaEnv();
//Lua调用C#代码(cs.命名空间.类名.方法名(参数))
env.DoString("CS.UnityEngine.Debug.Log('from lua')");
env.Dispose();
}
}
_______________________________________________________________________
using XLua;
public class Loader : MonoBehaviour
{
void Start()
{
LuaEnv env = new LuaEnv();
//对应test.lua
//内置加载器会扫描预制的目录，查找是否存在test.lua
//xlua存在默认加载器，StreamingAssets目录下可以加载文件中
env.DoString("require('test')");
env.Dispose();
}
}
_______________________________________________________________________
XLua的环境控制
接触一个新的Lua项目时，先要弄懂Lua的加载器规则，只有这样，才能弄懂项目的Lua执行流程
Xlua的单例运行环境
Xlua解析器创建销毁
Xlua加载器编写
using System.IO;
using UnityEngine;
using XLua;
public class xLuaEnv
{
private static xLuaEnv _Instance = null;
public static xLuaEnv Instance
{
get
{
if(_Instance==null)
{
_Instance = new xLuaEnv();
}
return _Instance;
}
}
private LuaEnv _Env;
//创建单例的时候，Lua运行环境，会一起被创建
private xLuaEnv()
{
_Env = new LuaEnv();
_Env.AddLoader(_ProjectLoader);
}
//创建自定义Lua加载器，这样就可以任意订制项目的Lua脚本的存储位置
private byte[] _ProjectLoader(ref string filepath)
{
string path = Application.dataPath;
path = path.Substring(0, path.Length - 7) + "/DataPath/Lua/" + filepath + ".Lua";
//因为"Application.dataPath"在上线的代码中无法获得，所以上线时，需要将Lua的存储路径，
//指向到"Application.persistentDataPath"
if(File.Exists(path))
{
return File.ReadAllBytes(path);
}
else
{
return null;
}
}
public void Free()
{
//释放LuaEnv，同时也释放单例对象，这样下次调单例对象，会再次产生Lua运行环境
_Env.Dispose();
_Instance = null;
}
public object[] DoString(string code)
{
return _Env.DoString(code);
}
}
——————————————————————————————————————
静态
public class LuaCallStatic : MonoBehaviour
{
void Start()
{
xLuaEnv.Instance.DoString("require('C2L/LuaCallStatic')");
}
private void OnDestroy()
{
xLuaEnv.Instance.Free();
}
}
LuaCallStatic.lua
print(‘LuaCallStatic’)
using UnityEngine;
namespace HX
{
public static class TestStatic
{
public static int ID = 99;
public static string Name
{
get;
set;
}
public static string Output()
{
return "static";
}
public static void Default(string str = "abc")
{
Debug.Log(str);
}
}
public class LuaCallStatic : MonoBehaviour
{
void Start()
{
xLuaEnv.Instance.DoString("require('C2L/LuaCallStatic')");
}
private void OnDestroy()
{
xLuaEnv.Instance.Free();
}
}
}
LuaCallStatic.lua
--Lua调用静态类
--规则“cs.命名空间.类名.成员变量"
print(CS.HX.Teststatic.ID)
--给静态属性赋值
CS.HX.TestStatic.Name="admin"
print(CS.HX.Teststatic.Name)
--静态成员方法调用
--规则"CS.命名空间.类名.方法名（）"
print(CS.HX.Teststatic.Output())
--使用默认值
CS.HX.Teststatic.Default()
--使用Lua传递的值
CS.HX.Teststatic.Default("def")
_______________________________________________________________________________________________
public class NPC
{
public string Name;
public int HP
{
get;
set;
}
public NPC()
{
}
public NPC(string name)
{
Name = name;
}
}
public class LuaCallObject : MonoBehaviour
{
void Start()
{
xLuaEnv.Instance.DoString("require('C2L/LuaCallObject')");
}
private void OnDestroy()
{
xLuaEnv.Instance.Free();
}
}
LuaCallObject.lua
--在当前表中调用表里—变量
--Lua实例化类
--C#NPC obj=new NPC()
--通过调用构造函数创建对象
local obj=CS.NPC()
obj.HP=100
print(obj.HP)
local obj1=CS.NPC("admin")
print(obj1.Name)
--表方法希望调用表成员变量（表：函数（））
--为什么是冒号，对象引用成员变量时，会隐性调用this,等同于Lua中的self
--Lua实例化GameObject
CS.UnityEngine.GameObject("LuaCreateGo")
local go=CS.UnityEngine.GameObject("LuaCreateGo")
go:AddComponent(typeof(CS.UnityEngine.BoxCollider))
结构体
public struct TestStruct
{
public string Name;
public string Output()
{
return Name;
}
}
public class LuaCallStruct : MonoBehaviour
{
void Start()
{
xLuaEnv.Instance.DoString("require('C2L/LuaCallStruct')");
}
private void OnDestroy()
{
xLuaEnv.Instance.Free();
}
}
LuaCallStruct.lua
--结构体
--和对象调用保持一致
local obj=CS.TestStruct()
obj.Name="admin"
print(obj.Name)
print(obj:Output())
枚举
using UnityEngine;
public enum TestEnum
{
LOL=0,
Data2
}
public class LuaCallEnum : MonoBehaviour
{
void Start()
{
xLuaEnv.Instance.DoString("require('C2L/LuaCallEnum')");
}
private void OnDestroy()
{
xLuaEnv.Instance.Free();
}
}
LuaCallEnum.lua
--C# TestEnum.LoL
--CS.命名空间.枚举名.枚举值
--枚举获得是userdata自定义数据类型，获得其他语言数据类型时，就是userdata
print(type(CS.TestEnum.LOL))
print(CS.TestEnum.Data2)
--转换获得枚举值
print(CS.TestEnum._CastFrom(0))
print(CS.TestEnum._CastFrom("Data2"))
重载函数
public class TestOverload
{
public static void Test(int id)
{
Debug.Log("数字类型：" + id);
}
public static void Test(string name)
{
Debug.Log("字符串类型：" + name);
}
public static void Test(int id,string name)
{
Debug.Log("两个数值："+id+","+name);
}
}
public class LuaCallOverload : MonoBehaviour
{
void Start()
{
xLuaEnv.Instance.DoString("require('C2L/LuaCallOverload')");
}
private void OnDestroy()
{
xLuaEnv.Instance.Free();
}
}
LuaCallOverload.lua
--重载函数
--数字重载函数
CS.TestOverload.test(99)
CS.TestOverload.test("admin")
--不同参数的重载函数
CS.TestOverload.test(100,"root")
重写、继承
public class Father
{
public string Name = "father";
public void Talk()
{
Debug.Log("这是父类中的方法");
}
public virtual void Override()
{
Debug.Log("这是父类中的虚方法");
}
}
public class Child:Father
{
public override void Override()
{
Debug.Log("这是子类中重写方法");
}
}
public class LuaCallBase : MonoBehaviour
{
void Start()
{
xLuaEnv.Instance.DoString("require('C2L/LuaCallBase')");
}
private void OnDestroy()
{
xLuaEnv.Instance.Free();
}
}
LuaCallBase.lua
--调用Father
local father=CS.Father()
print(father.Name)
father:Override()
--调用Child
local child=CS.Child()
print(child.Name)
child:Talk()
child:Override()
类扩展
public class TestExtend
{
public void Output()
{
Debug.Log("类本身带的方法");
}
}
//类扩展，需要给扩展方法编写的静态类添加LuaCallCSharp,
//否则Lua无法调用到
[LuaCallCSharp]
public static class MyExtend
{
public static void Show(this TestExtend obj)
{
Debug.Log("类扩展实现的方法");
}
}
public class LuaCallExtend : MonoBehaviour
{
void Start()
{
xLuaEnv.Instance.DoString("require('C2L/LuaCallExtend')");
}
private void OnDestroy()
{
xLuaEnv.Instance.Free();
}
}
LuaCallExtend.lua
local obj=CS.TestExtend()
obj:Output()
obj:SHow()
委托
using UnityEngine;
public delegate void DelegateLua();
public class TestDelegate
{
public static DelegateLua Static;
public DelegateLua Dynamic;
public static void StaticFunc()
{
Debug.Log("C#静态成员函数");
}
}
public class LuaCallDelegate : MonoBehaviour
{
void Start()
{
xLuaEnv.Instance.DoString("require('C2L/LuaCallDelegate')");
}
private void OnDestroy()
{
xLuaEnv.Instance.Free();
}
}
LuaCallDelegate.lua
--委托
--C#给委托赋值
--TestDelegate.Static=TestDelegate.StaticFunc
--TestDelegate.Static+=TestDelegate.StaticFunc
--TestDelegate.Static-=TestDelegate.StaticFunc
CS.TestDelegate.Static=CS.TestDelegate.StaticFunc
CS.TestDelegate.Static()
--Lua中如果添加了函数到静态委托变量中后，委托不再使用后，记得释放
CS.TestDelegate.Static=nil
local func=function ()
print(":这是Lua函数")
end
--覆盖添加委托
CS.TestDelegate.Static=func
CS.TestDelegate.Static=CS.TestDelegate.Static+func
CS.TestDelegate.Static=CS.TestDelegate.Static-func
--调用以前应确定委托有值
if(CS.TestDelegate.Static~=nil)
then
CS.TestDelegate.Static()
end
CS.TestDelegate.Static=nil
--根据委托判定赋值方法
if(CS.TestDelegate.Static==nil)
then
CS.TestDelegate.Static=func
else
CS.TestDelegate.Static=CS.TestDelegate.Static+func
end
local obj=CS.TestDelegate()
obj.Dynamic=func
obj.Dynamic()
obj.Dynamic=nil
事件
public delegate void EventLua();
public class TestEvent
{
public static event EventLua Static;
public static void StaticFunc()
{
Debug.Log("这是静态函数");
}
public static void CallStatic()
{
if(Static!=null)
{
Static();
}
}
public event EventLua Dynamic;
public void CallDynamic()
{
if(Dynamic!=null)
{
Dynamic();
}
}
}
public class LuaCallEvnet : MonoBehaviour
{
void Start()
{
xLuaEnv.Instance.DoString("require('C2L/LuaCallEvnet')");
}
private void OnDestroy()
{
xLuaEnv.Instance.Free();
}
}
LuaCallEvnet.lua
--Lua添加事件
CS.TestEvent.Static("+",CS.TestEvent.StaticFunc)
CS.TestEvent.CallStatic()
CS.TestEvent.Static("-",CS.TestEvent.StaticFunc)
--添加动态成员变量
local func=function ()
print("来自于Lua的回调函数")
end
local obj=CS.TestEvent()
obj:Dynamic("+",func)
obj:CallDynamic()
obj:Dynamic("-",func)
--xlua实现了typeof关键字，所以可以用类型API替代Unity内置的泛型方法
public class LuaCallGenericType : MonoBehaviour
{
void Start()
{
xLuaEnv.Instance.DoString("require('C2L/LuaCallGenericType')");
}
private void OnDestroy()
{
xLuaEnv.Instance.Free();
}
}
public class TestGenercType
{
public void Output<T>(T data)
{
Debug.Log("泛型方法：" + data.ToString());
}
public void Output(float data)
{
Output<float>(data);
}
public void Output(string data)
{
Output<string>(data);
}
}
LuaCallGenericType.lua
local obj=CS.TestGenericType()
obj:Output(99)
obj.Output("admin")
local go=CS.UnityEngine.GameObject("LuaCreate")
go:AddComponent(typeof(CS.UnityEngine.BoxCollider))
多返回值
public class LuaCallOutRef : MonoBehaviour
{
void Start()
{
xLuaEnv.Instance.DoString("require('C2L/LuaCallOutRef')");
}
private void OnDestroy()
{
xLuaEnv.Instance.Free();
}
}
public class TestOutRef
{
public static string Func1()
{
return "Func1";
}
public static string Func2(string str1,out string str2)
{
str2 = "Func2 out";
return "Func2";
}
public static string Func3(string str1, ref string str2)
{
str2 = "Func3 Ref";
return "Func3";
}
public static string Func4(ref string str1,string str2)
{
str1 = "Func4 Ref";
return "Func4";
}
}
LuaCallOutRef.lua
local r1=CS.TestOutRef.Func1()
print(r1)
--C# out返回的变量，会赋值给Lua的第二个接受返回值变量
local out2
local r2,out1=CS.TestOutRef.Func2("admin",out2)
print(r2,out1,out2)
--C# ref返回的变量，会赋值给Lua的第二个接受返回值变量
local ref2
local r3,ref1=CS.TestOutRef.Func3("root",ref2)
print(r3,ref1,ref2)
--即使out ref 作为第一个参数，其结果依然会以Lua的多个返回值进行返回
local ref4
local r4,ref3=CS.TestOutRef.Func4(ref4,"test")
print(r4,ref3,ref4)