public static bool AsyncStateMachineBuilderIsNeeded(FluentActionDefinition fluentActionDefinition)
{
// An AsyncStateMachineBuilder is not needed when there is only one handler invoking an async func
return fluentActionDefinition.IsAsync &&
(fluentActionDefinition.Handlers.Count() > 1 ||
(fluentActionDefinition.Handlers.Count() == 1 && fluentActionDefinition.Handlers.First().Type != FluentActionHandlerType.Func));
}
public override ParameterBuilder DefineMethodParameter(
MethodBuilder methodBuilder,
FluentActionDefinition actionDefinition,
FluentActionUsingDefinition usingDefinition,
int parameterIndex)
{
var parameterBuilder = base.DefineMethodParameter(methodBuilder, actionDefinition, usingDefinition, parameterIndex);
var attributeType = typeof(FromRouteAttribute);
var name = ((FluentActionUsingRouteParameterDefinition)usingDefinition).Name;
if (!actionDefinition.RouteTemplate.Contains($"{{{name}}}", StringComparison.CurrentCultureIgnoreCase))
{
throw new Exception($"Route parameter {name} does not exist in routeTemplate {actionDefinition.RouteTemplate}.");
}
var attributeBuilder = new CustomAttributeBuilder(
attributeType.GetConstructor(new Type[0]),
new Type[0],
new[] { attributeType.GetProperty("Name") },
new object[] { name });
parameterBuilder.SetCustomAttribute(attributeBuilder);
return(parameterBuilder);
}
public FluentActionWithView(FluentActionDefinition fluentActionDefinition, string pathToView)
: base(fluentActionDefinition)
{
Definition.ExistingOrNewHandlerDraft.Type = FluentActionHandlerType.View;
Definition.ExistingOrNewHandlerDraft.ViewTarget = pathToView;
Definition.ExistingOrNewHandlerDraft.ReturnType = typeof(ViewResult);
Definition.ExistingOrNewHandlerDraft.Async = false;
Definition.CommitHandlerDraft();
}
public FluentActionWithViewComponent(FluentActionDefinition fluentActionDefinition, Type viewComponentType)
: base(fluentActionDefinition)
{
Definition.ExistingOrNewHandlerDraft.Type = FluentActionHandlerType.ViewComponent;
Definition.ExistingOrNewHandlerDraft.ViewComponentType = viewComponentType;
Definition.ExistingOrNewHandlerDraft.ReturnType = typeof(ViewComponentResult);
Definition.ExistingOrNewHandlerDraft.Async = false;
Definition.CommitHandlerDraft();
}
public FluentActionWithControllerResult(FluentActionDefinition fluentActionDefinition, LambdaExpression actionExpression)
: base(fluentActionDefinition)
{
var returnType = typeof(TR);
Definition.ExistingOrNewHandlerDraft.Type = FluentActionHandlerType.Controller;
Definition.ExistingOrNewHandlerDraft.Expression = actionExpression;
Definition.ExistingOrNewHandlerDraft.ReturnType = returnType.IsAnonymous() ? typeof(object) : returnType;
Definition.CommitHandlerDraft();
}
public override ParameterBuilder DefineMethodParameter(
MethodBuilder methodBuilder,
FluentActionDefinition actionDefinition,
FluentActionUsingDefinition usingDefinition,
int parameterIndex)
{
var parameterBuilder = base.DefineMethodParameter(methodBuilder, actionDefinition, usingDefinition, parameterIndex);
var attributeType = typeof(ModelBinderAttribute);
var modelBinderDefinition = ((FluentActionUsingModelBinderDefinition)usingDefinition);
var modelBinderType = modelBinderDefinition.ModelBinderType;
PropertyInfo[] propertyTypes = null;
object[] propertyValues = null;
if (!string.IsNullOrWhiteSpace(modelBinderDefinition.ParameterName))
{
propertyTypes = new[]
{
attributeType.GetProperty("BinderType"),
attributeType.GetProperty("Name")
};
propertyValues = new object[]
{
modelBinderType,
modelBinderDefinition.ParameterName
};
}
else
{
propertyTypes = new[]
{
attributeType.GetProperty("BinderType")
};
propertyValues = new object[]
{
modelBinderType
};
}
var attributeBuilder = new CustomAttributeBuilder(
attributeType.GetConstructor(new Type[0]),
new Type[0],
propertyTypes,
propertyValues);
parameterBuilder.SetCustomAttribute(attributeBuilder);
return(parameterBuilder);
}
public override ParameterBuilder DefineMethodParameter(
MethodBuilder methodBuilder,
FluentActionDefinition actionDefinition,
FluentActionUsingDefinition usingDefinition,
int parameterIndex)
{
var parameterBuilder = base.DefineMethodParameter(methodBuilder, actionDefinition, usingDefinition, parameterIndex);
var attributeBuilder = new CustomAttributeBuilder(typeof(FromFormAttribute)
.GetConstructor(new Type[0]), new Type[0]);
parameterBuilder.SetCustomAttribute(attributeBuilder);
return(parameterBuilder);
}
public virtual ParameterBuilder DefineMethodParameter(MethodBuilder methodBuilder,
FluentActionDefinition actionDefinition,
FluentActionUsingDefinition usingDefinition,
int parameterIndex)
{
var parameterBuilder = methodBuilder.DefineParameter(
parameterIndex,
usingDefinition.HasDefaultValue ? ParameterAttributes.HasDefault : ParameterAttributes.None,
usingDefinition.MethodParameterName ?? $"parameter{parameterIndex}");
if (usingDefinition.HasDefaultValue)
{
parameterBuilder.SetConstant(usingDefinition.DefaultValue);
}
return(parameterBuilder);
}
private static TypeInfo DefineControllerType(
FluentActionDefinition fluentActionDefinition,
ILogger logger = null)
{
if (fluentActionDefinition == null)
{
throw new ArgumentNullException(nameof(fluentActionDefinition));
}
var guid = Guid.NewGuid().ToString().Replace("-", "");
var typeName = $"FluentAction{guid}Controller";
var controllerTypeBuilder = ControllerTypeBuilder.Create(
"FluentActionAssembly",
"FluentActionModule",
typeName,
fluentActionDefinition.ParentType);
foreach (var customAttributeOnClass in fluentActionDefinition.CustomAttributesOnClass)
{
controllerTypeBuilder.SetCustomAttribute(
customAttributeOnClass.Constructor,
customAttributeOnClass.ConstructorArgs,
customAttributeOnClass.NamedProperties,
customAttributeOnClass.PropertyValues,
customAttributeOnClass.NamedFields,
customAttributeOnClass.FieldValues
);
}
ControllerMethodBuilder controllerMethodBuilder;
if (AsyncStateMachineBuilderIsNeeded(fluentActionDefinition))
{
controllerMethodBuilder = new ControllerMethodBuilderForFluentActionAsync(fluentActionDefinition, logger);
}
else
{
controllerMethodBuilder = new ControllerMethodBuilderForFluentAction(fluentActionDefinition);
}
controllerTypeBuilder.BuildMethod(ActionName, controllerMethodBuilder);
return controllerTypeBuilder.CreateTypeInfo();
}
public override ParameterBuilder DefineMethodParameter(
MethodBuilder methodBuilder,
FluentActionDefinition actionDefinition,
FluentActionUsingDefinition usingDefinition,
int parameterIndex)
{
var parameterBuilder = base.DefineMethodParameter(methodBuilder, actionDefinition, usingDefinition, parameterIndex);
var attributeType = typeof(FromFormAttribute);
var key = ((FluentActionUsingFormValueDefinition)usingDefinition).Key;
var attributeBuilder = new CustomAttributeBuilder(
attributeType.GetConstructor(new Type[0]),
new Type[0],
new[] { attributeType.GetProperty("Name") },
new object[] { key });
parameterBuilder.SetCustomAttribute(attributeBuilder);
return(parameterBuilder);
}
public FluentActionWithMvcController(FluentActionDefinition fluentActionDefinition, FluentActionUsingDefinition usingDefinition) : base(fluentActionDefinition)
{
Definition.ExistingOrNewHandlerDraft.Usings.Add(usingDefinition);
}
public FluentActionBase(FluentActionDefinition actionDefinition)
{
Definition = actionDefinition;
}
public FluentActionBase(HttpMethod httpMethod, string routeTemplate, string id = null)
{
Definition = new FluentActionDefinition(routeTemplate, httpMethod, id);
}
