示例#1
0
        private static void Add <T>(
            Expression <Func <T, object> > expr,
            string functionFormat,
            MethodCallStyle preferredCallStyle            = MethodCallStyle.Static,
            Func <Expression, Expression> postResolveHook = null,
            bool localExec = false)
        {
            var memberInfo = ReflectionHelper.GetInstanceMemberInfo(expr);

            var memberMapping = MemberMapping.Parse(memberInfo, functionFormat, preferredCallStyle, postResolveHook, localExec);

            nameToMemberMappingDict.GetOrCreate(memberMapping.Name + memberMapping.ArgumentCount).Add(memberMapping);
            metadataTokenToMemberMappingDict[memberMapping.Member.UniqueToken()] = memberMapping;
        }
示例#2
0
 private MemberMapping(
     MemberInfo member,
     string name,
     IList <int> argumentOrder,
     string staticCallFormat,
     string chainedCallFormat,
     MethodCallStyle preferredCallStyle,
     Func <Expression, Expression> postResolveHookFunction,
     bool localExecutionPreferred)
 {
     Member                       = member;
     Name                         = name;
     ArgumentOrder                = argumentOrder;
     StaticCallFormat             = staticCallFormat;
     ChainedCallFormat            = chainedCallFormat;
     PreferredCallStyle           = preferredCallStyle;
     this.postResolveHookFunction = postResolveHookFunction;
     LocalExecutionPreferred      = localExecutionPreferred;
 }
示例#3
0
            public static MemberMapping Parse(
                MemberInfo member,
                string odataMethodFormat,
                MethodCallStyle preferredCallStyle,
                Func <Expression, Expression> postResolveHookFunction,
                bool localExecutionPreferred)
            {
                var name     = odataMethodFormat.Split('(').First();
                var argOrder = GetArgumentOrder(odataMethodFormat);

                var memberAsMethod = member as MethodInfo;

                if (memberAsMethod != null)
                {
                    if (memberAsMethod.IsGenericMethod &&
                        memberAsMethod.GetGenericArguments().Any(x => x == typeof(WildcardType)))
                    {
                        member = memberAsMethod.GetGenericMethodDefinition();
                    }
                }

                if (HasWildcardArgument(member.DeclaringType))
                {
                    var memberLocal = member;
                    member =
                        member.DeclaringType.GetGenericTypeDefinition().GetMembers()
                        .First(x => x.UniqueToken() == memberLocal.UniqueToken());
                }

                var argOrderArray = argOrder.ToArray();
                var extensionMethodFormatString = CreateChainedCallFormatString(name, argOrderArray);

                return(new MemberMapping(
                           member,
                           name,
                           argOrderArray,
                           odataMethodFormat,
                           extensionMethodFormatString,
                           preferredCallStyle,
                           postResolveHookFunction,
                           localExecutionPreferred));
            }