调用协同程序

LuaCoroutine.lua.txt

  1.     local util = require "xlua.util" -- 加载 Resources/xlua/util.lua.txt
  3.     local coroutineInstance = CS.UnityEngine.GameObject.FindObjectOfType(typeof(CS.shenjun.Coroutine))
  5.     local function async_yield_return(to_yield, cb)
  6.         coroutineInstance:InvokeSpawn(to_yield, cb)
  7.     end
  9.     -- 将调用C#协同的方法 转换为可以在lua协同中调用的方法 yield_return需要在lua协同中执行
  10.     local yield_return = util.async_to_sync(async_yield_return)
  12.     local function coroutine_callback()
  13.         print("lua coroutine over! callback done!")
  14.     end
  16.     local function co_function()
  17.         print("lua coroutine start")
  18.         local wt = CS.UnityEngine.WaitForSeconds(3)
  19.         yield_return(wt, coroutine_callback)
  20.     end
  22.     -- local co = coroutine.create(co_function)
  24.     function Start()
  25.         -- coroutine.resume(co)
  26.         util.coroutine_call(co_function)()
  27.     end
  42.     --[===[  lua coroutine 语法
  44.     --[[ 协同案例1 （基本语法）
  46.     fun1 = function()
  47.         print("hello")
  48.     end
  50.     -- 创建一个协同程序 co
  51.     co = coroutine.create(fun1)
  53.     -- 协同程序的4种状态 suspended、running、dead、normal
  54.     -- 创建完协同程序以后，处于suspended状态
  55.     print("status : ", coroutine.status(co))    
  57.     -- 启动协同程序（第一次唤醒）
  58.     coroutine.resume(co)
  59.     -- 协同程序运行完以后，处于dead状态，再次执行没效果
  60.     print("status : ", coroutine.status(co))
  62.     -- 再次唤醒已经dead的协同程序，无反应，说明不会再次执行了
  63.     coroutine.resume(co)
  64.     print("status : ", coroutine.status(co))
  66.     -- 协同程序处理dead状态，再次唤醒，返回false及一条错误信息
  67.     print(coroutine.resume(co))
  69.     ]]
  72.     --[[ 协同案例2 （yield方法）
  74.     -- 协同的强大之处 coroutine.yield()
  75.     -- 方法中有yield语句
  76.     -- 作用：让一个运行中的程序挂起，而之后可以恢复它的运行
  78.     co = coroutine.create(function() 
  79.             print("start coroutine function")
  80.             for i=1, 3 do
  81.                 print("co :", i)
  82.                 coroutine.yield()
  83.             end
  84.          end)
  86.     -- 处于suspended状态
  87.     print(coroutine.status(co))
  89.     -- 第一次唤醒，运行到yield方法时返回，挂起发生在yield调用中
  90.     coroutine.resume(co)  -- 打印1
  91.     print("1", coroutine.status(co))
  93.     -- 第二次唤醒，从上一次的yield的调用中返回，继续执行，碰到yield再挂起
  94.     coroutine.resume(co)  -- 打印2
  95.     print("2", coroutine.status(co))
  97.     -- 第三次唤醒
  98.     coroutine.resume(co)  -- 打印3
  99.     print("3", coroutine.status(co))
  101.     print("3-4", coroutine.status(co))  -- suspended状态
  103.     -- 第四次唤醒
  104.     coroutine.resume(co)  -- 什么都不打印
  105.     print("4", coroutine.status(co))
  107.     --]]
  112.     -- 当一个协同程序A唤醒一个协同程序B时，协同程序A就处于一个特殊状态，
  113.     -- 既不是挂起状态（无法继续A的执行），也不是运行状态（是B在运行）。
  114.     -- 所以将这时的状态称为“正常”状态。
  116.     -- Lua的协同程序还具有一项有用的机制，就是可以通过一对resume-yield来交换数据。
  121.     --[[ 协同案例3 （带参数协同）
  123.     -- 创建一个带参数的协同程序
  124.     co = coroutine.create(function(a, b)
  125.             for i=1,3 do
  126.                 print("co", a, b, i)
  127.                 coroutine.yield()
  128.             end
  130.          end)
  132.     -- 第一次唤醒 参数1，2传给function
  133.     coroutine.resume(co, 10, 20)   -- 缺少参数使用nil，多余的参数舍弃
  135.     -- 第二次唤醒
  136.     coroutine.resume(co, 100, 200) -- 传入100，200无效，有其他用途
  138.     --]]
  141.     --[[ 协同案例4 （resume的返回值）
  143.     co = coroutine.create(function(a, b) 
  144.             coroutine.yield(a + b, a - b)
  145.             return 6, 7
  146.          end)
  148.     -- 第一次唤醒
  149.     -- 在resume的返回值中，第一个返回值为true表示没有错误
  150.     -- 第2个返回值以及之后的，都对应yield传入的参数
  151.     print(coroutine.resume(co, 10, 3))  -- true  13  7
  152.     -- 当一个协同程序结束时，它的所有返回值都作为resume的返回值。
  153.     print(coroutine.resume(co))         -- true  6   7
  154.     --]]
  157.     --[[ 协同案例5 yield的返回值
  159.     co = coroutine.create(function()
  160.             print("co", coroutine.yield("yield"))
  161.          end)
  163.     -- 第一次唤醒，传入的参数“a”是传给方法的，由于方法没有参数，所以舍弃“a”
  164.     print("1", coroutine.resume(co, "a"))   -- "1"  true  yield
  166.     -- 第二次唤醒，传入的参数1，2，作为yield的额外返回值使用（yield返回的额外值就是对应resume传入的参数）
  167.     print("2", coroutine.resume(co, 1, 2))  -- "co"  1  2  -- "2"  true
  169.     print("3", coroutine.resume(co, 100, 200)) -- "3"  false  cannot resume dead coroutine
  170.     --]]
  173.     --[[ *协同案例6* 协同程序的嵌套使用（管道与过滤器）
  175.     -- 唤醒传入的迭代器
  176.     function receive(prod)
  177.         local status, value = coroutine.resume(prod);
  178.         return value;
  179.     end
  181.     funcition send(x)
  182.         coroutine.yield(x)
  183.     end
  185.     -- 返回一个挂起的协同程序 协同程序中需要有yield
  186.     function producer()
  187.         return coroutine.create(function()
  188.             while true do
  189.                 local x = io.read
  190.                 send(x)                 -- 产生新值
  191.             end
  192.         end)
  193.     end
  195.     function filter(prod)
  196.         return coroutine.create(function() 
  197.             for line = 1, math.huge do
  198.                 local x = receive(prod) -- 接收producer产生的值
  199.                 x = string.format("%5d %s", line, x)
  200.                 send(x)                 -- 把新值发送给消费者
  201.             end
  202.         end)
  203.     end
  205.     function consumer(prod)
  206.         while true do
  207.             local x = receive(prod)     -- 获取新值
  208.             io.write(x, "\n")           -- 消费新值
  209.         end
  210.     end
  212.     -- 运行代码
  213.     consumer(filter(producer))
  215.     --]]
  217.     ]===]

