public void WriteExpressions(LambdaDefinition definition)
{
var scope = definition.Scope();
var variableExpr = Expression.Variable(Variable.VariableType, Variable.Usage);
definition.RegisterExpression(Variable, variableExpr);
var invokeMethod = _setter.InitialValue.GetType().GetMethod("Invoke");
var invoke = Expression.Call(Expression.Constant(_setter.InitialValue), invokeMethod, scope);
Expression cast = invoke;
if (!variableExpr.Type.IsAssignableFrom(invoke.Type))
{
cast = Expression.Convert(invoke, variableExpr.Type);
}
definition.Body.Add(Expression.Assign(variableExpr, cast));
if (!Variable.VariableType.IsValueType)
{
definition.TryRegisterDisposable(variableExpr);
}
if (Next is IResolverFrame next)
{
next.WriteExpressions(definition);
}
else
{
throw new InvalidCastException($"{Next.GetType().FullNameInCode()} does not implement {nameof(IResolverFrame)}");
}
}
public void WriteExpressions(LambdaDefinition definition)
{
var variableExpr = definition.RegisterExpression(Variable);
definition.Body.Add(Expression.Assign(variableExpr, Expression.Convert(definition.ExpressionFor(_scope), Variable.VariableType)));
Next?.As <IResolverFrame>().WriteExpressions(definition);
}
public void short_hand_register_variable()
{
var definition = new LambdaDefinition();
var variable = Variable.For <IWidget>();
definition.RegisterExpression(variable);
definition.ExpressionFor(variable).ShouldNotBeNull();
}
public void register_a_variable_and_fetch_happy_path()
{
var definition = new LambdaDefinition();
var variable = Variable.For <IWidget>();
var expression = variable.ToVariableExpression(definition);
definition.RegisterExpression(variable, expression);
definition.ExpressionFor(variable).ShouldBeSameAs(expression);
}
public void WriteExpressions(LambdaDefinition definition)
{
// No next, not disposable
var isDisposed = BuiltType.CanBeCastTo <IDisposable>() ||
BuiltType.CanBeCastTo <IAsyncDisposable>();
var callCtor = Expression.New(Ctor, Parameters.Select(definition.ExpressionFor));
if (Next == null && !isDisposed && !Setters.Any())
{
definition.Body.Add(callCtor);
}
else
{
var variableExpr = Expression.Parameter(BuiltType, Variable.Usage);
definition.RegisterExpression(Variable, variableExpr);
definition.Assign(variableExpr, callCtor);
foreach (var setter in Setters)
{
var setMethod = BuiltType.GetProperty(setter.PropertyName).SetMethod;
var value = definition.ExpressionFor(setter.Variable);
var call = Expression.Call(variableExpr, setMethod, value);
definition.Body.Add(call);
}
if (isDisposed)
{
definition.RegisterDisposable(variableExpr, Variable.VariableType);
}
if (Next == null)
{
definition.Body.Add(definition.ExpressionFor(Variable));
}
else
{
if (Next is IResolverFrame next)
{
next.WriteExpressions(definition);
}
else
{
throw new InvalidCastException($"{Next.GetType().GetFullName()} does not implement {nameof(IResolverFrame)}");
}
}
}
}
public Func <Scope, object> BuildResolver()
{
var arranger = new MethodFrameArranger(this, this);
arranger.Arrange(out var mode, out var top);
var definition = new LambdaDefinition
{
Context = _scope
};
var scope = definition.RegisterExpression(_scopeArgument).As <ParameterExpression>();
definition.Arguments = new [] { scope };
if (top is IResolverFrame frame)
{
frame.WriteExpressions(definition);
return(definition.Compile <Func <Scope, object> >());
}
throw new InvalidOperationException($"Frame type {top} does not implement {nameof(IResolverFrame)}");
}
