public void LoadExpression <TItem>(LambdaExpression getterExpression)
{
GetterExpression = getterExpression;
PropertyValueType = ResolverTypeUtility.GetPropertyLambdaReturnType <TItem>(getterExpression.GetType());
EnumerableTypeArgument = GetEnumerableTypeArgument(PropertyValueType);
}
private static IIdentifierInfo <TItem> GetGetterIdentifierInfo(LambdaExpression getterExpr, bool multiReferenceCollection)
{
Type returnType = ResolverTypeUtility.GetPropertyLambdaReturnType <TItem>(getterExpr.GetType());
if (multiReferenceCollection)
{
Type enumerableType = returnType.GetGenericInterface(typeof(IEnumerable <>));
if (enumerableType == null)
{
throw new StemAttributeSetupException("References attribute must be placed on expressions that return an IEnumerable.");
}
Type itemType = enumerableType.GetGenericArguments()[0];
return(Reflect.Type(typeof(MultiExpressionIdentifierInfo <,>))
.MakeGeneric(typeof(TItem), itemType)
.CastTo <IIdentifierInfo <TItem> >()
.CreateInstance(getterExpr));
}
else
{
return(Reflect.Type(typeof(ExpressionIdentifierInfo <,>))
.MakeGeneric(typeof(TItem), returnType)
.CastTo <IIdentifierInfo <TItem> >()
.CreateInstance(getterExpr));
}
}
protected override void IncludeExpression(LambdaExpression expression)
{
Type exprBodyType = ResolverTypeUtility.GetPropertyLambdaReturnType(ItemType, expression.GetType());
SetOrConfirmType(exprBodyType);
AddExpressionToDefinition(expression);
}
private static void IncludeSetterExpression <TItem>(EngineImplementations <TItem> implementations, FieldDefinition definition)
where TItem : class
{
Type writerPropertyValueType =
ResolverTypeUtility.GetPropertyLambdaReturnType <TItem>(definition.Setter.Expression.GetType());
var writer = Reflect.Type(typeof(PropertyExpressionFieldWriter <,>))
.MakeGeneric(typeof(TItem), writerPropertyValueType)
.CastTo <IFieldWriter <TItem> >()
.CreateInstance(definition.Setter.Expression);
var writerFactory = new SingletonFactory <IFieldWriter <TItem>, TItem>(writer);
implementations.WriterFactories.Add(definition.FieldName, writerFactory);
}
private static void IncludeLocatorExpression <TItem>(EngineImplementations <TItem> implementations, FieldDefinition definition)
where TItem : class
{
Type locatorPropertyValueType =
ResolverTypeUtility.GetPropertyLambdaReturnType <TItem>(definition.Locator.Expression.GetType());
Debug.Assert(locatorPropertyValueType == definition.FieldType, "FieldType is incorrect");
var locator = Reflect.Type(typeof(IdentifierExpressionItemLocator <,>))
.MakeGeneric(typeof(TItem), locatorPropertyValueType)
.CastTo <IItemLocator <TItem> >()
.CreateInstance(definition.Locator.Expression);
var locatorFactory = new SingletonFactory <IItemLocator <TItem>, TItem>(locator);
implementations.LocatorFactories.Add(definition.FieldName, locatorFactory);
}
protected override Type AddMethodToDefinition(MethodInfo method)
{
FieldDefinition.Display = _display;
ParameterInfo[] parameters = method.GetParameters();
Type returnType = method.ReturnType;
if (_argumentMemberName != null)
{
PropertyInfo argumentProperty = method.ReflectedType.GetProperty(_argumentMemberName);
if (argumentProperty == null)
{
throw new StemAttributeSetupException("Cannot find a property in this Stem with the name '" + _argumentMemberName + "'");
}
LambdaExpression expression = GetExpressionFromProperty(argumentProperty);
FieldDefinition.Getter.Expression = expression;
Type delegateType = typeof(Func <,>).MakeGenericType(expression.ReturnType, returnType);
AddMethodToHandlerPart(FieldDefinition.Getter, method, delegateType);
if (expression.ReturnType == returnType)
{
return(expression.ReturnType);
}
// we must return a type that both db query type and replacement type derive from.
// we could find a common ancestor between them
return(typeof(object));
}
if (parameters.Length == 0)
{
if (!returnType.IsSubclassOfGeneric(typeof(Expression <>)))
{
throw new StemAttributeSetupException("A getter method with no parameters must return a strongly typed Expression<>.");
}
Type delegateType = typeof(Func <>).MakeGenericType(returnType);
AddMethodToHandlerPart(FieldDefinition.Getter, method, delegateType);
Type propertyValueType = ResolverTypeUtility.GetPropertyLambdaReturnType(ItemType, returnType);
return(propertyValueType);
}
else
{
if (parameters.Length != 1)
{
throw new StemAttributeSetupException("A getter method that does not return an expression must have one parameter for the item.");
}
if (parameters[0].ParameterType != ItemType)
{
throw new StemAttributeSetupException("A getter method's first parameter must be of type " + ItemType.Name);
}
Type delegateType = typeof(Func <,>).MakeGenericType(ItemType, returnType);
AddMethodToHandlerPart(FieldDefinition.Getter, method, delegateType);
return(method.ReturnType);
}
}
