コード例 #1
0
        /// <summary>
        /// Filters the source collection using the passed query parameters.
        /// </summary>
        /// <param name="source">The source items to filter.</param>
        /// <param name="query">The query parameters defining the filter.</param>
        /// <typeparam name="T">The <see cref="Type"/> of items in the source collection.</typeparam>
        /// <returns>A filtered and projected enumeration of the source collection.</returns>
        public static IQueryable <object> Filter <T>(this IEnumerable <T> source, NameValueCollection query)
        {
            CustomContract.Requires <ArgumentNullException>(source != null);
            CustomContract.Requires <ArgumentNullException>(query != null);

            var parser = new ParameterParser <T>();

            return(Filter(source, parser.Parse(query)));
        }
コード例 #2
0
        /// <summary>
        /// Adds the defined mapping to the mapper.
        /// </summary>
        /// <typeparam name="TSource">The source parameter type.</typeparam>
        /// <typeparam name="TTarget">The target parameter type.</typeparam>
        /// <returns>An instance of a <see cref="PredicateMapper"/>.</returns>
        public PredicateMapper And <TSource, TTarget>()
        {
            CustomContract.Ensures(CustomContract.Result <PredicateMapper>() != null);

            if (_converters.All(x => x.SourceType != typeof(TSource)))
            {
                _converters.Add(new PredicateConverter <TSource, TTarget>());
            }

            return(this);
        }
コード例 #3
0
        public static bool IsAnonymousType(this Type type)
        {
            CustomContract.Requires <ArgumentNullException>(type != null);

            return(KnownAnonymousTypes.GetOrAdd(
                       type,
                       t => t.GetCustomAttribute <CompilerGeneratedAttribute>() != null &&
                       t.IsGenericType() &&
                       t.Name.Contains("AnonymousType") && (t.Name.StartsWith("<>") || t.Name.StartsWith("VB$")) &&
                       (t.Attributes() & TypeAttributes.NotPublic) == TypeAttributes.NotPublic));
        }
コード例 #4
0
        private static MemberInfo CheckFrontingProperty(MemberInfo field)
        {
            CustomContract.Requires(field != null);

            var declaringType = field.DeclaringType;

            var correspondingProperty = declaringType.GetProperties()
                                        .FirstOrDefault(x => string.Equals(x.Name, field.Name.Replace("_", string.Empty), StringComparison.OrdinalIgnoreCase));

            return(correspondingProperty ?? field);
        }
コード例 #5
0
        public IQueryable <object> Filter(IEnumerable <T> model)
        {
            var result = _filterExpression != null
                                ? model.AsQueryable().Where(_filterExpression)
                                : model.AsQueryable();

            CustomContract.Assert(result != null);

            if (_sortDescriptions.Any())
            {
                var isFirst = true;
                foreach (var sortDescription in _sortDescriptions.Where(x => x != null))
                {
                    if (isFirst)
                    {
                        isFirst = false;
                        result  = sortDescription.Direction == SortDirection.Ascending
                                                        ? result.OrderBy(sortDescription.KeySelector)
                                                        : result.OrderByDescending(sortDescription.KeySelector);
                    }
                    else
                    {
                        var orderedEnumerable = result as IOrderedQueryable <T>;

                        CustomContract.Assume(orderedEnumerable != null);

                        result = sortDescription.Direction == SortDirection.Ascending
                                                                        ? orderedEnumerable.ThenBy(sortDescription.KeySelector)
                                                                        : orderedEnumerable.ThenByDescending(sortDescription.KeySelector);
                    }
                }
            }

            if (_skip > 0)
            {
                CustomContract.Assume(result != null);

                result = result.Skip(_skip);
            }

            if (_top > -1)
            {
                CustomContract.Assume(result != null);

                result = result.Take(_top);
            }

            CustomContract.Assume(_selectExpression == null || result != null);

            return(new UntypedQueryable <T>(result, _selectExpression));
        }
コード例 #6
0
        public static Tuple <Type, string> GetNameFromAlias(this IMemberNameResolver memberNameResolver, MemberInfo alias, Type sourceType)
        {
            CustomContract.Requires(sourceType != null);
            CustomContract.Requires(alias != null);
            CustomContract.Ensures(CustomContract.Result <Tuple <Type, string> >() != null);

            var source = sourceType.GetMembers()
                         .Select(x => new { Original = x, Name = memberNameResolver.ResolveName(x) })
                         .FirstOrDefault(x => x.Original.Name == alias.Name);

            return(source != null
                                           ? new Tuple <Type, string>(GetMemberType(source.Original), source.Name)
                                           : new Tuple <Type, string>(GetMemberType(alias), alias.Name));
        }
