public void TypeMemberCache()
{
var cache = new TypeMemberCache <MethodInfo>(RuntimeReflectionExtensions.GetRuntimeMethods);
var b_foos = cache.GetMembers(typeof(TMC_B), "Foo", inherited: true);
var a_foos = cache.GetMembers(typeof(TMC_A), "Foo", inherited: true);
var a_bars = cache.GetMembers(typeof(TMC_A), "Bar", inherited: true);
var b_bars = cache.GetMembers(typeof(TMC_B), "Bar", inherited: true);
var b_foos_declared = cache.GetMembers(typeof(TMC_B), "Foo", inherited: false);
var b_bars_declared = cache.GetMembers(typeof(TMC_B), "Bar", inherited: false);
AreBagsEqual(b_foos.Select(a => a.ToString()), new[] { "Void Foo(System.String)", "Void Foo()" });
AreBagsEqual(a_foos.Select(a => a.ToString()), new[] { "Void Foo(Int32)", "Void Foo()" });
AreBagsEqual(a_bars.Select(a => a.ToString()), new[] { "Void Bar(Int32)", "Void Bar()", "Void Bar(Char)", "Void Bar(Double)", "Void Bar(Int16)" });
AreBagsEqual(b_bars.Select(a => a.ToString()), new[] { "Void Bar(System.String)", "Void Bar()", "Void Bar(Int32)", "Void Bar()", "Void Bar(Char)", "Void Bar(Boolean)", "Void Bar(Int16)" });
AreBagsEqual(b_foos_declared.Select(a => a.ToString()), new[] { "Void Foo(System.String)", "Void Foo()" });
AreBagsEqual(b_bars_declared.Select(a => a.ToString()), new[] { "Void Bar(System.String)", "Void Bar()", "Void Bar(Boolean)", "Void Bar(Int16)" });
var m = b_bars.WithBindingFlags(BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic);
AreBagsEqual(m.Select(a => a.ToString()), new[] { "Void Bar()", "Void Bar(Char)", "Void Bar(Boolean)" });
m = b_bars.WithBindingFlags(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public);
AreBagsEqual(m.Select(a => a.ToString()), new[] { "Void Bar(System.String)", "Void Bar(Int32)", "Void Bar()", "Void Bar(Int16)" });
m = b_bars.WithBindingFlags(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
AreBagsEqual(m.Select(a => a.ToString()), new[] { "Void Bar(System.String)", "Void Bar()", "Void Bar(Int32)", "Void Bar()", "Void Bar(Char)", "Void Bar(Int16)" });
m = b_bars.WithBindingFlags(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
AreBagsEqual(m.Select(a => a.ToString()), new string[] { "Void Bar(Boolean)" });
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public static MethodInfo ResolveMethodFromLambda(LambdaExpression lambda)
{
var originalDeclaration = ExtractMethodInfoFromLambda(lambda);
var shouldResolveDeclaringType = TypeTemplate.IsTemplateType(originalDeclaration.DeclaringType);
if (!originalDeclaration.IsGenericMethod && !shouldResolveDeclaringType)
{
return(originalDeclaration);
}
var resolvedDeclaration = originalDeclaration;
if (shouldResolveDeclaringType)
{
var resolvedDeclaringType = TypeTemplate.Resolve(originalDeclaration.DeclaringType);
var resolvedReturnType = TypeTemplate.Resolve(originalDeclaration.ReturnType);
var resolvedParameterTypes = originalDeclaration.GetParameters().Select(p => TypeTemplate.Resolve(p.ParameterType)).ToArray();
resolvedDeclaration = TypeMemberCache.Of(resolvedDeclaringType)
.Methods.Where(m => m.Name == originalDeclaration.Name)
.OfSignature(resolvedReturnType, resolvedParameterTypes)
.Single();
}
if (resolvedDeclaration.IsGenericMethod)
{
var resolvedGenericArguments = originalDeclaration.GetGenericArguments().Select(TypeTemplate.Resolve).ToArray();
resolvedDeclaration = resolvedDeclaration.GetGenericMethodDefinition().MakeGenericMethod(resolvedGenericArguments);
}
return(resolvedDeclaration);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private void CreateMemberDescriptions()
{
foreach (var ancestorType in m_TypeKey.GetAllInterfaces())
{
foreach (var member in TypeMemberCache.Of(ancestorType).ImplementableMembers)
{
CreateMemberDescription(member);
}
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public ImplementationClassWriter(ClassType ownerClass, Type baseType)
: base(ownerClass)
{
m_BaseType = TypeTemplate.Resolve(baseType);
if (m_BaseType.IsInterface)
{
ownerClass.AddInterface(m_BaseType);
}
m_Members = TypeMemberCache.Of(m_BaseType);
//TODO: validate base type
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public static FieldInfo ResolveFieldFromLambda(LambdaExpression lambda)
{
var originalFieldInfo = (FieldInfo)((MemberExpression)lambda.Body).Member;
if (TypeTemplate.IsTemplateType(originalFieldInfo.DeclaringType))
{
var resolvedDeclaringType = TypeTemplate.Resolve(originalFieldInfo.DeclaringType);
return(TypeMemberCache.Of(resolvedDeclaringType).Fields.Single(m => m.Name == originalFieldInfo.Name));
}
else
{
return(originalFieldInfo);
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public static PropertyInfo ResolvePropertyFromLambda(LambdaExpression lambda)
{
var propertyInfo = (PropertyInfo)((MemberExpression)lambda.Body).Member;
if (TypeTemplate.IsTemplateType(propertyInfo.DeclaringType))
{
var resolvedDeclaringType = TypeTemplate.Resolve(propertyInfo.DeclaringType);
var resolvedPropertyType = TypeTemplate.Resolve(propertyInfo.PropertyType);
var resolvedParameterTypes = propertyInfo.GetIndexParameters().Select(p => TypeTemplate.Resolve(p.ParameterType)).ToArray();
var resolvedPropertyInfo = TypeMemberCache.Of(resolvedDeclaringType)
.Properties.Where(p => p.Name == propertyInfo.Name && p.DeclaringType == resolvedDeclaringType)
.OfSignature(resolvedPropertyType, resolvedParameterTypes)
.Single();
return(resolvedPropertyInfo);
}
else
{
return(propertyInfo);
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
protected override bool ShouldApply(ObjectFactoryContext context)
{
return(
context.TypeKey.PrimaryInterface != null &&
TypeMemberCache.Of(context.TypeKey.PrimaryInterface).ImplementableProperties.Any());
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
public TupleClassBuilder(TypeKey key, ImplementationClassWriter <object> classBody)
{
m_Key = key;
m_ClassBody = classBody;
m_TupleProperties = TypeMemberCache.Of(key.PrimaryInterface).ImplementableProperties.ToDictionary(p => p.Name, StringComparer.OrdinalIgnoreCase);
}
