/// <summary>
/// Builds all of the validators for a given method, parameter position, with the defined RunWhen.
/// </summary>
/// <param name="method">The method.</param>
/// <param name="parameterPosition">The parameter position.</param>
/// <param name="runner">The runner.</param>
/// <param name="runWhen">The run when.</param>
/// <param name="parameterInfoMeta">Metadata about the parameters such as whether or not it is params</param>
/// <returns></returns>
public IValidator[] GetValidatorsFor(MethodInfo method, int parameterPosition, ValidatorRunner runner, RunWhen runWhen,
out ParameterInfoMeta parameterInfoMeta)
{
MethodValidatorMetaInfo meta = type2MetaInfo[method.DeclaringType];
List <IValidator> validators = new List <IValidator>();
IValidatorBuilder[] builders = meta.GetBuilders(method, parameterPosition, out parameterInfoMeta);
ParameterInfo[] parameters = method.GetParameters();
foreach (IValidatorBuilder builder in builders)
{
IValidator validator = builder.Build(runner, typeof(MethodInfo));
if (!IsValidatorOnPhase(validator, runWhen))
{
continue;
}
if (string.IsNullOrEmpty(validator.FriendlyName))
{
validator.FriendlyName = parameters[parameterPosition].Name;
}
validator.Initialize(registry, null);
validators.Add(validator);
}
return(validators.ToArray());
}
/// <summary>
/// Validates the specified model to make sure that any methods that are being intercepted
/// are virtual and can be intercepted.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="store">The store.</param>
private void Validate(ComponentModel model, MethodValidatorMetaStore store)
{
if (model.Service == null || model.Service.IsInterface)
{
return;
}
MethodValidatorMetaInfo meta = store.GetMetaFor(model.Implementation);
if (meta == null)
{
return;
}
List <string> problematicMethods = new List <string>();
foreach (MethodInfo method in meta.Methods)
{
if (!method.IsVirtual)
{
problematicMethods.Add(method.Name);
}
}
if (problematicMethods.Count != 0)
{
String message = String.Format("The class {0} wants to use method validator interception, " +
"however the methods must be marked as virtual in order to do so. Please correct " +
"the following methods: {1}", model.Implementation.FullName,
String.Join(", ", problematicMethods.ToArray()));
throw new FacilityException(message);
}
}
private MethodValidatorMetaInfo CreateMetaInfo(Type service, Type implementation)
{
if (type2MetaInfo.Keys.Contains(service))
return type2MetaInfo[service];
MethodValidatorMetaInfo meta = new MethodValidatorMetaInfo();
foreach (MethodInfo methodInfo in implementation.GetMethods(DefaultBindingFlags))
{
MethodInfo serviceMethodInfo = service == implementation
? methodInfo
: GetMethodInfoFromService(service, implementation, methodInfo);
ParameterInfo[] parameterInfo = methodInfo.GetParameters();
for (int parameterPosition = 0; parameterPosition < parameterInfo.Length; parameterPosition++)
{
ParameterInfo parameter = parameterInfo[parameterPosition];
object[] builders = parameter.GetCustomAttributes(typeof(IValidatorBuilder), true);
foreach (IValidatorBuilder builder in builders)
{
builder.Initialize(registry, null);
ParameterInfoMeta parameterMeta = GetParameterMeta(methodInfo);
meta.AddBuilder(serviceMethodInfo, parameterPosition, builder, parameterMeta);
}
}
}
return meta;
}
/// <summary>
/// Adds the method interceptor to the type if there are methods that have validators
/// declared.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="store">The store.</param>
private static void AddMethodInterceptorIfValidatable(ComponentModel model, MethodValidatorMetaStore store)
{
MethodValidatorMetaInfo meta = store.GetMetaFor(GetServiceOrDefault(model));
if (meta == null)
{
return;
}
model.Dependencies.Add(new DependencyModel(DependencyType.Service, null, typeof(MethodValidatorInterceptor), false));
model.Interceptors.AddFirst(new InterceptorReference(typeof(MethodValidatorInterceptor)));
}
private MethodValidatorMetaInfo CreateMetaInfo(Type service, Type implementation)
{
if (type2MetaInfo.Keys.Contains(service))
{
return(type2MetaInfo[service]);
}
MethodValidatorMetaInfo meta = new MethodValidatorMetaInfo();
foreach (MethodInfo methodInfo in implementation.GetMethods(DefaultBindingFlags))
{
MethodInfo serviceMethodInfo = service == implementation
? methodInfo
: GetMethodInfoFromService(service, implementation, methodInfo);
ParameterInfo[] parameterInfo = methodInfo.GetParameters();
for (int parameterPosition = 0; parameterPosition < parameterInfo.Length; parameterPosition++)
{
ParameterInfo parameter = parameterInfo[parameterPosition];
object[] builders = parameter.GetCustomAttributes(typeof(IValidatorBuilder), true);
foreach (IValidatorBuilder builder in builders)
{
builder.Initialize(registry, null);
ParameterInfoMeta parameterMeta = GetParameterMeta(methodInfo);
meta.AddBuilder(serviceMethodInfo, parameterPosition, builder, parameterMeta);
}
}
}
return(meta);
}
public void CreateMetaFromType(Type service, Type implementation)
{
MethodValidatorMetaInfo info = CreateMetaInfo(service, implementation);
Register(service, info);
}
private void Register(Type service, MethodValidatorMetaInfo validatorMetaInfo)
{
type2MetaInfo[service] = validatorMetaInfo;
}
private void Register(Type service, MethodValidatorMetaInfo validatorMetaInfo)
{
type2MetaInfo[service] = validatorMetaInfo;
}
