public MemberInitOperation(OperationContext context, MemberInitExpression expression) : base(context, expression) { newOp = OperationFactory.FromExpression <T>(context, expression.NewExpression); newOp.ValueChanged += newOp_ValueChanged; foreach (var binding in expression.Bindings) { var memberAssignment = binding as MemberAssignment; if (memberAssignment != null) { var op = OperationFactory.FromExpression(Context, memberAssignment.Expression); op.Tag = memberAssignment; op.ValueChanged += memberAssignmentOp_ValueChanged; memberAssignmentOps.Add(op); SetAssignment(newOp.Value, op); } var list = binding as MemberListBinding; if (list != null) { throw new NotImplementedException(); } var member = binding as MemberMemberBinding; if (member != null) { throw new NotImplementedException(); } } SetValue(newOp.Value); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="context"></param> /// <param name="expression"></param> /// <param name="source1Expression"></param> /// <param name="source2Expression"></param> public EnumerableSource2Operation(OperationContext context, MethodCallExpression expression, Expression source1Expression, Expression source2Expression) : base(context, expression, source1Expression) { source2Op = OperationFactory.FromExpression <IEnumerable <TSource2> >(Context, source2Expression); SubscribeSource2Operation(source2Op); Source2Changed(null, source2Op.Value); }
/// <summary> /// Creates a context for a new lambda expression. /// </summary> /// <param name="item"></param> /// <param name="parameters"></param> /// <returns></returns> OperationContext CreateLambdaContext(TSource item, params ParameterExpression[] parameters) { // generate new parameter var ctx = new OperationContext(Context); var var = OperationFactory.FromValue(item); ctx.Variables[parameters[0].Name] = var; return(ctx); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="query"></param> internal ObservableView(ObservableQuery <TElement> query) { expression = query.Expression; // establish root operation, hook up events, and load operation = (Operation <IEnumerable <TElement> >)OperationFactory.FromExpression <IEnumerable <TElement> >(new OperationContext(), expression); SubscribeOperation(operation); OperationChanged(null, operation.Value); }
public LambdaOperation(OperationContext context, LambdaExpression expression) : base(context, expression) { if (expression.Body != null) { body = (IOperation <T>)OperationFactory.FromExpression(context, expression.Body); body.ValueChanged += body_ValueChanged; SetValue(body.Value); } }
protected UnaryOperation(OperationContext context, UnaryExpression expression) : base(context, expression) { if (expression.Operand != null) { operand = OperationFactory.FromExpression <TOperand>(context, expression.Operand); operand.ValueChanged += operand_ValueChanged; SetValue(CoerceValue((TOperand)operand.Value)); } }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="func"></param> public ObservableValue(Expression <Func <TResult> > func) { if (func == null) { throw new ArgumentNullException("func"); } // initialize result Initialize(OperationFactory.FromExpression <TResult>(new OperationContext(), func)); }
public NewOperation(OperationContext context, NewExpression expression) : base(context, expression) { argumentOps = new IOperation[expression.Arguments.Count]; for (int i = 0; i < expression.Arguments.Count; i++) { argumentOps[i] = OperationFactory.FromExpression(context, expression.Arguments[i]); argumentOps[i].ValueChanged += argument_ValueChanged; } ResetValue(); }
public ConditionalOperation(OperationContext context, ConditionalExpression expression) : base(context, expression) { testOp = OperationFactory.FromExpression <bool>(context, expression.Test); testOp.ValueChanged += testOp_ValueChanged; trueOp = OperationFactory.FromExpression <TResult>(context, expression.IfTrue); trueOp.ValueChanged += trueOp_ValueChanged; falseOp = OperationFactory.FromExpression <TResult>(context, expression.IfFalse); falseOp.ValueChanged += falseOp_ValueChanged; // set initial value ResetValue(); }
public MemberAccessOperation(OperationContext context, MemberExpression expression) : base(context, expression) { self = expression; if (self.Expression != null) { targetOp = OperationFactory.FromExpression(context, self.Expression); targetOp.ValueChanged += target_ValueChanged; OnTargetValueChanged(null, targetOp.Value); } else if (!IsStatic(self.Member)) { throw new ArgumentException("Cannot access a non-static method without a target expression."); } }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="context"></param> /// <param name="expression"></param> public IndexOperation(OperationContext context, IndexExpression expression) : base(context, expression) { if (expression.Object != null) { targetOp = OperationFactory.FromExpression(context, expression.Object); targetOp.ValueChanged += targetOp_ValueChanged; } parameterOps = new IOperation[expression.Arguments.Count]; for (int i = 0; i < expression.Arguments.Count; i++) { parameterOps[i] = OperationFactory.FromExpression(context, expression.Arguments[i]); parameterOps[i].ValueChanged += parameterOp_ValueChanged; } Reset(); }
/// <summary> /// Initializes a new instance. /// </summary> /// <param name="context"></param> /// <param name="expression"></param> public OptionOperation(OperationContext context, Expression expression) : base(context, expression) { this.operation = OperationFactory.FromExpression <T>(new OperationContext(context), expression); this.operation.ValueChanged += operation_ValueChanged; }