Пример #1
0
        private static Action <T1, T2, T3> fromJSMethod <T1, T2, T3>(IServiceNode node, JavaScriptValue value)
        {
            var converter = node.GetService <IJSValueConverterService>();
            Action <T1, T2, T3> result = (T1 para1, T2 para2, T3 para3) =>
            {
                JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
                JavaScriptValue p2 = converter.ToJSValue <T2>(para2);
                JavaScriptValue p3 = converter.ToJSValue <T3>(para3);


                node.WithContext(() =>
                {
                    var caller = node.GetService <ICallContextService>().Caller;
                    p1.AddRef();
                    p2.AddRef();
                    p3.AddRef();
                    value.CallFunction(caller, p1, p2, p3);
                    p1.Release();
                    p2.Release();
                    p3.Release();
                });
            };

            return(result);
        }
Пример #2
0
        private static Action <T1, T2, T3, T4, T5> fromJSMethod <T1, T2, T3, T4, T5>(IServiceNode node, JavaScriptValue value)
        {
            var         converter = node.GetService <IJSValueConverterService>();
            IDisposable stub      = node.GetService <IGCSyncService>().CreateJsGCWrapper(value);
            Action <T1, T2, T3, T4, T5> result = (T1 para1, T2 para2, T3 para3, T4 para4, T5 para5) =>
            {
                JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
                JavaScriptValue p2 = converter.ToJSValue <T2>(para2);
                JavaScriptValue p3 = converter.ToJSValue <T3>(para3);
                JavaScriptValue p4 = converter.ToJSValue <T4>(para4);
                JavaScriptValue p5 = converter.ToJSValue <T5>(para5);


                node.WithContext(() =>
                {
                    var caller = node.GetService <ICallContextService>().Caller;
                    p1.AddRef();
                    p2.AddRef();
                    p3.AddRef();
                    p4.AddRef();
                    p5.AddRef();
                    value.CallFunction(caller, p1, p2, p3, p4, p5);
                    p1.Release();
                    p2.Release();
                    p3.Release();
                    p4.Release();
                    p5.Release();
                });
                GC.KeepAlive(stub);                  //keep referenced javascript value alive
            };

            return(result);
        }
Пример #3
0
        private static Action <T1, T2, T3, T4, T5, T6> fromJSMethod <T1, T2, T3, T4, T5, T6>(IServiceNode node, JavaScriptValue value)
        {
            var converter = node.GetService <IJSValueConverterService>();
            Action <T1, T2, T3, T4, T5, T6> result = (T1 para1, T2 para2, T3 para3, T4 para4, T5 para5, T6 para6) =>
            {
                JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
                JavaScriptValue p2 = converter.ToJSValue <T2>(para2);
                JavaScriptValue p3 = converter.ToJSValue <T3>(para3);
                JavaScriptValue p4 = converter.ToJSValue <T4>(para4);
                JavaScriptValue p5 = converter.ToJSValue <T5>(para5);
                JavaScriptValue p6 = converter.ToJSValue <T6>(para6);


                node.WithContext(() =>
                {
                    var caller = node.GetService <ICallContextService>().Caller;
                    p1.AddRef();
                    p2.AddRef();
                    p3.AddRef();
                    p4.AddRef();
                    p5.AddRef();
                    p6.AddRef();
                    value.CallFunction(caller, p1, p2, p3, p4, p5, p6);
                    p1.Release();
                    p2.Release();
                    p3.Release();
                    p4.Release();
                    p5.Release();
                    p6.Release();
                });
            };

            return(result);
        }