LuaCoroutine.cs

  1.     /*
  2.      *  created by shenjun
  3.      */
  5.     using System.Collections;
  6.     using System.Collections.Generic;
  7.     using UnityEngine;
  8.     using XLua;
  10.     namespace shenjun
  11.     {
  12.         [LuaCallCSharp]
  13.         public class Coroutine : MonoBehaviour {
  15.             LuaEnv luaEnv = new LuaEnv();
  17.             void Start () {
  18.                 luaEnv.DoString("require 'LuaCoroutine'");
  19.                 System.Action luaStart = luaEnv.Global.Get<System.Action>("Start");
  21.                 if (null != luaStart)
  22.                     luaStart();
  23.             }
  25.             void Update () {
  27.             }
  29.             private void OnDestroy()
  30.             {
  31.                 luaEnv.Dispose();
  32.             }
  34.             public void InvokeSpawn(object yield_return, System.Action callback)
  35.             {
  36.                 StartCoroutine(SpawnObj(yield_return, callback));
  37.             }
  39.             IEnumerator SpawnObj(object yield_return, System.Action callback)
  40.             {
  41.                 for (int i = 0; i < 10; i++)
  42.                 {
  43.                     GameObject go = GameObject.CreatePrimitive(PrimitiveType.Sphere);
  44.                     go.transform.position = Random.insideUnitSphere * 5;
  45.                     if(yield_return is IEnumerator)
  46.                     {
  47.                         yield return StartCoroutine(yield_return as IEnumerator);
  48.                     }
  49.                     else
  50.                     {
  51.                         yield return yield_return;
  52.                     }
  53.                 }
  54.                 callback();
  55.             }
  56.         }
  58.         [LuaCallCSharp]
  59.         public static class CoroutineConfig
  60.         {
  61.             public static List<System.Type> LuaCallCSharp
  62.             {
  63.                 get{
  64.                     return new List<System.Type>() 
  65.                     { 
  66.                         typeof(WaitForSeconds)
  67.                     };
  68.                 }
  69.             }
  70.         }
  71.     }

?