熱 更新的 基本原理

 C#指令碼不能直接熱更新的原因:

下載的圖片與模型都沒有問題，如果是Unity邏輯程式碼，無論是以前的

Mono AOT 還是後面的il2cpp , 都是編譯成native code, IOS下是執行不起

來的。

 解決方法

就是不用native code ，改為解釋執行。包括Xlua在內所有熱更新就是這

個思路來實現。

 

Xlua外掛的GitHub 下載地址

https://github.com/Tencent/xLua

 作者對於Xlua外掛的整體介紹性文章

http://www.gad.qq.com/article/detail/24967

 

具體準備開發環境：

1：下載Xlua外掛，且匯入工程。

2: 把Xlua中的Xlua與Plugins 目錄直接拷貝到專案所在資料夾。成功拷貝後，

在Unity選單中可以看到出現"XLua"的選單項。


1.lua中使用冒號“：”表示成員方法的呼叫。它自動完成當前物件作為一個引數，傳入方法；lua中使用點“.”，則表示靜態屬性與方法呼叫，它需要手工往方法中傳遞當前物件。

2.冒號定義方法，預設會接受self引數，而點號定義的時候，預設不會接受self引數

3.lua中 classObj:Method()與 classObj.Method(classObj)一樣

 

1.lua 的欄位或者函式之間要用 ,(逗號)隔開

 

2.lua裡面的類或者table可以對映到C#裡面的Interface，C#裡面的Interface要用public修飾，並且要新增[CSharpCallLua]特性標籤

 

3.載入Resources檔案裡面的lua檔案：

 

  a.   env = new LuaEnv();

 

        env.DoString("require 'LuaCallCSharp'");

  b. env = new LuaEnv();

       TextAsset txtAsset = Resources.Load<TextAsset>("simpleLua.lua");

       env.DoString(txtAsset.text);

 

  c. LuaEnv env = null;

    // Use this for initialization

 

    string fileName = "CustomDIRLuaFile";

    void Start()

    {

        env = new LuaEnv();

        env.AddLoader(CustomMyLoader);

        env.DoString("require 'CustomDIRLuaFile'");

    }

 

    byte[] CustomMyLoader(ref string fileName)

    {

        string luaPath = Application.dataPath + "/Scripts/LuaScripts/" + fileName + ".lua";

 

        string strLuaContent = File.ReadAllText(luaPath);

 

        byte[] back=null;

        back = System.Text.Encoding.UTF8.GetBytes(strLuaContent);

        return back;

    }

 

uv：告訴貼圖如何貼在模型上

 

反轉法線

高亮 unlit/texture

 

                使用

1. 最基本是直接用LuaEnv.DoString執行一個字串，當然，字串得符合Lua語法

比如：luaenv.DoString("print('hello world')")

2. 載入 lua 檔案

 使用TextAsset 方式載入檔案：

Eg:

TextAsset ta=Resources.Load<TextAsset>("HelloWorld.lua");

LuaEnv env=new LuaEnv();

env.DoString(ta.text);

 

3. 載入 lua 檔案

 Require函式進行載入 (常用方式)

require 就是一個個的呼叫Loader ，查找出匹配的lua檔案，然後執行

該檔案。

注意事項：

1：因為Resource 只支援有限的字尾，放Resource下的lua檔案需要加上

txt字尾。

2：使用lua開發專案推薦的方式是：整個程式就一個

DoString(“require‘main’”), 然後在main.lua中載入其他指令碼。（這裡

的Main檔名稱可以任意）

3. 在xLua加自定義loader是很簡單的，只涉及到一個介面：

public delegate byte[] CustomLoader(ref string filepath);

public void LuaEnv.AddLoader(CustomLoader loader)

通過AddLoader可以註冊個回撥，該回調引數是字串，lua程式碼裡頭呼叫require時，引數將會透傳給回撥，回撥中就可以根據這個引數去載入指定檔案，如果需要支援除錯，需要把filepath修改為真實路徑傳出。該回調返回值是一個byte陣列，如果為空表示該loader找不到，否則則為lua檔案的內容。如下：

//lua環境(官方建議全域性唯一)

LuaEnv env = null;

private void Start()

{

env = new LuaEnv();

env.AddLoader(CustomMyLoader);

env.DoString("require 'CustomDIRLuaFile'");

}

/// <summary>

/// 定義回撥方法

/// 功能:

///     本方法主要功能是自定義lua檔案路徑。

/// </summary>