Пример #4
0
        private static Func <bool, T1, TResult> fromJSFunction <T1, TResult>(IServiceNode node, JavaScriptValue value)
        {
            var converter      = node.GetService <IJSValueConverterService>();
            var jsValueService = node.GetService <IJSValueService>();
            var callContext    = node.GetService <ICallContextService>();
            Func <bool, T1, TResult> result = (bool isConstruct, T1 para1) =>
            {
                JavaScriptValue p1 = converter.ToJSValue <T1>(para1);

                JavaScriptValue r = node.WithContext <JavaScriptValue>(() =>
                {
                    p1.AddRef();
                    JavaScriptValue resultValue;
                    if (isConstruct)
                    {
                        resultValue = jsValueService.ConstructObject(value, jsValueService.JSValue_Undefined, p1);
                    }
                    else
                    {
                        resultValue = jsValueService.CallFunction(value, callContext.Caller, p1);
                    }
                    p1.Release();
                    return(resultValue);
                });
                return(converter.FromJSValue <TResult>(r));
            };

            return(result);
        }
Пример #5
0
        private static Func <bool, T1, TResult> fromJSFunction <T1, TResult>(IServiceNode node, JavaScriptValue value)
        {
            var         converter           = node.GetService <IJSValueConverterService>();
            var         jsValueService      = node.GetService <IJSValueService>();
            var         callContext         = node.GetService <ICallContextService>();
            IDisposable stub                = node.GetService <IGCSyncService>().CreateJsGCWrapper(value);
            Func <bool, T1, TResult> result = (bool isConstruct, T1 para1) =>
            {
                JavaScriptValue p1 = converter.ToJSValue <T1>(para1);

                JavaScriptValue r = node.WithContext <JavaScriptValue>(() =>
                {
                    p1.AddRef();
                    JavaScriptValue resultValue;
                    if (isConstruct)
                    {
                        resultValue = jsValueService.ConstructObject(value, jsValueService.JSValue_Undefined, p1);
                    }
                    else
                    {
                        resultValue = jsValueService.CallFunction(value, callContext.Caller, p1);
                    }
                    p1.Release();
                    GC.KeepAlive(stub);//keep referenced javascript value alive
                    return(resultValue);
                });
                return(converter.FromJSValue <TResult>(r));
            };

            return(result);
        }
Пример #6
0
        private static Func <bool, T1, T2, T3, T4, T5, T6, T7, TResult> fromJSFunction <T1, T2, T3, T4, T5, T6, T7, TResult>(IServiceNode node, JavaScriptValue value)
        {
            var         converter      = node.GetService <IJSValueConverterService>();
            var         jsValueService = node.GetService <IJSValueService>();
            var         callContext    = node.GetService <ICallContextService>();
            IDisposable stub           = node.GetService <IGCSyncService>().CreateJsGCWrapper(value);
            Func <bool, T1, T2, T3, T4, T5, T6, T7, TResult> result = (bool isConstruct, T1 para1, T2 para2, T3 para3, T4 para4, T5 para5, T6 para6, T7 para7) =>
            {
                JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
                JavaScriptValue p2 = converter.ToJSValue <T2>(para2);
                JavaScriptValue p3 = converter.ToJSValue <T3>(para3);
                JavaScriptValue p4 = converter.ToJSValue <T4>(para4);
                JavaScriptValue p5 = converter.ToJSValue <T5>(para5);
                JavaScriptValue p6 = converter.ToJSValue <T6>(para6);
                JavaScriptValue p7 = converter.ToJSValue <T7>(para7);

                JavaScriptValue r = node.WithContext <JavaScriptValue>(() =>
                {
                    p1.AddRef();
                    p2.AddRef();
                    p3.AddRef();
                    p4.AddRef();
                    p5.AddRef();
                    p6.AddRef();
                    p7.AddRef();
                    JavaScriptValue resultValue;
                    if (isConstruct)
                    {
                        resultValue = jsValueService.ConstructObject(value, jsValueService.JSValue_Undefined, p1, p2, p3, p4, p5, p6, p7);
                    }
                    else
                    {
                        resultValue = jsValueService.CallFunction(value, callContext.Caller, p1, p2, p3, p4, p5, p6, p7);
                    }
                    p1.Release();
                    p2.Release();
                    p3.Release();
                    p4.Release();
                    p5.Release();
                    p6.Release();
                    p7.Release();
                    GC.KeepAlive(stub);//keep referenced javascript value alive
                    return(resultValue);
                });
                return(converter.FromJSValue <TResult>(r));
            };

            return(result);
        }