コード例 #7
0
        public static IOrderedQueryable <T> ThenByDescending <T>(this IOrderedQueryable <T> source, Expression keySelector)
        {
            CustomContract.Requires(source != null);
            CustomContract.Requires(keySelector != null);

            var propertyType  = keySelector.GetType().GetGenericArguments()[0].GetGenericArguments()[1];
            var orderbyMethod = typeof(Queryable).GetMethods(BindingFlags.Public | BindingFlags.Static).FirstOrDefault(x => x.Name == "ThenByDescending" && x.GetParameters().Length == 2);

            CustomContract.Assume(orderbyMethod != null);

            orderbyMethod = orderbyMethod.MakeGenericMethod(typeof(T), propertyType);

            return((IOrderedQueryable <T>)orderbyMethod.Invoke(null, new object[] { source, keySelector }));
        }
コード例 #8
0
        private static MethodBase GetGenericMethod(Type type, string name, Type[] typeArgs, Type[] argTypes, BindingFlags flags)
        {
            CustomContract.Requires(typeArgs != null);
            CustomContract.Requires(type != null);
            //CustomContract.Assume(Type.DefaultBinder != null);

            var typeArity = typeArgs.Length;
            var methods   = type.GetMethods()
                            .Where(m => m.Name == name)
                            .Where(m => m.GetGenericArguments().Length == typeArity)
                            .Where(m => m.GetParameters().Length == argTypes.Length &&
                                   m.GetParameters().All(p => p.GetCustomAttribute <ParamArrayAttribute>() == null &&
                                                         !(p.IsIn || p.IsOut || p.IsOptional)))
                            .Select(m => m.MakeGenericMethod(typeArgs));

            //return Type.DefaultBinder.SelectMethod(flags, methods.ToArray(), argTypes, null);
            return(methods.First());
        }
コード例 #9
0
        private static IEnumerable <CustomAttributeBuilder> CreateCustomAttributeBuilders(IEnumerable <CustomAttributeData> customAttributes)
        {
            CustomContract.Requires(customAttributes != null);

            var attributeBuilders = customAttributes
                                    .Select(
                x =>
            {
                var namedArguments  = x.NamedArguments;
                var properties      = namedArguments.Select(a => x.AttributeType.GetProperty(a.MemberName)).OfType <PropertyInfo>().ToArray();
                var values          = namedArguments.Select(a => a.TypedValue.Value).ToArray();
                var constructorArgs = x.ConstructorArguments.Select(a => a.Value).ToArray();
                var constructor     = x.Constructor;
                return(new CustomAttributeBuilder(constructor, constructorArgs, properties, values));
            });

            return(attributeBuilders);
        }
コード例 #10
0
        public static MethodInfo GetAnyAllMethod(string name, Type collectionType)
        {
            CustomContract.Requires(collectionType != null);

            var implementationType = GetIEnumerableImpl(collectionType);

            var elemType = implementationType.GetGenericArguments()[0];
            var predType = typeof(Func <,>).MakeGenericType(elemType, typeof(bool));

            var allMethod = (MethodInfo)GetGenericMethod(
                typeof(Enumerable),
                name,
                new[] { elemType },
                new[] { implementationType, predType },
                BindingFlags.Static);

            return(allMethod);
        }
コード例 #11
0
        public static Type GetIEnumerableImpl(Type type)
        {
            CustomContract.Requires(type != null);

            // Get IEnumerable implementation. Either type is IEnumerable<T> for some T,
            // or it implements IEnumerable<T> for some T. We need to find the interface.
            if (IsIEnumerable(type))
            {
                return(type);
            }

            var interfaces = type.FindInterfaces((m, o) => IsIEnumerable(m), null);

            CustomContract.Assume(interfaces.Count() > 0);

            var t = interfaces.First();

            return(t);
        }
コード例 #12
0
        private static Type GetMemberType(MemberInfo member)
        {
            CustomContract.Requires(member != null);

            switch (member.MemberType)
            {
            case MemberTypes.Field:
                return(((FieldInfo)member).FieldType);

            case MemberTypes.Property:
                return(((PropertyInfo)member).PropertyType);

            case MemberTypes.Method:
                return(((MethodInfo)member).ReturnType);

            default:
                throw new InvalidOperationException(member.MemberType + " is not resolvable");
            }
        }