/// <param name="fileName">檔名稱</param>

/// <returns></returns>

private byte[] CustomMyLoader(ref string fileName)

{

byte[] byArrayReturn = null; //返回資料

//定義lua路徑

string luaPath = Application.dataPath + "/Scripts/LuaScripts/" + fileName + ".lua";

//讀取lua路徑中指定lua檔案內容

string strLuaContent = File.ReadAllText(luaPath);

//資料型別轉換

byArrayReturn = System.Text.Encoding.UTF8.GetBytes(strLuaContent);

return byArrayReturn;

}

 

不同lua檔案的載入方式分析：

 使用Require 方式載入lua檔案，必須放置在Resources特殊目錄下，否則

查詢不到無法載入。

 自定義Loader 可以進一步擴充套件前面兩種方法的弊端，可以按照自己的方

式進行載入lua與執行lua程式碼。（即：可以把*.lua檔案放置到任意合法文

件夾下，且lua檔案不用字尾增加txt標識。）

 require 本質是按照既定的查詢順序，找到需要的lua程式，否則返回

nil ,然後報錯。演示當查詢一個錯誤的lua檔案時候，控制檯詳細列印的

查詢路徑。

C#呼叫lua

Lua類：

--定義一個綜合表（lua中的OOP思想）屬性或方法中以逗號分隔

gameUser={

       name="崔永元",

       age=40,

       ID="18011112222",

       Speak=function()

              print("lua玩家在討論中")

       end,

       Walking=function()

              print("lua玩家在健身中")

       end,

       Calulation=function(age,num1,num2)--說明：age 這裡命名可以任意，表示當前物件（即：gameUser）

              return age.age+num1+num2

       end

}

 

1. 獲取 一個全域性基本 資料型別

 訪問LuaEnv.Global就可以了，上面有個模版Get方法，可指定返回的型別。

env = new LuaEnv();

            env.DoString("require 'CsharpCallLua'");

            string str1=env.Global.Get<string>("str");  //字串型別

            int num = env.Global.Get<int>("number");//數字型別

 

2. 訪問一個全域性 table
方式1： 對映到普通class或struct

定義一個class，有對應於table的欄位的public屬性，而且有無引數構

造函式即可，比如對於{f1 = 100, f2 = 100}可以定義一個包含

public int f1;

public int f2; 的class。

這種方式下xLua會幫你new一個例項，並把對應的欄位賦值過去。

table的屬性可以多於或者少於class的屬性。可以巢狀其它複雜型別。

 

方式2：對映到一個interface [*推薦方式]

這種方式依賴於生成程式碼（如果沒生成程式碼會拋InvalidCastException異

常），程式碼生成器會生成這個interface的例項。 如果get一個屬性，生成代

碼會get對應的table欄位，如果set屬性也會設定對應的欄位。甚至可以通過

interface的方法訪問lua的函式。

注意點與效能分析:

A: 介面需要新增特性標籤[CSharpCallLua],否則無法生成例項程式碼。

B: 為引用拷貝，適合用在複雜表,一般商業專案推薦使用本方式。

如下：

//定義介面

        [CSharpCallLua]

        public interface IGameLanguage

        {

            string str1 { get; set; }

            string str2 { get; set; }

            string str3 { get; set; }

            string str4 { get; set; }

        }

  //lua環境(官方建議全域性唯一)

        LuaEnv env = null;

 

        private void Start()

        {

            env = new LuaEnv();

            env.DoString("require 'CsharpCallLua'");

            //得到lua中的表資訊

            IGameLanguage gameLan = env.Global.Get<IGameLanguage>("gameLanguage");

            //輸出顯示

            Debug.Log("[使用介面]gameLan.str1="+ gameLan.str1);

            Debug.Log("[使用介面]gameLan.str2=" + gameLan.str2);

            Debug.Log("[使用介面]gameLan.str3=" + gameLan.str3);

            Debug.Log("[使用介面]gameLan.str4=" + gameLan.str4);

            //演示介面的引用拷貝原理

            gameLan.str1 = "我是修改後的內容";

            env.DoString("print('修改後gameLanguage.str1='..gameLanguage.str1)");

 

        }

 

 

Example: 通過interface ，呼叫lua中一個複雜一些的Table

