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;
}
