Ejemplo n.º 1
0
 void checkIfTaskAndDoDirtWork(MethodInfo mi, Method_ReflectionMap newMethod)
 {
     if (typeof(Task).IsAssignableFrom(mi.ReturnType))
     {
         newMethod.IsAsync = true;
         newMethod.ReflectionToGetResultFromGenericTask = mi.ReturnType.GetProperty("Result").GetMethod;
     }
 }
Ejemplo n.º 2
0
        /// <summary>
        /// Ищем методы.
        /// </summary>
        /// <param name="t">Исследуемый тип, не путать с InspectedType, ведь с погружением в его поля это будет их тип, соответственно.</param>
        /// <param name="funcToGetLocalInstanceFromGlobal">Делегат для получения объекта с типом t из InspectedType.</param>
        void inspectMetods(string prefix, string realNamePrefix, Type t, Func <object, object> funcToGetLocalInstanceFromGlobal)
        {
            var methodInfoList = getAllMethods(t);

            foreach (var item in methodInfoList)
            {
                var attr = item.GetCustomAttribute(typeof(Method_ReflectionMapAttribute)) as Method_ReflectionMapAttribute;
                if (attr != null)
                {
                    var newInfo = new Info_ReflectionMap()
                    {
                        DisplayName = prefix + (attr.DisplayName ?? TextExtensions.ToUnderscoreCase(item.Name)),
                        RealName    = realNamePrefix + item.Name,
                        Description = attr.Description,
                    };

                    var newMethod = new Method_ReflectionMap()
                    {
                        Parameters = parameterInfoArrayToParamsArray(item.GetParameters()),
                        ReturnType = item.ReturnType
                    };
                    newMethod.InvokeAction = (globalInst, parameters) =>
                    {
                        var locInst = funcToGetLocalInstanceFromGlobal(globalInst);
                        return(item.Invoke(locInst, parameters));
                    };
                    checkIfTaskAndDoDirtWork(item, newMethod);


                    _longNameAndInfo.Add(
                        newInfo.DisplayName,
                        newInfo
                        );

                    _longNameAndMethod.Add(
                        newInfo.DisplayName,
                        newMethod
                        );
                }
            }
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Ищем простые свойства (которые будут сконвертированы в методы с приставкой get и set.
        /// </summary>
        /// <param name="t">Исследуемый тип, не путать с InspectedType, ведь с погружением в его поля это будет их тип, соответственно.</param>
        /// <param name="funcToGetLocalInstanceFromGlobal">Делегат для получения объекта с типом t из InspectedType.</param>
        void inspectSimpleProps(string prefix, string realNamePrefix, Type t, Func <object, object> funcToGetLocalInstanceFromGlobal)
        {
            //Dictionary<string, MethodInfo_ReflectionMap> res =new Dictionary<string, MethodInfo_ReflectionMap>();
            foreach (var item in t.GetProperties())
            {
                var attr = item.GetCustomAttribute(typeof(SimpleProp_ReflectionMapAttribute)) as SimpleProp_ReflectionMapAttribute;
                if (attr != null)
                {
                    if (attr.CanGet && item.CanRead)
                    {
                        var newInfo = new Info_ReflectionMap()
                        {
                            DisplayName = prefix + ("get_" + (attr.DisplayName ?? TextExtensions.ToUnderscoreCase(item.Name))),
                            RealName    = realNamePrefix + item.Name,
                            Description = attr.Description
                        };

                        var newMethod = new Method_ReflectionMap()
                        {
                            Parameters = new Parameter[] { },
                            ReturnType = item.PropertyType,
                            Kind       = MethodKind.PropertyGetter
                        };

                        var getter = item.GetMethod;
                        newMethod.InvokeAction = (globalInst, parameters) =>
                        {
                            var locInst = funcToGetLocalInstanceFromGlobal(globalInst);
                            return(getter.Invoke(locInst, parameters));
                        };
                        checkIfTaskAndDoDirtWork(getter, newMethod);

                        _longNameAndInfo.Add(
                            newInfo.DisplayName,
                            newInfo
                            );


                        _longNameAndMethod.Add(
                            newInfo.DisplayName,
                            newMethod
                            );
                    }

                    if (attr.CanSet && item.CanWrite)
                    {
                        var newInfo = new Info_ReflectionMap()
                        {
                            DisplayName = prefix + ("set_" + (attr.DisplayName ?? TextExtensions.ToUnderscoreCase(item.Name))),
                            RealName    = realNamePrefix + "Set" + item.Name,
                            Description = attr.Description
                        };

                        var param = new Parameter
                        {
                            ParamType = item.PropertyType,
                            ParamName = "val"
                        };

                        var newMethod = new Method_ReflectionMap()
                        {
                            Parameters = new Parameter[] { param },
                            ReturnType = typeof(void),
                            Kind       = MethodKind.PropertySetter
                        };


                        var setter = item.SetMethod;
                        newMethod.InvokeAction = (globalInst, parameters) =>
                        {
                            var locInst = funcToGetLocalInstanceFromGlobal(globalInst);
                            return(setter.Invoke(locInst, parameters));
                        };
                        checkIfTaskAndDoDirtWork(setter, newMethod);

                        _longNameAndInfo.Add(
                            newInfo.DisplayName,
                            newInfo
                            );


                        _longNameAndMethod.Add(
                            newInfo.DisplayName,
                            newMethod
                            );
                    }
                }
            }
        }