public ObservableReversableBinaryExpression(BinaryExpression node, ObservableExpressionBinder binder, MethodInfo leftReverser, MethodInfo rightReverser)
: this(
binder.VisitObservable <TLeft>(node.Left),
binder.VisitObservable <TRight>(node.Right),
ReflectionHelper.CreateDelegate <Func <TLeft, TRight, TResult> >(node.Method),
rightReverser != null ? ReflectionHelper.CreateDelegate <Func <TResult, TRight, TLeft> >(rightReverser) : null,
leftReverser != null ? ReflectionHelper.CreateDelegate <Func <TResult, TLeft, TRight> >(leftReverser) : null)
{
}
public ObservableStaticMethodBase(MethodInfo method)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
Function = ReflectionHelper.CreateDelegate(typeof(TDelegate), method) as TDelegate;
}
private static ObservableMemberBinding <T> CreateProperty <T, TMember>(MemberAssignment node, ObservableExpressionBinder binder, INotifyExpression <T> target)
{
INotifyExpression <TMember> value = binder.VisitObservable <TMember>(node.Expression);
var property = node.Member as PropertyInfo;
var reversable = value as INotifyReversableExpression <TMember>;
if (reversable != null && ReflectionHelper.IsAssignableFrom(typeof(INotifyPropertyChanged), typeof(T)))
{
return(new ObservableReversablePropertyMemberBinding <T, TMember>(target, node.Member.Name,
ReflectionHelper.CreateDelegate(typeof(Func <T, TMember>), ReflectionHelper.GetGetter(property)) as Func <T, TMember>,
ReflectionHelper.CreateDelegate(typeof(Action <T, TMember>), ReflectionHelper.GetSetter(property)) as Action <T, TMember>,
reversable));
}
return(new ObservablePropertyMemberBinding <T, TMember>(target,
ReflectionHelper.CreateDelegate(typeof(Action <T, TMember>), ReflectionHelper.GetSetter(property)) as Action <T, TMember>, value));
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
var rewriterAttributes = ReflectionHelper.GetCustomAttributes <ExpressionCompileRewriterAttribute>(node.Method, false);
if (rewriterAttributes != null && rewriterAttributes.Length == 1)
{
var rewriteAtt = rewriterAttributes[0];
MethodInfo rewriter;
if (!rewriteAtt.InitializeProxyMethod(node.Method, new Type[] { typeof(MethodCallExpression) }, out rewriter))
{
throw new InvalidOperationException("The rewriter method had the wrong signature. It must be a method taking a MethodCallExpression as parameter.");
}
var rewriterDelegate = ReflectionHelper.CreateDelegate <Func <MethodCallExpression, Expression> >(rewriter);
return(rewriterDelegate.Invoke(node));
}
return(base.VisitMethodCall(node));
}
public ObservableListInitializer(INotifyExpression <T> target, INotifyExpression <TElement> value, MethodInfo addMethod)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
if (addMethod == null)
{
throw new ArgumentNullException("addMethod");
}
Target = target;
Value = value;
AddAction = ReflectionHelper.CreateDelegate <Action <T, TElement> >(addMethod);
var removeMethod = ReflectionHelper.GetRemoveMethod(typeof(T), typeof(TElement));
if (removeMethod == null)
{
throw new InvalidOperationException("Could not find appropriate Remove method for " + addMethod.Name);
}
if (removeMethod.ReturnType == typeof(void))
{
RemoveAction = ReflectionHelper.CreateDelegate <Action <T, TElement> >(removeMethod);
}
else if (removeMethod.ReturnType == typeof(bool))
{
var tempAction = ReflectionHelper.CreateDelegate <Func <T, TElement, bool> >(removeMethod);
RemoveAction = (o, i) => tempAction(o, i);
}
else
{
throw new NotSupportedException();
}
}
private Expression VisitProperty(MemberExpression node, PropertyInfo property)
{
object getter;
if (!ReflectionHelper.IsValueType(property.DeclaringType))
{
getter = ReflectionHelper.CreateDelegate(typeof(Func <,>).MakeGenericType(property.DeclaringType, property.PropertyType), ReflectionHelper.GetGetter(property));
}
else
{
//TODO: This is a bug in the BCL, code here to get out of this shit
var param = Expression.Parameter(property.DeclaringType);
var expression = Expression.Lambda(Expression.Property(param, property), param);
getter = expression.Compile();
}
if (property.CanWrite)
{
var setter = ReflectionHelper.GetSetter(property);
if (setter != null)
{
if (!ReflectionHelper.IsValueType(property.DeclaringType))
{
return(System.Activator.CreateInstance(typeof(ObservableReversableMemberExpression <,>).MakeGenericType(property.DeclaringType, property.PropertyType),
node, this, property.Name, getter, ReflectionHelper.CreateDelegate(typeof(Action <,>).MakeGenericType(property.DeclaringType, property.PropertyType), setter)) as Expression);
}
else
{
var setParam1 = Expression.Parameter(property.DeclaringType);
var setParam2 = Expression.Parameter(property.PropertyType);
var setExpression = Expression.Lambda(Expression.Assign(Expression.Property(setParam1, property), setParam2), setParam1, setParam2);
return(System.Activator.CreateInstance(typeof(ObservableReversableMemberExpression <,>).MakeGenericType(property.DeclaringType, property.PropertyType),
node, this, property.Name, getter, setExpression.Compile()) as Expression);
}
}
}
return(System.Activator.CreateInstance(typeof(ObservableMemberExpression <,>).MakeGenericType(property.DeclaringType, property.PropertyType),
node, this, property.Name, getter) as Expression);
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
var attributes = node.Method.GetCustomAttributes(typeof(SetExpressionRewriterAttribute), false);
if (attributes != null)
{
var proxyAttribute = attributes.FirstOrDefault() as SetExpressionRewriterAttribute;
if (proxyAttribute != null)
{
MethodInfo proxyMethod;
if (!proxyAttribute.InitializeProxyMethod(node.Method, new Type[] { typeof(MethodCallExpression), typeof(SetExpressionRewriter) }, out proxyMethod))
{
throw new InvalidOperationException(string.Format("The given expression rewriter method for method {0} has the wrong signature. It must accept parameters of type MethodCallExpression and SetExpressionRewriter.", node.Method.Name));
}
else if (proxyMethod != null && proxyMethod.IsStatic && proxyMethod.ReturnType == typeof(Expression))
{
var func = ReflectionHelper.CreateDelegate <Func <MethodCallExpression, SetExpressionRewriter, Expression> >(proxyMethod);
return(func(node, this));
}
}
}
return(null);
}
public ObservableBinaryExpression(BinaryExpression node, ObservableExpressionBinder binder)
: this(binder.VisitObservable <TLeft>(node.Left), binder.VisitObservable <TRight>(node.Right), ReflectionHelper.CreateDelegate <Func <TLeft, TRight, TResult> >(node.Method))
{
}
private void RenewFunction()
{
Function = ReflectionHelper.CreateDelegate(typeof(TDelegate), Target.Value, Method) as TDelegate;
}
public ObservableUnaryExpression(UnaryExpression node, ObservableExpressionBinder binder)
: this(binder.VisitObservable <TInner>(node.Operand), ReflectionHelper.CreateDelegate <Func <TInner, TOuter> >(node.Method))
{
}
protected override Expression VisitMethodCall(MethodCallExpression node)
{
var attributes = node.Method.GetCustomAttributes(typeof(SetExpressionRewriterAttribute), false);
if (attributes != null)
{
var proxyAttribute = attributes.FirstOrDefault() as SetExpressionRewriterAttribute;
if (proxyAttribute != null)
{
MethodInfo proxyMethod;
if (!proxyAttribute.InitializeProxyMethod(node.Method, new Type[] { typeof(MethodCallExpression), typeof(SetExpressionRewriter) }, out proxyMethod))
{
throw new InvalidOperationException($"The given expression rewriter method for method {node.Method.Name} has the wrong signature. It must accept parameters of type MethodCallExpression and SetExpressionRewriter.");
}
else if (proxyMethod != null && proxyMethod.IsStatic && proxyMethod.ReturnType == typeof(Expression))
{
var func = ReflectionHelper.CreateDelegate <Func <MethodCallExpression, SetExpressionRewriter, Expression> >(proxyMethod);
return(func(node, this));
}
}
}
attributes = node.Method.GetCustomAttributes(typeof(LensPutAttribute), false);
if (attributes != null && node.Method.ReturnType != typeof(void) && Value != null)
{
var lensPutAttribute = attributes.FirstOrDefault() as LensPutAttribute;
if (lensPutAttribute != null)
{
MethodInfo lensMethod;
var typeList = new List <Type>(node.Method.GetParameters().Select(p => p.ParameterType));
if (!node.Method.IsStatic)
{
typeList.Insert(0, node.Object.Type);
}
typeList.Add(node.Method.ReturnType);
if (!lensPutAttribute.InitializeProxyMethod(node.Method, typeList.ToArray(), out lensMethod))
{
typeList.RemoveAt(0);
if (node.Method.IsStatic || !lensPutAttribute.InitializeProxyMethod(node.Method, typeList.ToArray(), out lensMethod))
{
throw new InvalidOperationException($"The lens put method for method {node.Method.Name} has the wrong signature. It must accept the same parameter types as the original method plus the return type of the original method.");
}
else if (lensMethod != null && !lensMethod.IsStatic)
{
var args = new List <Expression>(node.Arguments);
args.Add(Value);
var call = Expression.Call(node.Object, lensMethod, args);
if (lensMethod.ReturnType == typeof(void))
{
Value = null;
}
else
{
Value = call;
}
return(call);
}
}
else if (lensMethod != null && lensMethod.IsStatic)
{
var args = new List <Expression>(node.Arguments);
args.Add(Value);
if (!node.Method.IsStatic)
{
args.Insert(0, node.Object);
}
var call = Expression.Call(lensMethod, args);
if (lensMethod.ReturnType == typeof(void))
{
Value = null;
return(call);
}
else
{
Value = call;
if (node.Method.IsStatic)
{
return(Visit(node.Arguments[0]));
}
else
{
return(Visit(node.Object));
}
}
}
}
}
return(null);
}
