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