public override IValueProvider GetValueProvider(ModelBindingExecutionContext modelBindingExecutionContext) {
if (modelBindingExecutionContext == null) {
throw new ArgumentNullException("modelBindingExecutionContext");
}
return new FormValueProvider(modelBindingExecutionContext);
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
ModelBinderUtil.ValidateBindingContext(bindingContext, typeof(ComplexModel), false /* allowNullModel */);
ComplexModel complexModel = (ComplexModel)bindingContext.Model;
foreach (ModelMetadata propertyMetadata in complexModel.PropertyMetadata)
{
ModelBindingContext propertyBindingContext = new ModelBindingContext(bindingContext)
{
ModelMetadata = propertyMetadata,
ModelName = ModelBinderUtil.CreatePropertyModelName(bindingContext.ModelName, propertyMetadata.PropertyName)
};
// bind and propagate the values
IModelBinder propertyBinder = bindingContext.ModelBinderProviders.GetBinder(modelBindingExecutionContext, propertyBindingContext);
if (propertyBinder != null)
{
if (propertyBinder.BindModel(modelBindingExecutionContext, propertyBindingContext))
{
complexModel.Results[propertyMetadata] = new ComplexModelResult(propertyBindingContext.Model, propertyBindingContext.ValidationNode);
}
else
{
complexModel.Results[propertyMetadata] = null;
}
}
}
return(true);
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) {
ModelBindingContext newBindingContext = bindingContext;
IModelBinder binder = Providers.GetBinder(modelBindingExecutionContext, bindingContext);
if (binder == null && !String.IsNullOrEmpty(bindingContext.ModelName)
&& bindingContext.ModelMetadata.IsComplexType) {
// fallback to empty prefix?
newBindingContext = new ModelBindingContext(bindingContext) {
ModelName = String.Empty,
ModelMetadata = bindingContext.ModelMetadata
};
binder = Providers.GetBinder(modelBindingExecutionContext, newBindingContext);
}
if (binder != null) {
bool boundSuccessfully = binder.BindModel(modelBindingExecutionContext, newBindingContext);
if (boundSuccessfully) {
// run validation
newBindingContext.ValidationNode.Validate(modelBindingExecutionContext, parentNode:null);
return true;
}
}
return false; // something went wrong
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
Name = modelBindingExecutionContext.HttpContext.Request["Name"];
Age = Convert.ToInt32(modelBindingExecutionContext.HttpContext.Request["Age"]);
Reason = modelBindingExecutionContext.HttpContext.Request["Reason"];
return(true);
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) {
ModelBinderUtil.ValidateBindingContext(bindingContext);
ValueProviderResult vpResult = bindingContext.UnvalidatedValueProvider.GetValue(bindingContext.ModelName, skipValidation: !bindingContext.ValidateRequest);
if (vpResult == null) {
return false; // no entry
}
object newModel;
bindingContext.ModelState.SetModelValue(bindingContext.ModelName, vpResult);
try {
newModel = vpResult.ConvertTo(bindingContext.ModelType);
}
catch (Exception ex) {
if (IsFormatException(ex)) {
// there was a type conversion failure
string errorString = ModelBinderErrorMessageProviders.TypeConversionErrorMessageProvider(modelBindingExecutionContext, bindingContext.ModelMetadata, vpResult.AttemptedValue);
if (errorString != null) {
bindingContext.ModelState.AddModelError(bindingContext.ModelName, errorString);
}
}
else {
bindingContext.ModelState.AddModelError(bindingContext.ModelName, ex);
}
return false;
}
ModelBinderUtil.ReplaceEmptyStringWithNull(bindingContext.ModelMetadata, ref newModel);
bindingContext.Model = newModel;
return true;
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext,
System.Web.ModelBinding.ModelBindingContext bindingContext)
{
var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
bindingContext.Model = BindModelImpl(valueProviderResult != null ? valueProviderResult.AttemptedValue : null);
return bindingContext.Model != null;
}
private IValueProvider GetCustomValueProvider(ModelBindingExecutionContext modelBindingExecutionContext, ParameterInfo parameterInfo, ref string modelName, out bool validateRequest)
{
validateRequest = true;
object[] valueProviderAttributes = parameterInfo.GetCustomAttributes(typeof(IValueProviderSource), false);
if (valueProviderAttributes.Count() > 1)
{
throw new NotSupportedException(SR.GetString(SR.ModelDataSourceView_MultipleValueProvidersNotSupported, parameterInfo.Name));
}
if (valueProviderAttributes.Count() > 0)
{
IValueProviderSource valueProviderAttribute = (IValueProviderSource)valueProviderAttributes[0];
if (valueProviderAttribute is IModelNameProvider)
{
string name = ((IModelNameProvider)valueProviderAttribute).GetModelName();
if (!String.IsNullOrEmpty(name))
{
modelName = name;
}
}
if (valueProviderAttribute is IUnvalidatedValueProviderSource)
{
validateRequest = ((IUnvalidatedValueProviderSource)valueProviderAttribute).ValidateInput;
}
return(valueProviderAttribute.GetValueProvider(modelBindingExecutionContext));
}
return(null);
}
public void BlankKeyValueProviderTest()
{
StateController.Navigate("d0");
ModelBindingExecutionContext context = new ModelBindingExecutionContext(new MockHttpContext(), new ModelStateDictionary());
NavigationDataValueProvider provider = new NavigationDataValueProvider(context, false, null);
Assert.IsNull(provider.GetValue(""));
}
public IValueProvider GetValueProvider(ModelBindingExecutionContext modelBindingExecutionContext) {
if (modelBindingExecutionContext == null) {
throw new ArgumentNullException("modelBindingExecutionContext");
}
return new UserProfileValueProvider(modelBindingExecutionContext);
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, System.Web.ModelBinding.ModelBindingContext bindingContext)
{
var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
bindingContext.Model = BindModelImpl(valueProviderResult != null ? valueProviderResult.AttemptedValue : null);
return(bindingContext.Model != null);
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) {
ModelBinderUtil.ValidateBindingContext(bindingContext);
ValueProviderResult vpResult = bindingContext.UnvalidatedValueProvider.GetValue(bindingContext.ModelName);
// case 1: there was no <input ... /> element containing this data
if (vpResult == null) {
return false;
}
string base64string = (string)vpResult.ConvertTo(typeof(string));
// case 2: there was an <input ... /> element but it was left blank
if (String.IsNullOrEmpty(base64string)) {
return false;
}
// Future proofing. If the byte array is actually an instance of System.Data.Linq.Binary
// then we need to remove these quotes put in place by the ToString() method.
string realValue = base64string.Replace("\"", String.Empty);
try {
bindingContext.Model = ConvertByteArray(Convert.FromBase64String(realValue));
return true;
}
catch {
// corrupt data - just ignore
return false;
}
}
private static string GetValueRequiredResource(ModelBindingExecutionContext modelBindingExecutionContext)
{
string userResourceString = GetUserResourceString(modelBindingExecutionContext, "PropertyValueRequired");
return(userResourceString);
}
public override IWebFormsModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, WebFormsModelBindingContext bindingContext)
{
if (bindingContext.ModelType == typeof(DbGeography))
{
return(new DbGeographyModelBinder());
}
return(null);
}
public ModelValidatingEventArgs(ModelBindingExecutionContext modelBindingExecutionContext, ModelValidationNode parentNode) {
if (modelBindingExecutionContext == null) {
throw new ArgumentNullException("modelBindingExecutionContext");
}
ModelBindingExecutionContext = modelBindingExecutionContext;
ParentNode = parentNode;
}
public override System.Web.ModelBinding.IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, System.Web.ModelBinding.ModelBindingContext bindingContext)
{
if (bindingContext.ModelType == typeof(DbGeography))
{
return(new DbGeographyModelBinder());
}
return(null);
}
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
if (bindingContext.ModelType == typeof(DateTime))
{
return(new MyDateTimeBinder());
}
return(null);
}
public override System.Web.ModelBinding.IModelBinder GetBinder(
ModelBindingExecutionContext modelBindingExecutionContext,
System.Web.ModelBinding.ModelBindingContext bindingContext)
{
if (bindingContext.ModelType == typeof (DbGeography))
return new DbGeographyModelBinder();
return null;
}
public DataAnnotationsModelValidator(ModelMetadata metadata, ModelBindingExecutionContext context, ValidationAttribute attribute)
: base(metadata, context) {
if (attribute == null) {
throw new ArgumentNullException("attribute");
}
Attribute = attribute;
}
public override IValueProvider GetValueProvider(ModelBindingExecutionContext modelBindingExecutionContext)
{
if (modelBindingExecutionContext == null)
{
throw new ArgumentNullException("modelBindingExecutionContext");
}
return(new ViewStateValueProvider(modelBindingExecutionContext));
}
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) {
ModelBinderUtil.ValidateBindingContext(bindingContext);
if (bindingContext.UnvalidatedValueProvider.ContainsPrefix(bindingContext.ModelName)) {
return CollectionModelBinderUtil.GetGenericBinder(typeof(IDictionary<,>), typeof(Dictionary<,>), typeof(DictionaryModelBinder<,>), bindingContext.ModelMetadata);
}
else {
return null;
}
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
var inputdate = valueProviderResult != null ? valueProviderResult.AttemptedValue : null;
DateTime newDate = new DateTime();
bool success = DateTime.TryParse(inputdate, CultureInfo.GetCultureInfo("en-GB"), DateTimeStyles.None, out newDate);
bindingContext.Model = newDate;
return(bindingContext.Model != null);
}
private static string GetUserResourceString(ModelBindingExecutionContext modelBindingExecutionContext, string resourceName, string resourceClassKey)
{
if (string.IsNullOrEmpty(resourceClassKey) || modelBindingExecutionContext == null || modelBindingExecutionContext.HttpContext == null)
{
return null;
}
else
{
return modelBindingExecutionContext.HttpContext.GetGlobalResourceObject(resourceClassKey, resourceName, CultureInfo.CurrentUICulture) as string;
}
}
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) {
ModelBinderUtil.ValidateBindingContext(bindingContext);
if (!bindingContext.ModelMetadata.IsReadOnly && bindingContext.ModelType.IsArray &&
bindingContext.UnvalidatedValueProvider.ContainsPrefix(bindingContext.ModelName)) {
Type elementType = bindingContext.ModelType.GetElementType();
return (IModelBinder)Activator.CreateInstance(typeof(ArrayModelBinder<>).MakeGenericType(elementType));
}
return null;
}
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) {
ModelBinderUtil.ValidateBindingContext(bindingContext);
if (bindingContext.ModelType == ModelType) {
if (SuppressPrefixCheck || bindingContext.UnvalidatedValueProvider.ContainsPrefix(bindingContext.ModelName)) {
return _modelBinderFactory();
}
}
return null;
}
private static string GetUserResourceString(ModelBindingExecutionContext modelBindingExecutionContext, string resourceName, string resourceClassKey)
{
if (string.IsNullOrEmpty(resourceClassKey) || modelBindingExecutionContext == null || modelBindingExecutionContext.HttpContext == null)
{
return(null);
}
else
{
return(modelBindingExecutionContext.HttpContext.GetGlobalResourceObject(resourceClassKey, resourceName, CultureInfo.CurrentUICulture) as string);
}
}
protected ModelValidator(ModelMetadata metadata, ModelBindingExecutionContext modelBindingExecutionContext) {
if (metadata == null) {
throw new ArgumentNullException("metadata");
}
if (modelBindingExecutionContext == null) {
throw new ArgumentNullException("modelBindingExecutionContext");
}
Metadata = metadata;
ModelBindingExecutionContext = modelBindingExecutionContext;
}
public object BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
Cart cart = (Cart)modelBindingExecutionContext.HttpContext.Session["sessionKey"];
if (cart == null)
{
cart = new Cart();
modelBindingExecutionContext.HttpContext.Session["sessionKey"] = cart;
}
return(cart);
}
public void NavigationDataValueProviderTest()
{
NavigationData data = new NavigationData() {
{ "string", "Hello" }, {"int", 1 }
};
StateController.Navigate("d0", data);
ModelBindingExecutionContext context = new ModelBindingExecutionContext(new MockHttpContext(), new ModelStateDictionary());
NavigationDataValueProvider provider = new NavigationDataValueProvider(context, false, null);
Assert.AreEqual("Hello", provider.GetValue("string").RawValue);
Assert.AreEqual(1, provider.GetValue("int").RawValue);
Assert.AreEqual("1", provider.GetValue("int").AttemptedValue);
}
private ComplexModel CreateAndPopulateComplexModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext, IEnumerable<ModelMetadata> propertyMetadatas) {
// create a Complex Model and call into the Complex Model binder
ComplexModel originalComplexModel = new ComplexModel(bindingContext.ModelMetadata, propertyMetadatas);
ModelBindingContext complexModelBindingContext = new ModelBindingContext(bindingContext) {
ModelMetadata = MetadataProvider.GetMetadataForType(() => originalComplexModel, typeof(ComplexModel)),
ModelName = bindingContext.ModelName
};
IModelBinder complexModelBinder = bindingContext.ModelBinderProviders.GetRequiredBinder(modelBindingExecutionContext, complexModelBindingContext);
complexModelBinder.BindModel(modelBindingExecutionContext, complexModelBindingContext);
return (ComplexModel)complexModelBindingContext.Model;
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) {
ValueProviderResult vpResult = GetCompatibleValueProviderResult(bindingContext);
if (vpResult == null) {
return false; // conversion would have failed
}
bindingContext.ModelState.SetModelValue(bindingContext.ModelName, vpResult);
object model = vpResult.RawValue;
ModelBinderUtil.ReplaceEmptyStringWithNull(bindingContext.ModelMetadata, ref model);
bindingContext.Model = model;
return true;
}
private static string GetResourceCommon(ModelBindingExecutionContext modelBindingExecutionContext, ModelMetadata modelMetadata, object incomingValue,
Func<ModelBindingExecutionContext, string> resourceAccessor)
{
string displayName = modelMetadata.GetDisplayName();
string str = resourceAccessor(modelBindingExecutionContext);
object[] objArray = new object[2];
objArray[0] = incomingValue;
objArray[1] = displayName;
string str1 = string.Format(CultureInfo.CurrentCulture, str, objArray);
return str1;
}
public override sealed IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ModelBindingExecutionContext context) {
if (metadata == null) {
throw new ArgumentNullException("metadata");
}
if (context == null) {
throw new ArgumentNullException("context");
}
if (metadata.ContainerType != null && !String.IsNullOrEmpty(metadata.PropertyName)) {
return GetValidatorsForProperty(metadata, context);
}
return GetValidatorsForType(metadata, context);
}
private IEnumerable<ModelValidator> GetValidatorsForProperty(ModelMetadata metadata, ModelBindingExecutionContext context) {
ICustomTypeDescriptor typeDescriptor = GetTypeDescriptor(metadata.ContainerType);
PropertyDescriptor property = typeDescriptor.GetProperties().Find(metadata.PropertyName, true);
if (property == null) {
throw new ArgumentException(
String.Format(
CultureInfo.CurrentCulture,
SR.GetString(SR.Common_PropertyNotFound),
metadata.ContainerType.FullName, metadata.PropertyName),
"metadata");
}
return GetValidators(metadata, context, property.Attributes.OfType<Attribute>());
}
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) {
ModelBinderUtil.ValidateBindingContext(bindingContext);
string keyFieldName = ModelBinderUtil.CreatePropertyModelName(bindingContext.ModelName, "key");
string valueFieldName = ModelBinderUtil.CreatePropertyModelName(bindingContext.ModelName, "value");
if (bindingContext.UnvalidatedValueProvider.ContainsPrefix(keyFieldName) && bindingContext.UnvalidatedValueProvider.ContainsPrefix(valueFieldName)) {
return ModelBinderUtil.GetPossibleBinderInstance(bindingContext.ModelType, typeof(KeyValuePair<,>) /* supported model type */, typeof(KeyValuePairModelBinder<,>) /* binder type */);
}
else {
// 'key' or 'value' missing
return null;
}
}
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) {
ModelBinderUtil.ValidateBindingContext(bindingContext);
ValueProviderResult vpResult = bindingContext.UnvalidatedValueProvider.GetValue(bindingContext.ModelName, skipValidation: !bindingContext.ValidateRequest);
if (vpResult == null) {
return null; // no value to convert
}
if (!TypeDescriptor.GetConverter(bindingContext.ModelType).CanConvertFrom(typeof(string))) {
return null; // this type cannot be converted
}
return new TypeConverterModelBinder();
}
public void CustomPropertyControlDataValueProviderTest()
{
StateController.Navigate("d0");
StateContext.Data["double"] = 5d;
ModelBindingExecutionContext context = new ModelBindingExecutionContext(new MockHttpContext(), new ModelStateDictionary());
Page page = new Page();
TextBox textBox = new TextBox();
textBox.ID = "textBox";
textBox.CssClass = "double";
page.Controls.Add(textBox);
context.PublishService<Control>(page);
NavigationDataValueProvider provider = new NavigationDataValueProvider(context, true, "CssClass");
Assert.AreEqual(5d, provider.GetValue("textBox").RawValue);
}
public virtual bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) {
// Recursive method - prevent stack overflow.
RuntimeHelpers.EnsureSufficientExecutionStack();
ModelBinderUtil.ValidateBindingContext(bindingContext);
EnsureModel(modelBindingExecutionContext, bindingContext);
IEnumerable<ModelMetadata> propertyMetadatas = GetMetadataForProperties(modelBindingExecutionContext, bindingContext);
ComplexModel complexModel = CreateAndPopulateComplexModel(modelBindingExecutionContext, bindingContext, propertyMetadatas);
// post-processing, e.g. property setters and hooking up validation
ProcessComplexModel(modelBindingExecutionContext, bindingContext, complexModel);
bindingContext.ValidationNode.ValidateAllProperties = true; // complex models require full validation
return true;
}
private static string GetResourceCommon(ModelBindingExecutionContext modelBindingExecutionContext, ModelMetadata modelMetadata, object incomingValue,
Func <ModelBindingExecutionContext, string> resourceAccessor)
{
string displayName = modelMetadata.GetDisplayName();
string str = resourceAccessor(modelBindingExecutionContext);
object[] objArray = new object[2];
objArray[0] = incomingValue;
objArray[1] = displayName;
string str1 = string.Format(CultureInfo.CurrentCulture, str, objArray);
return(str1);
}
public void DefaultPropertyControlDataValueProviderTest()
{
StateController.Navigate("d0");
StateController.Navigate("t0");
StateContext.Data["i"] = 1;
ModelBindingExecutionContext context = new ModelBindingExecutionContext(new MockHttpContext(), new ModelStateDictionary());
Page page = new Page();
TextBox textBox = new TextBox();
textBox.ID = "textBox";
textBox.Text = "i";
page.Controls.Add(textBox);
context.PublishService<Control>(page);
NavigationDataValueProvider provider = new NavigationDataValueProvider(context, true, null);
Assert.AreEqual(1, provider.GetValue("textBox").RawValue);
}
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext) {
ModelBinderUtil.ValidateBindingContext(bindingContext);
if (!bindingContext.UnvalidatedValueProvider.ContainsPrefix(bindingContext.ModelName)) {
// no values to bind
return null;
}
if (bindingContext.ModelType == typeof(ComplexModel)) {
// forbidden type - will cause a stack overflow if we try binding this type
return null;
}
return new MutableObjectModelBinder();
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
ValueProviderResult vpResult = GetCompatibleValueProviderResult(bindingContext);
if (vpResult == null)
{
return(false); // conversion would have failed
}
bindingContext.ModelState.SetModelValue(bindingContext.ModelName, vpResult);
object model = vpResult.RawValue;
ModelBinderUtil.ReplaceEmptyStringWithNull(bindingContext.ModelMetadata, ref model);
bindingContext.Model = model;
return(true);
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
//var valueProvider = bindingContext.ValueProvider;
//int x = (int)valueProvider.GetValue("X").ConvertTo(typeof(int));
//int y = (int)valueProvider.GetValue("Y").ConvertTo(typeof(int));
//if (!bindingContext.FallbackToEmptyPrefix)
// return false;
//bindingContext = new ModelBindingContext
//{
// ModelMetadata = bindingContext.ModelMetadata,
// ModelState = bindingContext.ModelState,
// ValueProvider = bindingContext.ValueProvider
//};
return(true);
}
/// <summary>
/// Revalidates the model passed as the first parameter.
/// </summary>
/// <param name="model">The model instance you wish to validate.</param>
/// <returns></returns>
protected internal bool TryValidateModel(object model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
System.Web.ModelBinding.ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType());
var t = new ModelBindingExecutionContext(new HttpContextWrapper(HttpContext.Current), new System.Web.ModelBinding.ModelStateDictionary());
foreach (ModelValidationResult validationResult in ModelValidator.GetModelValidator(metadata, t).Validate(null))
{
ModelState.AddModelError(validationResult.MemberName, validationResult.Message);
}
return ModelState.IsValid;
}
public ModelBinderWrapper(object model = null)
{
modelBinder = new DefaultModelBinder();
modelState = new ModelStateDictionary();
var contextBase = new HttpContextWrapper(HttpContext.Current);
executingContext = new ModelBindingExecutionContext(contextBase, modelState);
bindingContext = new ModelBindingContext();
bindingContext.ValueProvider = new FormValueProvider(executingContext);
if (model != null)
{
setModel(model);
BindModel();
}
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
//var valueProvider = bindingContext.ValueProvider;
//int x = (int)valueProvider.GetValue("X").ConvertTo(typeof(int));
//int y = (int)valueProvider.GetValue("Y").ConvertTo(typeof(int));
//if (!bindingContext.FallbackToEmptyPrefix)
// return false;
//bindingContext = new ModelBindingContext
//{
// ModelMetadata = bindingContext.ModelMetadata,
// ModelState = bindingContext.ModelState,
// ValueProvider = bindingContext.ValueProvider
//};
return true;
}
public override IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
ModelBinderUtil.ValidateBindingContext(bindingContext);
if (!bindingContext.UnvalidatedValueProvider.ContainsPrefix(bindingContext.ModelName))
{
// no values to bind
return(null);
}
if (bindingContext.ModelType == typeof(ComplexModel))
{
// forbidden type - will cause a stack overflow if we try binding this type
return(null);
}
return(new MutableObjectModelBinder());
}
public ModelBinderWrapper(object model = null)
{
modelBinder = new DefaultModelBinder();
modelState = new ModelStateDictionary();
var contextBase = new HttpContextWrapper(HttpContext.Current);
executingContext = new ModelBindingExecutionContext(contextBase, modelState);
bindingContext = new ModelBindingContext();
bindingContext.ValueProvider = new FormValueProvider(executingContext);
if (model != null)
{
setModel(model);
BindModel();
}
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
Cart cart = null;
if (modelBindingExecutionContext.HttpContext.Session != null)
{
cart = modelBindingExecutionContext.HttpContext.Session[sessionKey] as Cart;
}
if (cart == null)
{
cart = new Cart();
if (modelBindingExecutionContext.HttpContext.Session != null)
{
modelBindingExecutionContext.HttpContext.Session[sessionKey] = cart;
}
}
return(true);
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
var request = new AspNetRequest(modelBindingExecutionContext.HttpContext.Request);
var binder = BinderCollection.FindBinderFor(bindingContext.ModelName, bindingContext.ModelType, request, null);
if (binder == null)
return false;
var bindingResult = binder.Bind(bindingContext.ModelName, bindingContext.ModelType, request, false, null);
if(!bindingResult.BoundSuccessfully)
{
foreach (var error in bindingResult.BindingErrors)
modelBindingExecutionContext.ModelState.AddModelError(error.Key, error.Message);
}
return bindingResult.BoundSuccessfully;
}
protected internal bool TryValidateModel(object model, string prefix, out string _modelError)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()); //using System.Web.ModelBinding;
var t = new ModelBindingExecutionContext(new HttpContextWrapper(HttpContext.Current), new System.Web.ModelBinding.ModelStateDictionary()); //using System.Web;
foreach (ModelValidationResult validationResult in ModelValidator.GetModelValidator(metadata, t).Validate(null))
{
ModelState.AddModelError(validationResult.MemberName, validationResult.Message);
}
_modelError = string.Join(" | ", ModelState.Values
.SelectMany(v => v.Errors)
.Select(e => e.ErrorMessage));
return(ModelState.IsValid);
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
ValueProviderResult result = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
if (null == result)
{
return(false);
}
try
{
bindingContext.Model = result.ConvertTo(bindingContext.ModelType);
if (bindingContext.Model is string && string.IsNullOrWhiteSpace((string)bindingContext.Model) && bindingContext.ModelMetadata.ConvertEmptyStringToNull)
{
bindingContext.Model = null;
}
return(true);
}
catch
{
return(false);
}
}
public static bool TryBindStrongModel <TModel>(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext parentBindingContext, string propertyName, ModelMetadataProvider metadataProvider, out TModel model)
{
ModelBindingContext propertyBindingContext = new ModelBindingContext(parentBindingContext)
{
ModelMetadata = metadataProvider.GetMetadataForType(null, typeof(TModel)),
ModelName = ModelBinderUtil.CreatePropertyModelName(parentBindingContext.ModelName, propertyName)
};
IModelBinder binder = parentBindingContext.ModelBinderProviders.GetBinder(modelBindingExecutionContext, propertyBindingContext);
if (binder != null)
{
if (binder.BindModel(modelBindingExecutionContext, propertyBindingContext))
{
object untypedModel = propertyBindingContext.Model;
model = ModelBinderUtil.CastOrDefault <TModel>(untypedModel);
parentBindingContext.ValidationNode.ChildNodes.Add(propertyBindingContext.ValidationNode);
return(true);
}
}
model = default(TModel);
return(false);
}
private static string GetUserResourceString(ModelBindingExecutionContext modelBindingExecutionContext, string resourceName)
{
return(GetUserResourceString(modelBindingExecutionContext, resourceName, _resourceClassKey));
}
private static string DefaultValueRequiredErrorMessageProvider(ModelBindingExecutionContext modelBindingExecutionContext, ModelMetadata modelMetadata, object incomingValue)
{
return(GetResourceCommon(modelBindingExecutionContext, modelMetadata, incomingValue, new Func <ModelBindingExecutionContext, string>(GetValueRequiredResource)));
}
public abstract IModelBinder GetBinder(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext);
public CustomFormsValueProvider(ModelBindingExecutionContext context)
{
_form = context.HttpContext.Request.Form;
}
public CustomValueProvider(ModelBindingExecutionContext context) : base(context)
{
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
throw new NotImplementedException();
}
public IValueProvider GetValueProvider(ModelBindingExecutionContext modelBindingExecutionContext)
{
return(new CurrentUserValueProvider(modelBindingExecutionContext.HttpContext));
}
public bool BindModel(ModelBindingExecutionContext modelBindingExecutionContext, ModelBindingContext bindingContext)
{
return(true);
}
