/// <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);
}
}
