public void WriteExpressions(LambdaDefinition definition)
{
var listType = typeof(List <>).MakeGenericType(typeof(T));
var ctor = listType.GetConstructors().Single(x => x.GetParameters().Length == 0);
var addMethod = listType.GetMethod("Add");
var expr = definition.ExpressionFor(Variable);
var assign = Expression.Assign(expr, Expression.New(ctor));
definition.Body.Add(assign);
foreach (var variable in Elements)
{
var add = Expression.Call(expr, addMethod, definition.ExpressionFor(variable));
definition.Body.Add(add);
}
if (Next == null)
{
definition.Body.Add(expr);
}
else if (Next is IResolverFrame next)
{
next.WriteExpressions(definition);
}
else
{
throw new InvalidCastException($"{Next.GetType().GetFullName()} does not implement {nameof(IResolverFrame)}");
}
}
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 void WriteExpressions(LambdaDefinition definition)
{
var scope = definition.Scope();
var closedMethod = _openMethod.MakeGenericMethod(_serviceType);
var expr = definition.ExpressionFor(Variable);
var call = Expression.Call(scope, closedMethod);
var assign = Expression.Assign(expr, call);
definition.Body.Add(assign);
if (Next == null)
{
definition.Body.Add(expr);
}
else 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 listType = typeof(List <>).MakeGenericType(typeof(T));
var ctor = listType.GetConstructors().Single(x => x.GetParameters().Length == 1 && x.GetParameters()[0].ParameterType.IsEnumerable());
var initArray = Expression.NewArrayInit(ElementType, Elements.Select(definition.ExpressionFor));
var expr = definition.ExpressionFor(Variable);
var assign = Expression.Assign(expr, Expression.New(ctor, initArray));
definition.Body.Add(assign);
if (Next == null)
{
definition.Body.Add(expr);
}
else if (Next is IResolverFrame next)
{
next.WriteExpressions(definition);
}
else
{
throw new InvalidCastException($"{Next.GetType().GetFullName()} 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)
{
var scope = definition.Scope();
var expr = definition.ExpressionFor(Variable);
var instance = Variable.Instance;
var @call = Expression.Call(Expression.Constant(instance), _resolveMethod, scope);
var assign = Expression.Assign(expr, Expression.Convert(@call, Variable.VariableType));
definition.Body.Add(assign);
if (Next is IResolverFrame next)
{
next.WriteExpressions(definition);
}
else
{
throw new InvalidCastException($"{Next.GetType().GetFullName()} does not implement {nameof(IResolverFrame)}");
}
}
public void WriteExpressions(LambdaDefinition definition)
{
var init = Expression.NewArrayInit(ElementType, Elements.Select(definition.ExpressionFor));
var expr = definition.ExpressionFor(Variable);
var assign = Expression.Assign(expr, init);
definition.Body.Add(assign);
if (Next == null)
{
definition.Body.Add(expr);
}
else if (Next is IResolverFrame next)
{
next.WriteExpressions(definition);
}
else
{
throw new InvalidCastException($"{Next.GetType().GetFullName()} does not implement {nameof(IResolverFrame)}");
}
}
