public bool Validate(object model, Type type, ModelMetadataProvider metadataProvider, HttpActionContext actionContext, string keyPrefix) {
if (type == null) {
throw new ArgumentNullException("type");
}
if (metadataProvider == null) {
throw new ArgumentNullException("metadataProvider");
}
if (actionContext == null) {
throw new ArgumentNullException("actionContext");
}
if (model != null && MediaTypeFormatterCollection.IsTypeExcludedFromValidation(model.GetType())) {
// no validation for some DOM like types
return true;
}
ModelValidatorProvider[] validatorProviders = actionContext.GetValidatorProviders().ToArray();
// Optimization : avoid validating the object graph if there are no validator providers
if (validatorProviders == null || validatorProviders.Length == 0) {
return true;
}
ModelMetadata metadata = metadataProvider.GetMetadataForType(() => model, type);
ValidationContext validationContext = new ValidationContext {
MetadataProvider = metadataProvider,
ActionContext = actionContext,
ModelState = actionContext.ModelState,
Visited = new HashSet<object>(),
KeyBuilders = new Stack<IKeyBuilder>(),
RootPrefix = keyPrefix
};
return this.ValidateNodeAndChildren(metadata, validationContext, container: null);
}
private ModelBindingContext GetModelBindingContext(ModelMetadataProvider metadataProvider, HttpActionContext actionContext)
{
string name = Descriptor.ParameterName;
Type type = Descriptor.ParameterType;
string prefix = Descriptor.Prefix;
IValueProvider vp = CreateValueProvider(this._valueProviderFactories, actionContext);
if (_metadataCache == null)
{
Interlocked.Exchange(ref _metadataCache, metadataProvider.GetMetadataForType(null, type));
}
ModelBindingContext ctx = new ModelBindingContext()
{
ModelName = prefix ?? name,
FallbackToEmptyPrefix = prefix == null, // only fall back if prefix not specified
ModelMetadata = _metadataCache,
ModelState = actionContext.ModelState,
ValueProvider = vp
};
if (_validationNodeCache == null)
{
Interlocked.Exchange(ref _validationNodeCache, ctx.ValidationNode);
}
else
{
ctx.ValidationNode = _validationNodeCache;
}
return ctx;
}
public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
{
string name = Descriptor.ParameterName;
Type type = Descriptor.ParameterType;
string prefix = Descriptor.Prefix;
IValueProvider vp = CreateValueProvider(this._valueProviderFactories, actionContext);
ModelBindingContext ctx = new ModelBindingContext()
{
ModelName = prefix ?? name,
FallbackToEmptyPrefix = prefix == null, // only fall back if prefix not specified
ModelMetadata = metadataProvider.GetMetadataForType(null, type),
ModelState = actionContext.ModelState,
ValueProvider = vp
};
IModelBinder binder = this._modelBinderProvider.GetBinder(actionContext, ctx);
bool haveResult = binder.BindModel(actionContext, ctx);
object model = haveResult ? ctx.Model : Descriptor.DefaultValue;
actionContext.ActionArguments.Add(name, model);
return TaskHelpers.Completed();
}
private static ModelValidationNode CreateModelValidationNode(object o, ModelMetadataProvider metadataProvider, ModelStateDictionary modelStateDictionary, string modelStateKey)
{
ModelMetadata metadata = metadataProvider.GetMetadataForType(() =>
{
return o;
}, o.GetType());
ModelValidationNode validationNode = new ModelValidationNode(metadata, modelStateKey);
// for this root node, recursively add all child nodes
HashSet<object> visited = new HashSet<object>();
CreateModelValidationNodeRecursive(o, validationNode, metadataProvider, metadata, modelStateDictionary, modelStateKey, visited);
return validationNode;
}
/// <summary>
/// Determines whether the <paramref name="model"/> is valid and adds any validation errors to the <paramref name="actionContext"/>'s <see cref="ModelStateDictionary"/>
/// </summary>
/// <param name="model">The model to be validated.</param>
/// <param name="type">The <see cref="Type"/> to use for validation.</param>
/// <param name="metadataProvider">The <see cref="ModelMetadataProvider"/> used to provide the model metadata.</param>
/// <param name="actionContext">The <see cref="HttpActionContext"/> within which the model is being validated.</param>
/// <param name="keyPrefix">The <see cref="string"/> to append to the key for any validation errors.</param>
/// <returns><c>true</c>if <paramref name="model"/> is valid, <c>false</c> otherwise.</returns>
public bool Validate(object model, Type type, ModelMetadataProvider metadataProvider, HttpActionContext actionContext, string keyPrefix)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (metadataProvider == null)
{
throw Error.ArgumentNull("metadataProvider");
}
if (actionContext == null)
{
throw Error.ArgumentNull("actionContext");
}
if (model != null && !ShouldValidateType(model.GetType()))
{
return true;
}
ModelValidatorProvider[] validatorProviders = actionContext.GetValidatorProviders().ToArray();
// Optimization : avoid validating the object graph if there are no validator providers
if (validatorProviders == null || validatorProviders.Length == 0)
{
return true;
}
ModelMetadata metadata = metadataProvider.GetMetadataForType(() => model, type);
ValidationContext validationContext = new ValidationContext()
{
MetadataProvider = metadataProvider,
ActionContext = actionContext,
ValidatorCache = actionContext.GetValidatorCache(),
ModelState = actionContext.ModelState,
Visited = new HashSet<object>(),
KeyBuilders = new Stack<IKeyBuilder>(),
RootPrefix = keyPrefix
};
return ValidateNodeAndChildren(metadata, validationContext, container: null);
}
private ModelBindingContext GetModelBindingContext(ModelMetadataProvider metadataProvider, HttpActionContext actionContext)
{
string name = Descriptor.ParameterName;
Type type = Descriptor.ParameterType;
string prefix = Descriptor.Prefix;
IValueProvider vp = CompositeValueProviderFactory.GetValueProvider(actionContext, _valueProviderFactories);
ModelBindingContext ctx = new ModelBindingContext()
{
ModelName = prefix ?? name,
FallbackToEmptyPrefix = prefix == null, // only fall back if prefix not specified
ModelMetadata = metadataProvider.GetMetadataForType(null, type),
ModelState = actionContext.ModelState,
ValueProvider = vp
};
return ctx;
}
/// <summary>
/// Determines whether the <paramref name="model"/> is valid and adds any validation errors to the <paramref name="actionContext"/>'s <see cref="ModelStateDictionary"/>
/// </summary>
/// <param name="model">The model to be validated.</param>
/// <param name="type">The <see cref="Type"/> to use for validation.</param>
/// <param name="metadataProvider">The <see cref="ModelMetadataProvider"/> used to provide the model metadata.</param>
/// <param name="actionContext">The <see cref="HttpActionContext"/> within which the model is being validated.</param>
/// <param name="keyPrefix">The <see cref="string"/> to append to the key for any validation errors.</param>
/// <returns><c>true</c>if <paramref name="model"/> is valid, <c>false</c> otherwise.</returns>
public bool Validate(object model, Type type, ModelMetadataProvider metadataProvider, HttpActionContext actionContext, string keyPrefix)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (metadataProvider == null)
{
throw Error.ArgumentNull("metadataProvider");
}
if (actionContext == null)
{
throw Error.ArgumentNull("actionContext");
}
ModelMetadata metadata = metadataProvider.GetMetadataForType(() => model, type);
ValidationContext validationContext = new ValidationContext() { ActionContext = actionContext, MetadataProvider = metadataProvider, Visited = new HashSet<object>() };
return ValidateNodeAndChildren(metadata, validationContext, container: null, prefix: keyPrefix);
}
/// <summary>
/// Determines whether the <paramref name="model"/> is valid and adds any validation errors to the <paramref name="actionContext"/>'s <see cref="ModelStateDictionary"/>
/// </summary>
/// <param name="model">The model to be validated.</param>
/// <param name="type">The <see cref="Type"/> to use for validation.</param>
/// <param name="metadataProvider">The <see cref="ModelMetadataProvider"/> used to provide the model metadata.</param>
/// <param name="actionContext">The <see cref="HttpActionContext"/> within which the model is being validated.</param>
/// <param name="keyPrefix">The <see cref="string"/> to append to the key for any validation errors.</param>
/// <returns><c>true</c>if <paramref name="model"/> is valid, <c>false</c> otherwise.</returns>
public bool Validate(object model, Type type, ModelMetadataProvider metadataProvider, HttpActionContext actionContext, string keyPrefix)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (metadataProvider == null)
{
throw Error.ArgumentNull("metadataProvider");
}
if (actionContext == null)
{
throw Error.ArgumentNull("actionContext");
}
if (model != null && MediaTypeFormatterCollection.IsTypeExcludedFromValidation(model.GetType()))
{
// no validation for some DOM like types
return true;
}
IEnumerable<ModelValidatorProvider> validatorProviders = actionContext.GetValidatorProviders();
// Optimization : avoid validating the object graph if there are no validator providers
if (validatorProviders == null || !validatorProviders.Any())
{
return true;
}
ModelMetadata metadata = metadataProvider.GetMetadataForType(() => model, type);
ValidationContext validationContext = new ValidationContext()
{
MetadataProvider = metadataProvider,
ValidatorProviders = validatorProviders,
ModelState = actionContext.ModelState,
Visited = new HashSet<object>()
};
return ValidateNodeAndChildren(metadata, validationContext, container: null, prefix: keyPrefix);
}