Пример #7
0
        private static Action fromJSMethod(IServiceNode node, JavaScriptValue value)
        {
            var    converter = node.GetService <IJSValueConverterService>();
            Action result    = () =>
            {
                node.WithContext(() =>
                {
                    var caller = node.GetService <ICallContextService>().Caller;

                    value.CallFunction(caller);
                });
            };

            return(result);
        }
Пример #8
0
        private static Action fromJSMethod(IServiceNode node, JavaScriptValue value)
        {
            var         converter = node.GetService <IJSValueConverterService>();
            IDisposable stub      = node.GetService <IGCSyncService>().CreateJsGCWrapper(value);
            Action      result    = () =>
            {
                node.WithContext(() =>
                {
                    var caller = node.GetService <ICallContextService>().Caller;

                    value.CallFunction(caller);
                });
                GC.KeepAlive(stub);                  //keep referenced javascript value alive
            };

            return(result);
        }
Пример #9
0
        private static Func <bool, T1, T2, T3, T4, T5, T6, TResult> fromJSFunction <T1, T2, T3, T4, T5, T6, TResult>(IServiceNode node, JavaScriptValue value)
        {
            var converter      = node.GetService <IJSValueConverterService>();
            var jsValueService = node.GetService <IJSValueService>();
            var callContext    = node.GetService <ICallContextService>();
            Func <bool, T1, T2, T3, T4, T5, T6, TResult> result = (bool isConstruct, T1 para1, T2 para2, T3 para3, T4 para4, T5 para5, T6 para6) =>
            {
                JavaScriptValue p1 = converter.ToJSValue <T1>(para1);
                JavaScriptValue p2 = converter.ToJSValue <T2>(para2);
                JavaScriptValue p3 = converter.ToJSValue <T3>(para3);
                JavaScriptValue p4 = converter.ToJSValue <T4>(para4);
                JavaScriptValue p5 = converter.ToJSValue <T5>(para5);
                JavaScriptValue p6 = converter.ToJSValue <T6>(para6);

                JavaScriptValue r = node.WithContext <JavaScriptValue>(() =>
                {
                    p1.AddRef();
                    p2.AddRef();
                    p3.AddRef();
                    p4.AddRef();
                    p5.AddRef();
                    p6.AddRef();
                    JavaScriptValue resultValue;
                    if (isConstruct)
                    {
                        resultValue = jsValueService.ConstructObject(value, jsValueService.JSValue_Undefined, p1, p2, p3, p4, p5, p6);
                    }
                    else
                    {
                        resultValue = jsValueService.CallFunction(value, callContext.Caller, p1, p2, p3, p4, p5, p6);
                    }
                    p1.Release();
                    p2.Release();
                    p3.Release();
                    p4.Release();
                    p5.Release();
                    p6.Release();
                    return(resultValue);
                });
                return(converter.FromJSValue <TResult>(r));
            };

            return(result);
        }
Пример #10
0
        private static Action <T1> fromJSMethod <T1>(IServiceNode node, JavaScriptValue value)
        {
            var         converter = node.GetService <IJSValueConverterService>();
            IDisposable stub      = node.GetService <IGCSyncService>().CreateJsGCWrapper(value);
            Action <T1> result    = (T1 para1) =>
            {
                JavaScriptValue p1 = converter.ToJSValue <T1>(para1);


                node.WithContext(() =>
                {
                    var caller = node.GetService <ICallContextService>().Caller;
                    p1.AddRef();
                    value.CallFunction(caller, p1);
                    p1.Release();
                });
                GC.KeepAlive(stub);                  //keep referenced javascript value alive
            };

            return(result);
        }