コード例 #1
0
    public bool CheckExistMethod(CLRSharp.ICLRType rType, string rFuncName, params object[] rArgs)
    {
        var rList = MatchParamList(rArgs);

        var method = rType.GetMethod(rFuncName, rList);

        if (method != null)
        {
            return(true);
        }
        else
        {
            return(false);
        }
    }
コード例 #2
0
    public bool TryGetMethod(CLRSharp.ICLRType rType, string rFuncName, out CLRSharp.IMethod outMethod, params object[] rArgs)
    {
        var rList = MatchParamList(rArgs);

        outMethod = rType.GetMethod(rFuncName, rList);

        if (outMethod != null)
        {
            return(true);
        }
        else
        {
            return(false);
        }
    }
コード例 #3
0
    public object CreateScriptObject(CLRSharp.ICLRType rType, params object[] rArgs)
    {
        var rList = MatchParamList(rArgs);

        CLRSharp.IMethod rCtor = rType.GetMethod(".ctor", rList);

        if (rCtor == null)
        {
            Debug.LogError("Create Script Object failed, check full type name and param list");
            return(null);
        }

        object rObj = rCtor.Invoke(context, null, null);

        return(rObj);
    }
コード例 #4
0
    public bool TryGetType(string rName, out CLRSharp.ICLRType outType)
    {
        string fullTypeName = "HotFixCode." + rName;


        outType = env.GetType(fullTypeName);

        if (outType != null)
        {
            return(true);
        }
        else
        {
            Debug.LogError("Get CLRType failed, check full type name:>" + rName);
            return(false);
        }
    }
コード例 #5
0
    // Use this for initialization
    void Start()
    {
        //创建CLRSharp环境
        env = new CLRSharp.CLRSharp_Environment(new LSharpLogger());

        //加载L#模块
        TextAsset dll = Resources.Load("Controller.dll") as TextAsset;
        TextAsset pdb = Resources.Load("Controller.pdb") as TextAsset;

        System.IO.MemoryStream msDll = new System.IO.MemoryStream(dll.bytes);
        System.IO.MemoryStream msPdb = new System.IO.MemoryStream(pdb.bytes);
        //env.LoadModule (msDll);//如果无符号是pdb的话,第二个参数传null
        env.LoadModule(msDll, msPdb, new Mono.Cecil.Pdb.PdbReaderProvider());        //Pdb
        //env.LoadModule(msDll, msMdb, new Mono.Cecil.Mdb.MdbReaderProvider());//如果符号是Mdb格式
        Debug.Log("LoadModule Controller.dll done.");

        //step01建立一个线程上下文,用来模拟L#的线程模型,每个线程创建一个即可。
        CLRSharp.ThreadContext context = new CLRSharp.ThreadContext(env);
        Debug.Log("Create ThreadContext for L#.");

        //step02取得想要调用的L#类型
        CLRSharp.ICLRType wantType = env.GetType("Controller.Entry");        //用全名称,包括命名空间
        Debug.Log("GetType:" + wantType.Name);
        //和反射代码中的Type.GetType相对应

        //step03 静态调用
        //得到类型上的一个函数,第一个参数是函数名字,第二个参数是函数的参数表,这是一个没有参数的函数
        CLRSharp.IMethod method01 = wantType.GetMethod("Log", CLRSharp.MethodParamList.constEmpty());
        method01.Invoke(context, null, null);        //第三个参数是object[] 参数表,这个例子不需要参数
        //这是个静态函数调用,对应到代码他就是HotFixCode.TestClass.Test1();

        ////step04 成员调用
        ////第二个测试程序是一个成员变量,所以先要创建实例
        //CLRSharp.IMethod methodctor = wantType.GetMethod(".ctor", CLRSharp.MethodParamList.constEmpty());//取得构造函数
        //object typeObj = methodctor.Invoke(context, null, null);//执行构造函数
        ////这几行的作用对应到代码就约等于 HotFixCode.TestClass typeObj =new HotFixCode.TestClass();
        //CLRSharp.IMethod method02 = wantType.GetMethod("Test2", CLRSharp.MethodParamList.constEmpty());
        //method02.Invoke(context, typeObj, null);
        ////这两行的作用就相当于 typeOBj.Test2();
        //
        //var list = CLRSharp.MethodParamList.Make(env.GetType(typeof(int)), env.GetType(typeof(string)));
        //CLRSharp.IMethod method03 = wantType.GetMethod("Test2", list);
        //method03.Invoke(context, typeObj, new object[] { 1234, "abcddd" });
        ////这两行的作用就相当于 typeOBj.Test2(1234,"abcddd");
    }