コード例 #13
0
        private static void CreateProperty(TypeBuilder typeBuilder, KeyValuePair <string, MemberInfo> field)
        {
            CustomContract.Requires(typeBuilder != null);

            var propertyType = field.Value.MemberType == MemberTypes.Property
                                                                ? ((PropertyInfo)field.Value).PropertyType
                                                                : ((FieldInfo)field.Value).FieldType;
            var fieldBuilder = typeBuilder.DefineField("_" + field.Key, propertyType, FieldAttributes.Private);

            var propertyBuilder = typeBuilder.DefineProperty(field.Key, PropertyAttributes.None, propertyType, null);

            CustomContract.Assume(propertyBuilder != null, "Created above.");

            SetAttributes(propertyBuilder, field.Value);

            var getAccessor = typeBuilder.DefineMethod(
                "get_" + field.Key,
                GetSetAttr,
                propertyType,
                Type.EmptyTypes);

            var getIl = getAccessor.GetILGenerator();

            getIl.Emit(OpCodes.Ldarg_0);
            getIl.Emit(OpCodes.Ldfld, fieldBuilder);
            getIl.Emit(OpCodes.Ret);

            var setAccessor = typeBuilder.DefineMethod(
                "set_" + field.Key,
                GetSetAttr,
                null,
                new[] { propertyType });

            var setIl = setAccessor.GetILGenerator();

            setIl.Emit(OpCodes.Ldarg_0);
            setIl.Emit(OpCodes.Ldarg_1);
            setIl.Emit(OpCodes.Stfld, fieldBuilder);
            setIl.Emit(OpCodes.Ret);

            propertyBuilder.SetGetMethod(getAccessor);
            propertyBuilder.SetSetMethod(setAccessor);
        }
コード例 #14
0
        public static Tuple <Type, Expression> CreateMemberExpression(this IMemberNameResolver memberNameResolver, ParameterExpression parameter, IEnumerable <string> propertyChain, Type parentType, Expression propertyExpression)
        {
            CustomContract.Requires(parentType != null);
            CustomContract.Requires(propertyChain != null);

            foreach (var propertyName in propertyChain)
            {
                var name   = propertyName;
                var member = memberNameResolver.ResolveAlias(parentType, name);
                if (member != null)
                {
                    parentType         = GetMemberType(member);
                    propertyExpression = propertyExpression == null
                                                                                         ? Expression.MakeMemberAccess(parameter, member)
                                                                                         : Expression.MakeMemberAccess(propertyExpression, member);
                }
            }

            return(new Tuple <Type, Expression>(parentType, propertyExpression));
        }
コード例 #15
0
        private static void SetAttributes(PropertyBuilder propertyBuilder, MemberInfo memberInfo)
        {
            CustomContract.Requires(propertyBuilder != null);
            CustomContract.Requires(memberInfo != null);

            var customAttributeBuilders = PropertyAttributeBuilders
                                          .GetOrAdd(
                memberInfo,
                p =>
            {
                var customAttributes = p.GetCustomAttributesData();
                return(CreateCustomAttributeBuilders(customAttributes).ToArray());
            });

            CustomContract.Assume(customAttributeBuilders != null);

            foreach (var attribute in customAttributeBuilders)
            {
                propertyBuilder.SetCustomAttribute(attribute);
            }
        }
コード例 #16
0
        private static void SetAttributes(TypeBuilder typeBuilder, Type type)
        {
            CustomContract.Requires(typeBuilder != null);
            CustomContract.Requires(type != null);

            var attributeBuilders = TypeAttributeBuilders
                                    .GetOrAdd(
                type,
                t =>
            {
                var customAttributes = t.GetCustomAttributesData();
                return(CreateCustomAttributeBuilders(customAttributes).ToArray());
            });

            CustomContract.Assume(attributeBuilders != null);

            foreach (var attributeBuilder in attributeBuilders)
            {
                typeBuilder.SetCustomAttribute(attributeBuilder);
            }
        }
