/// <summary> /// Gets the <see cref="Type"/> matching the provided members. /// </summary> /// <param name="sourceType">The <see cref="Type"/> to generate the runtime type from.</param> /// <param name="properties">The <see cref="MemberInfo"/> to use to generate properties.</param> /// <returns>A <see cref="Type"/> mathing the provided properties.</returns> public Type Get(Type sourceType, IEnumerable <MemberInfo> properties) { properties = properties.ToArray(); if (!properties.Any()) { throw new ArgumentOutOfRangeException("properties", "properties must have at least 1 property definition"); } var dictionary = properties.ToDictionary(f => _nameResolver.ResolveName(f), memberInfo => memberInfo); var className = GetTypeKey(sourceType, dictionary); return(BuiltTypes.GetOrAdd( className, s => { var typeBuilder = ModuleBuilder.DefineType( className, TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Serializable); CustomContract.Assume(typeBuilder != null); SetAttributes(typeBuilder, sourceType); foreach (var field in dictionary) { CreateProperty(typeBuilder, field); } return typeBuilder.CreateTypeInfo().AsType(); })); }
/// <summary> /// Returns the resolved name for the <see cref="MemberInfo"/>. /// </summary> /// <param name="member">The <see cref="MemberInfo"/> to resolve the name of.</param> /// <returns>The resolved name.</returns> public string ResolveName(MemberInfo member) { var result = KnownMemberNames.GetOrAdd(member, ResolveNameInternal); CustomContract.Assume(result != null); return(result); }
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)); }
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 })); }
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); }
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); }
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); } }
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); } }