public static T ReadAs <T>( this FormDataCollection formData, string modelName, IRequiredMemberSelector requiredMemberSelector, IFormatterLogger formatterLogger ) { return((T)ReadAs( formData, typeof(T), modelName, requiredMemberSelector, formatterLogger )); }
/// <summary> /// Initializes a new instance of the <see cref="MediaTypeFormatter"/> class. /// </summary> /// <param name="formatter">The <see cref="MediaTypeFormatter"/> instance to copy settings from.</param> protected MediaTypeFormatter(MediaTypeFormatter formatter) { if (formatter == null) { throw Error.ArgumentNull("formatter"); } _supportedMediaTypes = formatter._supportedMediaTypes; SupportedMediaTypes = formatter.SupportedMediaTypes; _supportedEncodings = formatter._supportedEncodings; SupportedEncodings = formatter.SupportedEncodings; _mediaTypeMappings = formatter._mediaTypeMappings; MediaTypeMappings = formatter.MediaTypeMappings; _requiredMemberSelector = formatter._requiredMemberSelector; }
/// <summary> /// Initializes a new instance of the <see cref="MediaTypeFormatter"/> class. /// </summary> /// <param name="formatter">The <see cref="MediaTypeFormatter"/> instance to copy settings from.</param> protected MediaTypeFormatter(MediaTypeFormatter formatter) { if (formatter == null) { throw Error.ArgumentNull("formatter"); } this._supportedMediaTypes = formatter._supportedMediaTypes; this.SupportedMediaTypes = formatter.SupportedMediaTypes; this._supportedEncodings = formatter._supportedEncodings; this.SupportedEncodings = formatter.SupportedEncodings; #if !NETFX_CORE // No MediaTypeMappings in portable library or IRequiredMemberSelector (no model state on client) this._mediaTypeMappings = formatter._mediaTypeMappings; this.MediaTypeMappings = formatter.MediaTypeMappings; this._requiredMemberSelector = formatter._requiredMemberSelector; #endif }
public static object ReadAs( this FormDataCollection formData, Type type, string modelName, IRequiredMemberSelector requiredMemberSelector, IFormatterLogger formatterLogger ) { return(ReadAs( formData, type, modelName, requiredMemberSelector, formatterLogger, config: null )); }
public RequiredMemberModelValidatorProvider(IRequiredMemberSelector requiredMemberSelector) { _requiredMemberSelector = requiredMemberSelector; }
public RequiredMemberModelValidatorProvider(IRequiredMemberSelector requiredMemberSelector) { _requiredMemberSelector = requiredMemberSelector; }
/// <summary> /// Deserialize the form data to the given type, using model binding. /// </summary> /// <param name="formData">collection with parsed form url data</param> /// <param name="type">target type to read as</param> /// <param name="modelName">null or empty to read the entire form as a single object. /// This is common for body data. Or the name of a model to do a partial binding against the form data. /// This is common for extracting individual fields.</param> /// <param name="requiredMemberSelector">The <see cref="IRequiredMemberSelector"/> /// used to determine required members.</param> /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param> /// <param name="config">The <see cref="HttpConfiguration"/> configuration to pick binder from. /// Can be null if the config was not created already. In that case a new config is created.</param> /// <returns>best attempt to bind the object. The best attempt may be null.</returns> public static object ReadAs( this FormDataCollection formData, Type type, string modelName, IRequiredMemberSelector requiredMemberSelector, IFormatterLogger formatterLogger, HttpConfiguration config ) { if (formData == null) { throw Error.ArgumentNull("formData"); } if (type == null) { throw Error.ArgumentNull("type"); } object result = null; HttpActionContext actionContext = null; bool validateRequiredMembers = requiredMemberSelector != null && formatterLogger != null; if (validateRequiredMembers) { // We wrap the config so we can override the services and cache // without affecting outside callers or users of the config. using (HttpConfiguration wrapperConfig = new HttpConfiguration()) { config = config == null ? wrapperConfig : config; wrapperConfig.Services = new ServicesContainerWrapper( config, new RequiredMemberModelValidatorProvider(requiredMemberSelector) ); // The HttpActionContext provides access to configuration for ModelBinders, and is also provided // to the IModelBinder when binding occurs. Since HttpActionContext was not provided, create a default. actionContext = CreateActionContextForModelBinding(wrapperConfig); result = ReadAs(formData, type, modelName, actionContext); } } else { if (config == null) { using (config = new HttpConfiguration()) { actionContext = CreateActionContextForModelBinding(config); result = ReadAs(formData, type, modelName, actionContext); } } else { actionContext = CreateActionContextForModelBinding(config); result = ReadAs(formData, type, modelName, actionContext); } } // The model binding will log any errors to the HttpActionContext's ModelState. Since this is a context // that we created and doesn't map to a real action invocation, we want to forward the errors to // the user-specified IFormatterLogger. if (formatterLogger != null) { foreach ( KeyValuePair <string, ModelState> modelStatePair in actionContext.ModelState ) { foreach (ModelError modelError in modelStatePair.Value.Errors) { if (modelError.Exception != null) { formatterLogger.LogError(modelStatePair.Key, modelError.Exception); } else { formatterLogger.LogError(modelStatePair.Key, modelError.ErrorMessage); } } } } return(result); }
/// <summary> /// Deserialize the form data to the given type, using model binding. /// </summary> /// <param name="formData">collection with parsed form url data</param> /// <param name="type">target type to read as</param> /// <param name="modelName">null or empty to read the entire form as a single object. This is common for body data. /// <param name="requiredMemberSelector">The <see cref="IRequiredMemberSelector"/> used to determine required members.</param> /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param> /// Or the name of a model to do a partial binding against the form data. This is common for extracting individual fields.</param> /// <returns>best attempt to bind the object. The best attempt may be null.</returns> public static object ReadAs(this FormDataCollection formData, Type type, string modelName, IRequiredMemberSelector requiredMemberSelector, IFormatterLogger formatterLogger) { if (formData == null) { throw Error.ArgumentNull("formData"); } if (type == null) { throw Error.ArgumentNull("type"); } if (modelName == null) { modelName = string.Empty; } using (HttpConfiguration config = new HttpConfiguration()) { bool validateRequiredMembers = requiredMemberSelector != null && formatterLogger != null; if (validateRequiredMembers) { // Set a ModelValidatorProvider that understands the IRequiredMemberSelector config.Services.Replace(typeof(ModelValidatorProvider), new RequiredMemberModelValidatorProvider(requiredMemberSelector)); } // Looks like HttpActionContext is just a way of getting to the config, which we really // just need to get a list of modelbinderPRoviders for composition. HttpControllerContext controllerContext = new HttpControllerContext() { Configuration = config }; HttpActionContext actionContext = new HttpActionContext { ControllerContext = controllerContext }; ModelMetadataProvider metadataProvider = config.Services.GetModelMetadataProvider(); // Create default over config IEnumerable <ModelBinderProvider> providers = config.Services.GetModelBinderProviders(); ModelBinderProvider modelBinderProvider = new CompositeModelBinderProvider(providers); IValueProvider vp = formData.GetJQueryValueProvider(); ModelBindingContext ctx = new ModelBindingContext() { ModelName = modelName, FallbackToEmptyPrefix = false, ModelMetadata = metadataProvider.GetMetadataForType(null, type), ModelState = actionContext.ModelState, ValueProvider = vp }; IModelBinder binder = modelBinderProvider.GetBinder(actionContext, ctx); bool haveResult = binder.BindModel(actionContext, ctx); // Log model binding errors if (validateRequiredMembers) { Contract.Assert(formatterLogger != null); foreach (KeyValuePair <string, ModelState> modelStatePair in actionContext.ModelState) { foreach (ModelError modelError in modelStatePair.Value.Errors) { formatterLogger.LogError(modelStatePair.Key, modelError.ErrorMessage); } } } if (haveResult) { return(ctx.Model); } return(null); } }
/// <summary> /// Deserialize the form data to the given type, using model binding. /// </summary> /// <param name="formData">collection with parsed form url data</param> /// <param name="type">target type to read as</param> /// <param name="modelName">null or empty to read the entire form as a single object. This is common for body data. /// <param name="requiredMemberSelector">The <see cref="IRequiredMemberSelector"/> used to determine required members.</param> /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param> /// Or the name of a model to do a partial binding against the form data. This is common for extracting individual fields.</param> /// <returns>best attempt to bind the object. The best attempt may be null.</returns> public static object ReadAs(this FormDataCollection formData, Type type, string modelName, IRequiredMemberSelector requiredMemberSelector, IFormatterLogger formatterLogger) { if (formData == null) { throw Error.ArgumentNull("formData"); } if (type == null) { throw Error.ArgumentNull("type"); } if (modelName == null) { modelName = String.Empty; } using (HttpConfiguration config = new HttpConfiguration()) { bool validateRequiredMembers = requiredMemberSelector != null && formatterLogger != null; if (validateRequiredMembers) { // Set a ModelValidatorProvider that understands the IRequiredMemberSelector config.Services.Replace(typeof(ModelValidatorProvider), new RequiredMemberModelValidatorProvider(requiredMemberSelector)); } // Looks like HttpActionContext is just a way of getting to the config, which we really // just need to get a list of modelbinderPRoviders for composition. HttpActionContext actionContext = CreateActionContextForModelBinding(config); IValueProvider vp = formData.GetJQueryValueProvider(); ModelBindingContext ctx = CreateModelBindingContext(actionContext, modelName, type, vp); ModelBinderProvider modelBinderProvider = CreateModelBindingProvider(actionContext); IModelBinder binder = modelBinderProvider.GetBinder(config, type); bool haveResult = binder.BindModel(actionContext, ctx); // Log model binding errors if (formatterLogger != null) { foreach (KeyValuePair <string, ModelState> modelStatePair in actionContext.ModelState) { foreach (ModelError modelError in modelStatePair.Value.Errors) { if (modelError.Exception != null) { formatterLogger.LogError(modelStatePair.Key, modelError.Exception); } else { formatterLogger.LogError(modelStatePair.Key, modelError.ErrorMessage); } } } } if (haveResult) { return(ctx.Model); } return(MediaTypeFormatter.GetDefaultValueForType(type)); } }
/// <summary> /// Deserialize the form data to the given type, using model binding. /// </summary> /// <param name="formData">collection with parsed form url data</param> /// <param name="type">target type to read as</param> /// <param name="modelName">null or empty to read the entire form as a single object. This is common for body data. /// Or the name of a model to do a partial binding against the form data. This is common for extracting individual fields.</param> /// <param name="requiredMemberSelector">The <see cref="IRequiredMemberSelector"/> used to determine required members.</param> /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param> /// <returns>best attempt to bind the object. The best attempt may be null.</returns> public static object ReadAs(this FormDataCollection formData, Type type, string modelName, IRequiredMemberSelector requiredMemberSelector, IFormatterLogger formatterLogger) { if (formData == null) { throw Error.ArgumentNull("formData"); } if (type == null) { throw Error.ArgumentNull("type"); } using (HttpConfiguration config = new HttpConfiguration()) { // The HttpActionContext provides access to configuration for ModelBinders, and is also provided // to the IModelBinder when binding occurs. Since an HttpActionContext was not provided, create a default. HttpActionContext actionContext = CreateActionContextForModelBinding(config); bool validateRequiredMembers = requiredMemberSelector != null && formatterLogger != null; if (validateRequiredMembers) { // Set a ModelValidatorProvider that understands the IRequiredMemberSelector config.Services.Replace(typeof(ModelValidatorProvider), new RequiredMemberModelValidatorProvider(requiredMemberSelector)); } object result = ReadAs(formData, type, modelName, actionContext); // The model binding will log any errors to the HttpActionContext's ModelState. Since this is a context // that we created and doesn't map to a real action invocation, we want to forward the errors to // the user-specified IFormatterLogger. if (formatterLogger != null) { foreach (KeyValuePair <string, ModelState> modelStatePair in actionContext.ModelState) { foreach (ModelError modelError in modelStatePair.Value.Errors) { if (modelError.Exception != null) { formatterLogger.LogError(modelStatePair.Key, modelError.Exception); } else { formatterLogger.LogError(modelStatePair.Key, modelError.ErrorMessage); } } } } return(result); } }