コード例 #6
0
    CLRSharp.MethodParamList MatchParamList(params object[] rArgs)
    {
        CLRSharp.MethodParamList rList;
        if (rArgs.Length > 0)
        {
            CLRSharp.ICLRType[] rClrTypes = new CLRSharp.ICLRType[rArgs.Length];
            for (int i = 0; i < rArgs.Length; i++)
            {
                var arg     = rArgs[i];
                var clrType = env.GetType(arg.GetType());
                rClrTypes[i] = clrType;
            }
            rList = CLRSharp.MethodParamList.Make(rClrTypes);
        }
        else
        {
            rList = CLRSharp.MethodParamList.constEmpty();
        }

        return(rList);
    }
コード例 #7
0
ファイル: Form1.cs プロジェクト: sjb8100/LSharp
        private void Form1_Load(object sender, EventArgs e)
        {
            //创建CLRSharp环境
            env = new CLRSharp.CLRSharp_Environment(this);

            //加载L#模块
            var dll = System.IO.File.ReadAllBytes("testdll01.dll");
            var pdb = System.IO.File.ReadAllBytes("testdll01.pdb");

            System.IO.MemoryStream msDll = new System.IO.MemoryStream(dll);
            System.IO.MemoryStream msPdb = new System.IO.MemoryStream(pdb);
            //env.LoadModule (msDll, null);//不需要pdb的话,第二个参数传null
            env.LoadModule(msDll, msPdb);
            Log("LoadModule HotFixCode.dll done.");

            //step01建立一个线程上下文,用来模拟L#的线程模型,每个线程创建一个即可。
            CLRSharp.ThreadContext context = new CLRSharp.ThreadContext(env);
            Log("Create ThreadContext for L#.");

            //step02取得想要调用的L#类型
            CLRSharp.ICLRType wantType = env.GetType("HoxFixCode.TestClass", null);//用全名称,包括命名空间
            Log("GetType:" + wantType.Name);
            //和反射代码中的Type.GetType相对应

            //step03 静态调用
            //得到类型上的一个函数,第一个参数是函数名字,第二个参数是函数的参数表,这是一个没有参数的函数
            CLRSharp.IMethod method01 = wantType.GetMethod("Test1", CLRSharp.MethodParamList.MakeEmpty());
            method01.Invoke(context, null, null);//第三个参数是object[] 参数表,这个例子不需要参数
            //这是个静态函数调用,对应到代码他就是HotFixCode.TestClass.Test1();

            //step04 成员调用
            //第二个测试程序是一个成员变量,所以先要创建实例
            CLRSharp.CLRSharp_Instance typeObj    = new CLRSharp.CLRSharp_Instance(wantType as CLRSharp.ICLRType_Sharp); //创建实例
            CLRSharp.IMethod           methodctor = wantType.GetMethod(".ctor", CLRSharp.MethodParamList.MakeEmpty());   //取得构造函数
            methodctor.Invoke(context, typeObj, null);                                                                   //执行构造函数
            //这几行的作用对应到代码就约等于 HotFixCode.TestClass typeObj =new HotFixCode.TestClass();
            CLRSharp.IMethod method02 = wantType.GetMethod("Test2", CLRSharp.MethodParamList.MakeEmpty());
            method02.Invoke(context, typeObj, null);
            //这两行的作用就相当于 typeOBj.Test2();
        }