コード例 #17
0
        private static IEnumerable <MemberInfo> GetMembers(Type type)
        {
            CustomContract.Requires(type != null);

            if (type.IsInterface())
            {
                var propertyInfos = new List <MemberInfo>();

                var considered = new List <Type>();
                var queue      = new Queue <Type>();
                considered.Add(type);
                queue.Enqueue(type);
                while (queue.Count > 0)
                {
                    var subType = queue.Dequeue();
                    foreach (var subInterface in subType.GetInterfaces()
                             .Where(x => !considered.Contains(x)))
                    {
                        considered.Add(subInterface);
                        queue.Enqueue(subInterface);
                    }

                    var typeProperties = subType.GetMembers(
                        BindingFlags.FlattenHierarchy
                        | BindingFlags.Public
                        | BindingFlags.Instance);

                    var newPropertyInfos = typeProperties
                                           .Where(x => !propertyInfos.Contains(x));

                    propertyInfos.InsertRange(0, newPropertyInfos);
                }

                return(propertyInfos.ToArray());
            }

            var members = type.GetMembers(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

            return(members);
        }
コード例 #18
0
        public PredicateMapper MapMember <TSource, TTarget, TValue>(
            Expression <Func <TSource, TValue> > source,
            Expression <Func <TTarget, TValue> > result)
        {
            CustomContract.Requires <ArgumentNullException>(result != null);
            CustomContract.Requires <ArgumentNullException>(source != null);
            CustomContract.Ensures(CustomContract.Result <PredicateMapper>() != null);

            var memberBody = result.Body as MemberExpression;

            if (memberBody == null)
            {
                throw new ArgumentException("Expression should access member.", "result");
            }

            var sourceBody = source.Body as MemberExpression;

            if (sourceBody == null)
            {
                throw new ArgumentException("Expression should access member.", "source");
            }

            var resultMember = memberBody.Member;
            var sourceMember = sourceBody.Member;

            var converter = _converters.FirstOrDefault(x => x.SourceType == typeof(TSource) && x.TargetType == typeof(TTarget));

            if (converter == null)
            {
                converter = new PredicateConverter <TSource, TTarget>();
                _converters.Add(converter);
            }

            converter.Substitutions[sourceMember] = resultMember;

            return(this);
        }
コード例 #19
0
        public static Stream ToStream(this string input)
        {
            CustomContract.Requires(input != null);

            return(new MemoryStream(Encoding.UTF8.GetBytes(input ?? string.Empty)));
        }
コード例 #20
0
        public static string Capitalize(this string input)
        {
            CustomContract.Requires(!string.IsNullOrEmpty(input));

            return(char.ToUpperInvariant(input[0]) + input.Substring(1));
        }
コード例 #21
0
 private void Invariants()
 {
     CustomContract.Invariant(_source != null);
 }
コード例 #22
0
 public MemberInfo ResolveAlias(Type type, string alias)
 {
     CustomContract.Requires <ArgumentNullException>(type != null);
     CustomContract.Requires <ArgumentException>(!string.IsNullOrWhiteSpace(alias));
     throw new NotImplementedException();
 }
コード例 #23
0
        /// <summary>
        /// Create a map based on the passed type arguments.
        /// </summary>
        /// <typeparam name="TSource">The source parameter type.</typeparam>
        /// <typeparam name="TTarget">The target parameter type.</typeparam>
        /// <returns>An instance of a <see cref="PredicateMapper"/></returns>
        public static PredicateMapper Map <TSource, TTarget>()
        {
            CustomContract.Ensures(CustomContract.Result <PredicateMapper>() != null);

            return(new PredicateMapper(new PredicateConverter <TSource, TTarget>()));
        }
コード例 #24
0
 private void Invariants()
 {
     CustomContract.Invariant(_writer != null);
 }
コード例 #25
0
        /// <summary>
        /// Filters the source collection using the passed query parameters.
        /// </summary>
        /// <param name="source">The source items to filter.</param>
        /// <param name="filter">The filter to apply.</param>
        /// <typeparam name="T">The <see cref="Type"/> of items in the source collection.</typeparam>
        /// <returns>A filtered and projected enumeration of the source collection.</returns>
        public static IQueryable <object> Filter <T>(this IEnumerable <T> source, IModelFilter <T> filter)
        {
            CustomContract.Requires <ArgumentNullException>(source != null);

            return(filter == null?source.OfType <object>().AsQueryable() : filter.Filter(source));
        }
コード例 #26
0
        public IQueryable <object> Filter(IEnumerable <T> source)
        {
            CustomContract.Requires <ArgumentNullException>(source != null);

            throw new NotImplementedException();
        }
コード例 #27
0
        /// <summary>
        /// Initializes a new instance of the <see cref="RuntimeTypeProvider"/> class.
        /// </summary>
        /// <param name="nameResolver"></param>
        public RuntimeTypeProvider(IMemberNameResolver nameResolver)
        {
            CustomContract.Requires(nameResolver != null);

            _nameResolver = nameResolver;
        }
コード例 #28
0
 private void Invariants()
 {
     CustomContract.Invariant(_converters != null);
 }