public class CallLuaTableByInterfaceComp:MonoBehaviour

    {

        //lua環境(官方建議全域性唯一)

        LuaEnv env = null;

 

        private void Start()

        {

            env = new LuaEnv();

            env.DoString("require 'CsharpCallLua'");

            //得到lua中的表資訊

            IGameUser gameUser = env.Global.Get<IGameUser>("gameUser");

            //輸出顯示

            Debug.Log("[使用介面]gameLan.ID=" + gameUser.ID);

            Debug.Log("[使用介面]gameLan.Name=" + gameUser.name);

            Debug.Log("[使用介面]gameLan.Age=" + gameUser.age);

 

            //輸出呼叫方法

            gameUser.Speak();

            gameUser.Walking();

            int tmpResult=gameUser.Calulation(100,200);

            Debug.Log("經過lua中計算，結果= "+tmpResult);

 

        }

 

        private void OnDestroy()

        {

            //釋放luaenv

            env.Dispose();

        }

 

        //定義介面

        [CSharpCallLua]

        public interface IGameUser

        {

            string name { get; set; }

            int age { get; set; }

            string ID { get; set; }

 

            void Speak();

            void Walking();

            int Calulation(int num1, int num2);

 

        }

    }

方式3： by value 方式:

這是更輕量級的by value 方式，對映到Dictionary<>,List<> （適合用在

簡單表）不想定義class或者interface的話，可以考慮用這個，前提table下

key和value的型別都是一致的。如下：

//得到lua中的簡單表資訊

Dictionary<string, object>  dicGameLan=env.Global.Get<Dictionary<string, object>>("gameLanguage");//對映一個簡單表

 

            //得到lua中的複雜表信

Dictionary<string, object>  dicGameLan=env.Global.Get<Dictionary<string, object>>("gameUser");//對映一個複雜表

//得到一個更加簡單lua表，使用List<> 來對映。

List<string> liProLan=env.Global.Get<List<string>>("programLanguage");

 

