static DependencyInjectionLambdaGenerator()
        {
            CachedType argType = typeof(Container);

            dependencyMethod = argType
                               .Query(t => t.GetMethod(nameof(Container.Resolve), new Type[] { typeof(Type) }));
        }
示例#2
0
        /// <summary>
        /// Uses Reflection to get MethodInfo for the Typed ExecutePlugin method. Also caches
        /// All reflection results to improve performance
        /// </summary>
        internal static CachedMethodInfo GetExecInfo(Type type)
        {
            var typeName = UniqueTypeName(type);

            if (MethodInfoCache.ContainsKey(typeName))
            {
                return(MethodInfoCache[typeName]);
            }

            var methodInfo = type.GetMethod("ExecutePlugin", BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);

            if (methodInfo == null)
            {
                throw new WorkflowEngineException("Plugin Doesn't have an ExecutePlugin method Definition");
            }

            var cachedInfo = new CachedMethodInfo
            {
                ParameterInfo = GetParamterInfo(methodInfo),
                Executable    = GetExecutable(methodInfo, type),
                PluginName    = UniqueTypeName(type, false),
                ReturnType    = GetReturnType(methodInfo),
                Version       = GetVersion(methodInfo)
            };

            MethodInfoCache[typeName] = cachedInfo;
            return(cachedInfo);
        }
        public void Assumption_Method()
        {
            var x = typeof(TestType <,>);

            var xConstructed = typeof(TestType <string, string>);

            CachedMethodInfo testMethod2 = x.GetMethod("TestMethod2");

            var parameters = testMethod2.Query(MethodBaseQueries.GetParameters);
        }
 public void OnClick()
 {
     CachedMethodInfo.Invoke(referenceModel.Model, null);
 }
        public Action <Container, object> CreateMethodInjectionLambda(Type targetType, CachedMethodInfo injectionMethod)
        {
            ParameterExpression containerArg         = Expression.Parameter(typeof(Container), "container");
            ParameterExpression injectionTarget      = Expression.Parameter(typeof(object), "injectionTarget");
            ParameterExpression typedInjectionTarget = Expression.Variable(targetType, "typedInjectionTarget");


            List <Expression> methodBody = new List <Expression>
            {
                Expression.Assign(typedInjectionTarget, Expression.Convert(injectionTarget, targetType)),
                Expression.Call(typedInjectionTarget,
                                injectionMethod,
                                BuildInjectionLambdaArguments(
                                    containerArg,
                                    injectionMethod.Query(MethodBaseQueries.GetParameters).Select(p => (CachedParameterInfo)p).ToArray()))
            };


            return(Expression
                   .Lambda <Action <Container, object> >(Expression.Block(new [] { typedInjectionTarget }, methodBody), containerArg, injectionTarget)
                   .Compile());
        }
示例#6
0
        public void RenderService(CachedType tService, object serviceObject)
        {
            Dictionary <int, CachedMethodInfo> choose = new Dictionary <int, CachedMethodInfo>();

            int i = 1;

            IEnumerable <CachedMethodInfo> methods = tService.Query(TypeQueries.GetMethods).Select(m => (CachedMethodInfo)m);

            foreach (var methodInfo in methods)
            {
                choose[i] = methodInfo;
                i++;
            }

            while (true)
            {
                _console.WriteLine($"{_translationProvider.Translate("ServiceOfType")} {tService.InnerMetaData.FullName}:");

                i = 1;

                if (methods.Any())
                {
                    _console.WriteLine($"{_translationProvider.Translate("Methods")}:");

                    foreach (var methodInfo in methods)
                    {
                        _console.WriteLine($"{i}) {methodInfo.InnerMetaData.Name}");
                        i++;
                    }
                }

                string input;

                _console.WriteLine($"{_translationProvider.Translate("ChoosePropertyOrMethod")}");

                input = _console.ReadLine();

                if (input == "x")
                {
                    return;
                }

                int choice;

                try
                {
                    choice = int.Parse(input);
                }
                catch
                {
                    continue;
                }

                if (choice > choose.Count)
                {
                    _console.WriteLine($"{choice} {_translationProvider.Translate("IsOutOfRange")}");
                    continue;
                }

                CachedMethodInfo metaData = choose[choice];

                CreateMethodInvocation(metaData, serviceObject);
            }
        }
示例#7
0
        private void CreateMethodInvocation(CachedMethodInfo cachedMethodInfo, object o)
        {
            var parameters = cachedMethodInfo.Query(MethodBaseQueries.GetParameters);

            Dictionary <ParameterInfo, object> arguments = new Dictionary <ParameterInfo, object>();

            foreach (var parameterInfo in parameters)
            {
                CachedType parameterType = parameterInfo.ParameterType;

                if (parameterType.InnerMetaData == typeof(string))
                {
                    _console.WriteLine(string.Format(_translationProvider.Translate("ProvideArgumentOfType"), parameterInfo.Name, parameterType.InnerMetaData.FullName));

                    string argument = _console.ReadLine();

                    arguments[parameterInfo] = argument;
                }
                else if (parameterType.InnerMetaData.IsPrimitive)
                {
                    _console.WriteLine(string.Format(_translationProvider.Translate("ProvideArgumentOfType"), parameterInfo.Name, parameterType.InnerMetaData.FullName));

                    var parseMethod = GetParseMethod(parameterType);

                    object parsedValue = null;

                    string argument = _console.ReadLine();

                    while (true)
                    {
                        try
                        {
                            parsedValue = parseMethod.InnerMetaData.Invoke(null, new object[] { argument });
                            break;
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e.ToString());
                            _console.WriteLine(string.Format(_translationProvider.Translate("ProvideArgumentOfType"), parameterInfo.Name, parameterType.InnerMetaData.FullName));
                        }
                    }

                    arguments[parameterInfo] = parsedValue;
                }
                else if (parameterType.InnerMetaData.IsClass || parameterType.InnerMetaData.IsInterface)
                {
                    var obj = Activator.Activate(parameterType);

                    EditObject(parameterType, obj, out obj);

                    arguments[parameterInfo] = obj;
                }
            }

            var args = parameters.Select(p => arguments[p]).ToArray();

            object result = cachedMethodInfo.InnerMetaData.Invoke(o, args);

            if (cachedMethodInfo.InnerMetaData.ReturnType == typeof(void))
            {
                return;
            }
            else if (cachedMethodInfo.InnerMetaData.ReturnType.IsPrimitive || cachedMethodInfo.InnerMetaData.ReturnType == typeof(string))
            {
                _console.WriteLine(_translationProvider.Translate("ReturnValue"));
                _console.WriteLine(result.ToString());
                return;
            }

            EditObject(cachedMethodInfo.InnerMetaData.ReturnType, result, out object v);
        }