static DependencyInjectionLambdaGenerator() { CachedType argType = typeof(Container); dependencyMethod = argType .Query(t => t.GetMethod(nameof(Container.Resolve), new Type[] { typeof(Type) })); }
/// <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()); }
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); } }
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); }