Example:  講解使用委託的方式，呼叫Lua中具備多個返回數值的函式。

 *          1: 定義out 關鍵字的委託。

 *          2：定義ref 關鍵字的委託。
 

  //自定義委託(使用out關鍵字)

    [CSharpCallLua]

    public delegate void delAddingMutilReturn(int num1, int num2, out int res1, out int res2, out int res3);

    [CSharpCallLua]

    public delegate void delAddingMutilRetRef(ref int num1, ref int num2, out int result);

 

    public class CallLuaFunctionByDeleMultiReturn:MonoBehaviour

    {

        //lua環境(官方建議全域性唯一)

        LuaEnv env = null;

        //委託宣告

        delAddingMutilReturn act1 = null;

        delAddingMutilRetRef act2 = null;

 

        private void Start()

        {

            env = new LuaEnv();

            env.DoString("require 'CsharpCallLua'");

            ////得到lua中的具有多個返回數值的函式（通過委託out關鍵字來進行對映）

            //act1=env.Global.Get<delAddingMutilReturn>("ProcMyFunc5");

 

            ////輸出返回結果

            //int intOutRes1 = 0;

            //int intOutRes2 = 0;

            //int intOutRes3 = 0;

            //act1(100, 880,out intOutRes1, out intOutRes2, out intOutRes3);

            //Debug.Log(string.Format("res1={0},res2={1},res3={2}", intOutRes1, intOutRes2, intOutRes3));

 

            //得到lua中的具有多個返回數值的函式（通過委託ref關鍵字來進行對映）

            act2=env.Global.Get<delAddingMutilRetRef>("ProcMyFunc5");

 

            //輸出返回結果

            int intNum1 = 20;

            int intNum2 = 30;

            int intResult = 0;

 

            act2(ref intNum1, ref intNum2, out intResult);

            Debug.Log(string.Format("使用ref關鍵字，測試多輸出 res1={0},res2={1},res3={2}", intNum1,intNum2, intResult));

        }

方式4： by ref方式，對映到LuaTable類。

這種方式好處是不需要生成程式碼，但問題就是比較慢(即：效率低下)，

比interface方式要慢一個數量級，比如沒有型別檢查。

效能分析：

因為效率較低，所以不推薦常用，適合用在一些較為複雜且使用頻率很

低的情況下，一般不推薦使用。如下：

env = new LuaEnv();

            env.DoString("require 'CsharpCallLua'");

            //得到lua中的複雜表資訊

            XLua.LuaTable tabGameUser=env.Global.Get<XLua.LuaTable>("gameUser");

 

            //輸出顯示

            Debug.Log("name="+tabGameUser.Get<string>("name"));

            Debug.Log("Age=" + tabGameUser.Get<int>("age"));

            Debug.Log("ID=" + tabGameUser.Get<string>("ID"));

 

            //輸出表中函式

            XLua.LuaFunction funSpeak=tabGameUser.Get<XLua.LuaFunction>("Speak");

            funSpeak.Call();

            XLua.LuaFunction funWalking = tabGameUser.Get<XLua.LuaFunction>("Walking");

            funWalking.Call();

 

            XLua.LuaFunction funCalulation = tabGameUser.Get<XLua.LuaFunction>("Calulation");

            object[] objArray=funCalulation.Call(tabGameUser, 10, 20);

            Debug.Log("輸出結果="+ objArray[0]);//輸出結果： 70

 

2. 訪問 一個全域性的
方式1： 對映到delegate [* 推薦方式]

優點: 這是建議的方式，效能好很多，而且型別安全。

缺點: (含有out與ref關鍵字delegate)要生成程式碼（如果沒生成程式碼會拋

InvalidCastException異常）。

注意：

A: 含有 out 與 ref 關鍵字委託也需要新增特性標籤[ [ CSharpCallLua] ]

B: 委託 引用後，退出 luaEnv 前，需要釋放委託引用，否則 lua 報錯 ！

C: 對於 Unity 與 C# 中的複雜型別 API, 必須加入 Xlua 的配置檔案，經過生

成程式碼後才能正確應用。

例如： Action< int,int,int > 、 Func< < int,int,int >

delegate要怎樣宣告呢？

對於function的每個引數就宣告一個輸入型別的引數。

 多返回值要怎麼處理？

從左往右對映到c#的輸出引數，輸出引數包括返回值，out引數，ref參

數。

 引數、返回值型別支援哪些呢？

都支援，各種複雜型別，out，ref修飾的，甚至可以返回另外一個

delegate。

public class CallLuaFunctionByDele:MonoBehaviour

    {

        //lua環境(官方建議全域性唯一)

        LuaEnv env = null;

        //自定義委託

        public delegate void delAdding(int num1, int num2);

        Action act = null;

        delAdding act2 = null;

        //注意： 以下兩種委託定義，需要配置檔案支援。

        Action<int, int, int> act3 = null;

        Func<int, int, int> act4 = null;

 

 

        private void Start()

        {

            env = new LuaEnv();

            env.DoString("require 'CsharpCallLua'");

            //得到lua中的函式資訊（通過委託來進行對映）

            act=env.Global.Get<Action>("ProcMyFunc1");

            //使用自定義委託呼叫具備兩個輸入引數的lua中的函式

            act2=env.Global.Get<delAdding>("ProcMyFunc2");

            //定義三個輸入引數的委託。

            act3 = env.Global.Get<Action<int, int, int>>("ProcMyFunc4");

            //定義具備返回數值，兩個輸入數值的委託

            act4 = env.Global.Get<Func<int, int, int>>("ProcMyFunc3");

 

            //呼叫

            act.Invoke();

            act2(50,60);

            act3(20, 30, 40);

            int intResult=act4(60,40);

            Debug.Log("Func 委託，輸出結果="+intResult);

 

        }

        private void OnDestroy()

        {

            act = null;

            act2 = null;

            act3 = null;

            act4 = null;

            //釋放luaenv

            env.Dispose();

        }

}

 

方式2： 對映到LuaFunction

優點: 無需生成程式碼

缺點: 效能不高，不推薦。

這種方式的優缺點剛好和第一種相反。使用也簡單。LuaFunction上有個

變參的Call函式，可以傳任意型別，任意個數的引數，返回值是object的數

組，對應於lua的多返回值。

private void Start()

        {

            env = new LuaEnv();

            env.DoString("require 'CsharpCallLua'");

            //得到lua中的函式資訊（通過LuaFunction來進行對映）

            LuaFunction luaFun=env.Global.Get<LuaFunction>("ProcMyFunc1");

            LuaFunction luaFun2 = env.Global.Get<LuaFunction>("ProcMyFunc2");

            LuaFunction luaFun3 = env.Global.Get<LuaFunction>("ProcMyFunc3");

            //呼叫具有多返回數值。

            LuaFunction luaFun4 = env.Global.Get<LuaFunction>("ProcMyFunc5");

 

            //輸出

            luaFun.Call();

            luaFun2.Call(10, 20);

            object[] objArray = luaFun3.Call(30, 40);

            Debug.Log("呼叫ProcMyFunc3 ，結果=" + objArray[0]);

 

            object[] objArray2=luaFun4.Call(22,80);

            Debug.Log(string.Format("測試多返回數值 res1={0},res2={1},res3={2}",objArray2[0], objArray2[1], objArray2[2]));

 

        }

 

官方使用建議：

A: 訪問lua全域性資料，特別是table以及function，代價比較大，建議

儘量少做，比如在初始化時把要呼叫的lua function獲取一次（對映到

delegate）後，儲存下來，後續直接呼叫該delegate即可。table也類似。

B: 如果lua實現的部分都以delegate和interface的方式提供，使用方

可以完全和xLua解耦： 由一個專門的模組負責xlua的初始化以及delegate、

interface的對映，然後把這些delegate和interface設定到要用到它們的地

方。

 

 

Lua呼叫C#

1. lua 訪問 C# 靜態屬性與 方法
基本方法：

使用CS開頭，例項化類。

在C#這樣new一個物件：

var newGameObj = new UnityEngine.GameObject();

對應到Lua是這樣：

local newGameObj = CS.UnityEngine.GameObject()
基本規則：

A: lua裡頭沒有new關鍵字。

B: 所有C#相關的都放到CS下，包括建構函式，靜態成員屬性、方法。

 如果有多個建構函式呢？

xlua支援過載，比如你要呼叫GameObject的帶一個string引數的構造函

數，這麼寫：

local newGameObj2 = CS.UnityEngine.GameObject('helloworld')
 

2. lua 訪問 C# 常用方式
 1. 方式1：訪問成員屬性與方法

讀成員屬性 testobj.DMF

寫成員屬性 testobj.DMF = 1024

呼叫成員方法 testobj:DMFunc()

注意:

lua中使用冒號，表示成員方法的呼叫。它自動完成把當前物件作為一

個引數，傳入方法。

lua中使用點，則表示靜態屬性與方法呼叫。它需要手工往方法中傳遞

當前物件。

 

2. 方式2：訪問父類屬性與方法

xlua支援（通過派生類）訪問基類的靜態屬性，靜態方法，（通過派生

類例項）訪問基類的成員屬性，成員方法。

 

3. 方式3: 訪問過載方法

Xlua 支援方法的過載，但為“有限過載”。直接通過不同的引數型別進

行過載函式的訪問，例如：

testobj：TestFunc(100)

testobj：TestFunc('hello')

將分別訪問整數引數的TestFunc和字串引數的TestFunc。
 

注意：

xlua只一定程度上支援過載函式的呼叫，因為lua的型別遠遠不如C#豐富，

存在一對多的情況，

比如C#的int，float，double都對應於lua的number，上面的例子中

TestFunc如果有這些過載引數，第一行將無法區分開來，只能呼叫到其中一

個（生成程式碼中排前面的那個）

 

 

3. lua 呼叫 C# 中帶參方法

 1. 方式1： C# 中可變引數方法

對於C#的如下方法：

void VariableParamsFunc(int a, params string[] strs)

可以在lua裡頭這樣呼叫：

testobj:VariableParamsFunc(5, 'hello', 'john')

 

 2. 方式2： C#結構體引數

lua 使用一個表，來對映C#的結構體。

 

 3. 方式3：C#介面引數

注意： 介面需要加入標記: [CSharpCallLua]

lua 使用一個表，來對映C#的介面。

 

 4. 方式4: C#委託引數

委託需要加入標記: [CSharpCallLua]

lua 使用一個函式，來對映C#的委託。

 

4. lua 接收 C# 方法返回的多個結果數值
 1. 基本規則: 引數的輸入輸出屬性（out，ref）

A: C#的普通引數算一個輸入形參，ref修飾的算一個輸入形參，out不算，

然後從左往右對應lua 呼叫的實參列表。

B: Lua呼叫返回值處理規則：

C#函式的返回值（如果有的話）算一個返回值，out算一個返回值，

ref算一個返回值，然後從左往右對應lua的多返回值。

 

5. lua 如何呼叫 C# 泛型方法
  基本規則：

lua 不直接支援C#的泛型方法，但可以通過擴充套件方法功能進行封裝後調

用。

 使用 Extension methods (擴充套件方法)技術就是C#中在不改變原始類的基

礎上，使用一種機制可以無限擴充套件這個類功能的機制。

Eg:

原始類為： A 擴充套件類為： Ext_A

注意： Ext_A 必須是一個靜態類，且擴充套件方法也必須是靜態的。方法的

引數中必須要有被擴充套件類作為其中一個引數，此引數前面必須有this 關鍵字

修飾。
 

6．Lua 呼叫其他 C# 知識點
  1. 引數帶預設值的方法

與C#呼叫有預設值引數的函式一樣，如果所給的實參少於形參，則會

用預設值補上。

 列舉型別

列舉值就像列舉型別下的靜態屬性一樣。

testobj:EnumTestFunc(CS.Tutorial.TestEnum.E1)

上面的EnumTestFunc函式引數是Tutorial.TestEnum型別的

 

 2. 委託與事件

delegate 屬性可以用一個luaFunction 來賦值（前面已經講過）

比如testobj裡頭有個事件定義是這樣：public event Action

TestEvent;

增加事件回撥

testobj:TestEvent('+', lua_event_callback)

移除事件回撥

testobj:TestEvent('-', lua_event_callback)

 

委託與事件（續）

delegate 使用 (呼叫，+，-)

注意：

A: 這裡lua中可以使用“+/-”操作符，來增加與減少一個委託的呼叫。

B: delegate 屬性可以用一個 luafunction 來賦值。

 

 委託與事件（續）

event使用

Eg:

public event Action TestEvent;

增加事件回撥：

testObj: TestEvent('+',lua_event_callback)

移除事件回撥：

testObj: TestEvent('-',lua_event_callback)

 

7. Lua 呼叫 C# 經驗總結

 1. 一： lua 呼叫C#，需要在Xlua中生成“適配程式碼”，則在這個類打入一個

[luaCallCSharp] 的標籤。

 二： 如果lua呼叫C#的系統API ，則無法拿到原始碼，無法打入標籤。則

使用“靜態列表”方式解決。

Eg:

public static List<Type> mymodule_LuaCallCS_List=new

List<Type>()

{

typeof(GameObject),

typeof(Dictionary<string,int>),

};

然後把以上程式碼放入一個靜態類中即可。

 

三： 實際開發過程中，lua 呼叫C# 用的比較多。

xlua 的優點體現的沒有必要每次改的時候，都要生成程式碼。主要原理是

依賴於編譯器環境下，利用反射來動態生成程式碼介面。

 四： 在標有“[XLua.LuaCallCSharp]”的C#類中，新增新的方法後，如

果是生成了程式碼類，則必須重新生成或者刪除，否則Xlua 用以前生成的，

進行註冊查詢，會出現lua 異常：“試圖訪問一個nil 的方法”

 

 

 

LuaCallCsharp.lua檔案

--詳細演示 lua Call C# 各種特性

--

print("測試lua檔案是否正確載入")

 

--[[  一： 學習 lua  呼叫 Unity 系統 API   ]]--

--1： lua 中例項化一個 Unity 的物件

local newGo=CS.UnityEngine.GameObject()

newGo.name="New GameObject"

 

--2: 查詢遊戲物體

--   學習lua 訪問Unity API 中靜態屬性與方法

local TxtGo=CS.UnityEngine.GameObject.Find("Txt_Logo");

--TxtGo.name="Modify Name"

 

--3: 得到遊戲物件上的元件，學習使用冒號與句號（"："，“.”）

local txtLogo=TxtGo:GetComponent("UnityEngine.UI.Text")

txtLogo.text="公告系統"

 

 

--[[  二： 學習 lua  呼叫自定義C#指令碼   ]]--

local IsInvoked=CS.XluaPro.IsInvokedClass

local classObj=IsInvoked()   --自動呼叫父類與子類的建構函式

 

--呼叫普通方法

--classObj:Mehtod1()                               --ok

--classObj.Mehtod1()                         --語法報錯！

--classObj.Mehtod1(classObj)               --語法OK

 

--呼叫父類的欄位與方法

--classObj:ShowFatherInfo();              --呼叫父類的方法

--print(classObj.FatherClassName)         --呼叫父類的公共欄位

--print(classObj.ChildClassName)          --呼叫子類的公共欄位

 

--測試呼叫C#方法過載

--classObj:Method2(10,20)

--classObj:Method2("abc","def")

 

--測試C#中帶有params 關鍵字的方法

--local intResult=classObj:Method3(20,70,"Hello ","World","EveryOne")

--print("呼叫parmas關鍵字的方法，返回數值= "..intResult)

 

--測試lua呼叫C#中帶有結構體引數的方法

--定義一個表

--myStructTable={x="C#語言",y="lua語言"}

--classObj:Method4(myStructTable)

 

 

相關推薦