private static bool IsIEnumerable(Type type)
{
CustomContract.Requires(type != null);
return(type.IsGenericType() &&
type.GetGenericTypeDefinition() == typeof(IEnumerable <>));
}
private static bool HasAliasAttribute(string alias, MemberInfo member)
{
CustomContract.Requires(member != null);
var attributes = member.GetCustomAttributes(true);
var dataMember = attributes.OfType <DataMemberAttribute>()
.FirstOrDefault();
if (dataMember != null && dataMember.Name == alias)
{
return(true);
}
var xmlElement = attributes.OfType <XmlElementAttribute>()
.FirstOrDefault();
if (xmlElement != null && xmlElement.ElementName == alias)
{
return(true);
}
var xmlAttribute = attributes.OfType <XmlAttributeAttribute>()
.FirstOrDefault();
if (xmlAttribute != null && xmlAttribute.AttributeName == alias)
{
return(true);
}
return(false);
}
public Type Get(Type sourceType, IEnumerable <MemberInfo> properties)
{
CustomContract.Requires <ArgumentNullException>(sourceType != null);
CustomContract.Requires <ArgumentNullException>(properties != null);
throw new NotImplementedException();
}
private static string GetTypeKey(Type sourceType, Dictionary <string, MemberInfo> fields)
{
CustomContract.Requires(sourceType != null);
CustomContract.Requires(fields != null);
return(fields.Aggregate("Linq2Rest<>" + sourceType.Name, (current, field) => current + (field.Key + field.Value.MemberType)));
}
public string ResolveName(MemberInfo member)
{
CustomContract.Requires <ArgumentNullException>(member != null);
CustomContract.Ensures(CustomContract.Result <string>() != null);
throw new NotImplementedException();
}
private static MemberInfo ResolveAliasInternal(Type type, string alias)
{
CustomContract.Requires(type != null);
var members = GetMembers(type);
Debug.WriteLine("Linq2Rest: members of " + type.FullName + ": " + string.Join(", ", members.Select(m => m.Name)));
var member = members
.Select(
x =>
{
if (HasAliasAttribute(alias, x))
{
#if !NETFX_CORE
return(x.MemberType == MemberTypes.Field
? CheckFrontingProperty(x)
: x);
#else
return(x is FieldInfo ? CheckFrontingProperty(x) : x);
#endif
}
if (x.Name == alias)
{
return(x);
}
return(null);
})
.FirstOrDefault(x => x != null);
return(member);
}
private static string ResolveNameInternal(MemberInfo member)
{
CustomContract.Requires(member != null);
var dataMember = member.GetCustomAttributes(typeof(DataMemberAttribute), true)
.OfType <DataMemberAttribute>()
.FirstOrDefault();
if (dataMember != null && dataMember.Name != null)
{
return(dataMember.Name);
}
var xmlElement = member.GetCustomAttributes(typeof(XmlElementAttribute), true)
.OfType <XmlElementAttribute>()
.FirstOrDefault();
if (xmlElement != null && xmlElement.ElementName != null)
{
return(xmlElement.ElementName);
}
var xmlAttribute = member.GetCustomAttributes(typeof(XmlAttributeAttribute), true)
.OfType <XmlAttributeAttribute>()
.FirstOrDefault();
if (xmlAttribute != null && xmlAttribute.AttributeName != null)
{
return(xmlAttribute.AttributeName);
}
CustomContract.Assert(member.Name != null, "Member must have name");
return(member.Name);
}
public static IEnumerable <T> Replace <T>(this IEnumerable <T> items, Func <T, bool> predicate, T replacement)
{
CustomContract.Requires(items != null);
CustomContract.Requires(predicate != null);
CustomContract.Ensures(CustomContract.Result <IEnumerable <T> >() != null);
return(items.Select(item => predicate(item) ? replacement : item));
}
public UntypedQueryable(IQueryable <T> source, Expression <Func <T, object> > projection)
{
CustomContract.Requires(projection == null || source != null);
_source = projection == null
? (IQueryable)source
: source.Select(projection);
}
/// <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)));
}
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);
}
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));
}
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));
}
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 }));
}
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);
}
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);
}
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());
}
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");
}
}
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);
}
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));
}
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);
}
}
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);
}
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);
}
/// <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;
}
public static Stream ToStream(this string input)
{
CustomContract.Requires(input != null);
return(new MemoryStream(Encoding.UTF8.GetBytes(input ?? string.Empty)));
}
public static string Capitalize(this string input)
{
CustomContract.Requires(!string.IsNullOrEmpty(input));
return(char.ToUpperInvariant(input[0]) + input.Substring(1));
}
public MemberInfo ResolveAlias(Type type, string alias)
{
CustomContract.Requires <ArgumentNullException>(type != null);
CustomContract.Requires <ArgumentException>(!string.IsNullOrWhiteSpace(alias));
throw new NotImplementedException();
}
public IQueryable <object> Filter(IEnumerable <T> source)
{
CustomContract.Requires <ArgumentNullException>(source != null);
throw new NotImplementedException();
}