コード例 #8
0
    protected virtual void Awake()
    {
        CLRSharp.ICLRType rType = null;
        var  rName = name.Replace("(Clone)", "");
        bool rGot  = Global.ScriptManager.TryGetType(rName, out rType);

        if (rGot)
        {
            if (_scriptObject == null)
            {
                _scriptObject = Global.ScriptManager.CreateScriptObject(rType);
            }
            isNeedStart       = Global.ScriptManager.CheckExistMethod(rType, startName);
            isNeedUpdate      = Global.ScriptManager.CheckExistMethod(rType, updateName);
            isNeedLateUpdate  = Global.ScriptManager.CheckExistMethod(rType, lateUpdateName);
            isNeedFixedUpdate = Global.ScriptManager.CheckExistMethod(rType, fixedUpdateName);
            isNeedOnDestroy   = Global.ScriptManager.CheckExistMethod(rType, onDestroyName);
            CallMethod("Awake", gameObject);
        }
        else
        {
            DebugConsole.Log("未找到" + name + "相应的脚本类");
        }
    }
コード例 #9
0
 public TestItem(CLRSharp.ICLRType type, string method)
 {
     this.type   = type;
     this.method = method;
 }
コード例 #10
0
    protected virtual void Awake()
    {
        if (!LShapClient.Instance.IsScriptInited)
        {
            LShapClient.Instance.Initialize();
        }

        CLRSharp.ICLRType rType = null;

        string typeName = name;
        var    i        = name.IndexOf(" ", 0);

        if (i >= 0)
        {
            typeName = name.Remove(i);
        }

        i = typeName.IndexOf("(", 0);
        if (i >= 0)
        {
            typeName = name.Remove(i);
        }

        bool rGot = LShapClient.Instance.TryGetType(typeName, out rType);

        if (rGot)
        {
            if (lShapObject == null)
            {
                SetLShapObject(LShapClient.Instance.CreateScriptObject(rType));
            }

            isNeedAwake     = LShapClient.Instance.CheckExistMethod(rType, awakeName, gameObject);
            isNeedStart     = LShapClient.Instance.CheckExistMethod(rType, startName);
            isNeedOnDestroy = LShapClient.Instance.CheckExistMethod(rType, onDestroyName);


            LShapClient.Instance.TryGetMethod(rType, updateName, out update);
            LShapClient.Instance.TryGetMethod(rType, lateUpdateName, out lateUpdate);
            LShapClient.Instance.TryGetMethod(rType, fixedUpdateName, out fixedUpdate);

            LShapClient.Instance.TryGetMethod(rType, onTriggerEnterName, out onTriggerEnter, new Collider());
            LShapClient.Instance.TryGetMethod(rType, onTriggerExitName, out onTriggerExit, new Collider());
            LShapClient.Instance.TryGetMethod(rType, onTriggerStayName, out onTriggerStay, new Collider());
            LShapClient.Instance.TryGetMethod(rType, onCollisionEnterName, out onCollisionEnter, new Collision());
            LShapClient.Instance.TryGetMethod(rType, onCollisionExitName, out onCollisionExit, new Collision());
            LShapClient.Instance.TryGetMethod(rType, onCollisionStayName, out onCollisionStay, new Collision());


            LShapClient.Instance.TryGetMethod(rType, onTriggerEnter2DName, out onTriggerEnter2D, new Collider2D());
            LShapClient.Instance.TryGetMethod(rType, onTriggerExit2DName, out onTriggerExit2D, new Collider2D());
            LShapClient.Instance.TryGetMethod(rType, onTriggerStay2DName, out onTriggerStay2D, new Collider2D());
            LShapClient.Instance.TryGetMethod(rType, onCollisionEnter2DName, out onCollisionEnter2D, new Collision2D());
            LShapClient.Instance.TryGetMethod(rType, onCollisionExit2DName, out onCollisionExit2D, new Collision2D());
            LShapClient.Instance.TryGetMethod(rType, onCollisionStay2DName, out onCollisionStay2D, new Collision2D());


            if (isNeedAwake)
            {
                CallMethod("Awake", gameObject);
            }
        }
        else
        {
            DebugConsole.Log("未找到" + name + "相应的脚本类");
        }
    }
コード例 #11
0
ファイル: ComUnitTest.cs プロジェクト: raymanyu/LSharpUnity
 public TestItem(CLRSharp.ICLRType type, string method)
 {
     this.type = type;
     this.method = method;
 }
コード例 #12
0
        private void Form1_Load(object sender, EventArgs e)
        {
            //创建CLRSharp环境
            env = new CLRSharp.CLRSharp_Environment(this);

            //加载L#模块
            var dll = System.IO.File.ReadAllBytes("testdll01.dll");
            var pdb = System.IO.File.ReadAllBytes("testdll01.pdb");

            System.IO.MemoryStream msDll = new System.IO.MemoryStream(dll);
            System.IO.MemoryStream msPdb = new System.IO.MemoryStream(pdb);
            //env.LoadModule (msDll);//不需要pdb的话
            bool useSystemAssm = false;

            if (useSystemAssm)
            {
                byte[] dllbytes = msDll.ToArray();
                byte[] pdbbytes = msPdb.ToArray();
                var    assem    = System.Reflection.Assembly.Load(dllbytes, pdbbytes); //用系统反射加载
                env.AddSerachAssembly(assem);                                          //直接搜索系统反射,此时L#不发挥作用,为了调试的功能
            }
            else
            {
                env.LoadModule(msDll, msPdb, new Mono.Cecil.Pdb.PdbReaderProvider());
            }
            Log("LoadModule HotFixCode.dll done.");
            env.RegCrossBind(new MyCrossBind());

            //step01建立一个线程上下文,用来模拟L#的线程模型,每个线程创建一个即可。
            CLRSharp.ThreadContext context = new CLRSharp.ThreadContext(env);
            context.SetNoTry = true;
            Log("Create ThreadContext for L#.");

            //step02取得想要调用的L#类型
            CLRSharp.ICLRType wantType = env.GetType("HoxFixCode.TestClass");//用全名称,包括命名空间
            Log("GetType:" + wantType.Name);
            //和反射代码中的Type.GetType相对应

            //step03 静态调用
            //得到类型上的一个函数,第一个参数是函数名字,第二个参数是函数的参数表,这是一个没有参数的函数
            CLRSharp.IMethod method01 = wantType.GetMethod("Test1", CLRSharp.MethodParamList.constEmpty());
            method01.Invoke(context, null, null);//第三个参数是object[] 参数表,这个例子不需要参数
            //这是个静态函数调用,对应到代码他就是HotFixCode.TestClass.Test1();

            //step04 成员调用
            //第二个测试程序是一个成员变量,所以先要创建实例
            //CLRSharp.CLRSharp_Instance typeObj = new CLRSharp.CLRSharp_Instance(wantType as CLRSharp.ICLRType_Sharp);//创建实例
            //上一句写的有问题,执行构造函数返回的才是 new出来的对象
            CLRSharp.IMethod methodctor = wantType.GetMethod(".ctor", CLRSharp.MethodParamList.constEmpty()); //取得构造函数
            //这里用object 就可以脚本和反射通用了
            object typeObj = methodctor.Invoke(context, null, null);                                          //执行构造函数

            //这几行的作用对应到代码就约等于 HotFixCode.TestClass typeObj =new HotFixCode.TestClass();
            CLRSharp.IMethod method02 = wantType.GetMethod("Test2", CLRSharp.MethodParamList.constEmpty());
            for (int i = 0; i < 5; i++)
            {
                method02.Invoke(context, typeObj, null);
            }
            //这两行的作用就相当于 typeOBj.Test2();

            //请注意,不要在初始化之后,再修改ParamList的内容
            CLRSharp.MethodParamList list = CLRSharp.MethodParamList.Make(

                env.GetType(typeof(int)),
                env.GetType(typeof(string))

                );
            CLRSharp.IMethod method03 = wantType.GetMethod("Test3", list);
            CallMethod(method03, typeObj, 345, "abbc");

            //获取TestClass.CreateMyI函数
            //public static Interface.IMyType CreateMyI()
            //{
            //    return new myi();
            //}
            CLRSharp.IMethod method04 = wantType.GetMethod("CreateMyI", CLRSharp.MethodParamList.constEmpty());
            var obj = method04.Invoke(context, null, null);

            Interface.IMyType got = obj as Interface.IMyType;
            //执行他其实返回的是脚本的类型,但是可以让他自动转型成 程序认识的类型
        }