/// <summary>
        /// Gets the <see cref="ModelBindingContext"/> for this <see cref="HttpActionContext"/>.
        /// </summary>
        /// <param name="actionContext">The action context.</param>
        /// <param name="bindingContext">The binding context.</param>
        /// <param name="binder">When this method returns, the value associated with the specified binding context, if the context is found; otherwise, the default value for the type of the value parameter.</param>
        /// <returns><c>true</c> if <see cref="ModelBindingContext"/> was present; otherwise <c>false</c>.</returns>
        public static bool TryGetBinder(this HttpActionContext actionContext, ModelBindingContext bindingContext, out IModelBinder binder)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            if (bindingContext == null)
            {
                throw Error.ArgumentNull("bindingContext");
            }

            binder = null;
            ModelBinderProvider providerFromAttr;
            if (ModelBindingHelper.TryGetProviderFromAttributes(bindingContext.ModelType, out providerFromAttr))
            {
                binder = providerFromAttr.GetBinder(actionContext, bindingContext);
            }
            else
            {
                binder = actionContext.ControllerContext.Configuration.Services.GetModelBinderProviders()
                    .Select(p => p.GetBinder(actionContext, bindingContext))
                    .Where(b => b != null)
                    .FirstOrDefault();
            }

            return binder != null;
        }

        public ElementBinding AddElement(Type elementType, IModelBinder binder)
        {
            var binding = new ElementBinding(_elements.Count, elementType, binder);
            _elements.Add(binding);

            return binding;
        }

        protected override object GetPropertyValue(ControllerContext controllerContext, ModelBindingContext bindingContext, System.ComponentModel.PropertyDescriptor propertyDescriptor, IModelBinder propertyBinder)
        {
            // Check for existence of type discriminator field
            string typeDiscrimKey = CreateSubPropertyName(bindingContext.ModelName, "_TYPEDISC_");
            ValueProviderResult vpDiscrim = bindingContext.ValueProvider.GetValue(typeDiscrimKey);
            if (vpDiscrim != null)
            {
                // check for attribute on property specifying the requested type name is allowed
                string typeName = (string)vpDiscrim.ConvertTo(typeof(string));
                var attr = propertyDescriptor.Attributes.OfType<AllowedSubtypesAttribute>().FirstOrDefault();
                if (attr != null && attr.AllowedSubtypeNames.Contains(typeName))
                {
                    // check if the requested type is different from the property type, but assignable to it
                    Type propType = Type.GetType(typeName);
                    if (propType != propertyDescriptor.PropertyType && propertyDescriptor.PropertyType.IsAssignableFrom(propType))
                    {
                        // substitute type of property for specified type
                        IModelBinder newPropertyBinder = Binders.GetBinder(propType);
                        var propertyMetadata =
                            ModelMetadataProviders.Current.GetMetadataForType(() => null, propType);
                        ModelBindingContext newBindingContext = new ModelBindingContext()
                        {
                            ModelMetadata = propertyMetadata,
                            ModelName = bindingContext.ModelName,
                            ModelState = bindingContext.ModelState,
                            ValueProvider = bindingContext.ValueProvider
                        };

                        return base.GetPropertyValue(controllerContext, newBindingContext, propertyDescriptor, newPropertyBinder);
                    }
                }
            }
            return base.GetPropertyValue(controllerContext, bindingContext, propertyDescriptor, propertyBinder);
        }

 public void ChoseModelBinder(Type modelType, IModelBinder binder)
 {
     _report.AddBindingDetail(new ModelBinderSelection{
         ModelType = modelType,
         BinderType = binder.GetType()
     });
 }

        /// <summary>
        /// Register that the given parameter type on an Action is to be bound using the model binder.
        /// </summary>
        /// <param name="configuration">configuration to be updated.</param>
        /// <param name="type">parameter type that binder is applied to</param>
        /// <param name="binder">a model binder</param>
        public static void BindParameter(this HttpConfiguration configuration, Type type, IModelBinder binder)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (binder == null)
            {
                throw Error.ArgumentNull("binder");
            }

            // Add a provider so that we can use this type recursively
            // Be sure to insert at position 0 to preempt any eager binders (eg, MutableObjectBinder) that 
            // may eagerly claim all types.
            configuration.Services.Insert(typeof(ModelBinderProvider), 0, new SimpleModelBinderProvider(type, binder));

            // Add the binder to the list of rules. 
            // This ensures that the parameter binding will actually use model binding instead of Formatters.            
            // Without this, the parameter binding system may see the parameter type is complex and choose
            // to use formatters instead, in which case it would ignore the registered model binders. 
            configuration.ParameterBindingRules.Insert(0, type, param => param.BindWithModelBinding(binder));
        }

		public void Add(Type modelType, IModelBinder binder)
        {
            Precondition.Require(modelType, () => Error.ArgumentNull("modelType"));
			Precondition.Require(binder, () => Error.ArgumentNull("binder"));

            _mappings.Add(modelType, binder);
        }

 /// <summary>
 /// This method changes de default behavior of a modelbinder when it has to bind a posted photo to the
 /// Photo property of customer picture. Otherwise it behaves default.
 /// </summary>
 /// <param name="controllerContext">The context within which the controller operates. The context information includes the controller, HTTP content, request context, and route data.</param>
 /// <param name="bindingContext">The context within which the model is bound. The context includes information such as the model object, model name, model type, property filter, and value provider.</param>
 /// <param name="propertyDescriptor">The descriptor for the property to access. The descriptor provides information such as the component type, property type, and property value. It also provides methods to get or set the property value.</param>
 /// <param name="propertyBinder">An object that provides a way to bind the property.</param>
 /// <returns>
 /// An object that represents the property value.
 /// </returns>
 protected override object GetPropertyValue(ControllerContext controllerContext, ModelBindingContext bindingContext, System.ComponentModel.PropertyDescriptor propertyDescriptor, IModelBinder propertyBinder)
 {
     // Check to see if we are binding the Photo Property, otherwise fallback to default behavior
     if (propertyDescriptor.Name == "Photo")
     {
         IValueProvider provider = bindingContext.ValueProvider;
         // Check if there is a value on the request for the Photo property
         var result = provider.GetValue(bindingContext.ModelName);
         // The result should be a posted file
         HttpPostedFileBase file = result.ConvertTo(typeof(HttpPostedFileBase)) as HttpPostedFileBase;
         // Check if there's actually a Photo in the request.
         if (file == (HttpPostedFileBase)null)
         {
             //There is no photo.
             return null;
         }
         // Create a byte array with the length of the posted file.
         byte [] resultValue = new byte[file.ContentLength];
         // Read the contents of the posted file to the byte array.
         file.InputStream.Read(resultValue, 0, file.ContentLength);
         // Return the byte array.
         return resultValue;
     }
     //If we are binding another property fallback to default behavior.
     return base.GetPropertyValue(controllerContext, bindingContext, propertyDescriptor, propertyBinder);
 }

        protected override object GetPropertyValue(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor, IModelBinder propertyBinder)
        {
            var propertyType = propertyDescriptor.PropertyType;

            // Check if the property type is an enum with the flag attribute
            if (propertyType.IsEnum && propertyType.GetCustomAttributes(true).Any())
            {
                var providerValue = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
                if (providerValue != null)
                {
                    var value = providerValue.RawValue;
                    if (value != null)
                    {
                        // In case it is a checkbox list/dropdownlist/radio button list
                        if (value is string[])
                        {
                            // Create flag value from posted values
                            int flagValue = 0;
                            foreach (string val in ((string[])value))
                            {
                                flagValue = flagValue | (int)Enum.Parse(propertyType, val);
                            }
                            return Enum.ToObject(propertyType, flagValue);
                        }
                        // In case it is a single value
                        if (value.GetType().IsEnum)
                        {
                            return Enum.ToObject(propertyType, value);
                        }
                    }
                }
            }
            return base.GetPropertyValue(controllerContext, bindingContext, propertyDescriptor, propertyBinder);
        }

        public async Task TryUpdateModel_ReturnsFalse_IfModelValidationFails()
        {
            // Arrange
            var binders = new IModelBinder[]
            {
                new TypeConverterModelBinder(),
                new ComplexModelDtoModelBinder(),
                new MutableObjectModelBinder()
            };

            var validator = new DataAnnotationsModelValidatorProvider();
            var model = new MyModel();
            var modelStateDictionary = new ModelStateDictionary();
            var values = new Dictionary<string, object>
            {
                { "", null }
            };
            var valueProvider = new DictionaryBasedValueProvider(values);

            // Act
            var result = await ModelBindingHelper.TryUpdateModelAsync(
                                                    model,
                                                    "",
                                                    Mock.Of<HttpContext>(),
                                                    modelStateDictionary,
                                                    new DataAnnotationsModelMetadataProvider(),
                                                    GetCompositeBinder(binders),
                                                    valueProvider,
                                                    new[] { validator });

            // Assert
            Assert.False(result);
            Assert.Equal("The MyProperty field is required.",
                         modelStateDictionary["MyProperty"].Errors[0].ErrorMessage);
        }

        /// <summary>
        /// Bind the parameter using the given model binder. 
        /// </summary>
        /// <param name="parameter">parameter to provide binding for.</param>
        /// <param name="binder">model binder to use on parameter</param>
        /// <returns>a binding</returns>
        public static HttpParameterBinding BindWithModelBinding(this HttpParameterDescriptor parameter, IModelBinder binder)
        {
            HttpConfiguration config = parameter.Configuration;
            IEnumerable<ValueProviderFactory> valueProviderFactories = new ModelBinderAttribute().GetValueProviderFactories(config);

            return BindWithModelBinding(parameter, binder, valueProviderFactories);
        }

 /// <summary>
 /// Removes the specified model binder.
 /// </summary>
 /// <param name="binder">The model binder to remove.</param>
 public void Remove(IModelBinder binder)
 {
     var pairs = binders.Where(x => x.Value == binder).ToArray();
     foreach (var pair in pairs)
     {
         binders.Remove(pair.Key);
     }
 }

 /// <summary>
 /// Provides custom logic for creating an <see cref="ISectionID"/> object from a string.
 /// </summary>
 /// <param name="controllerContext"></param>
 /// <param name="bindingContext"></param>
 /// <param name="propertyDescriptor"></param>
 /// <param name="propertyBinder"></param>
 /// <returns></returns>
 protected override object GetPropertyValue(ControllerContext controllerContext, ModelBindingContext bindingContext, System.ComponentModel.PropertyDescriptor propertyDescriptor, IModelBinder propertyBinder)
 {
     if (propertyDescriptor.PropertyType.IsSubclassOf(typeof(Section)))
       {
     return base.GetPropertyValue(controllerContext, bindingContext, propertyDescriptor, new SectionIdModelBinder());
       }
       // TODO: Account for a property that is a collection of ISection objects
       return base.GetPropertyValue(controllerContext, bindingContext, propertyDescriptor, propertyBinder);
 }

		public TypeMatchModelBinderProvider(Type type, IModelBinder binder)
			: base()
		{
			Precondition.Require(type, () => Error.ArgumentNull("type"));
			Precondition.Require(binder, () => Error.ArgumentNull("binder"));

			_type = type;
			_binder = binder;
		}

        public RegisterDefaultModelBinderStartupTask(IModelBinder modelBinder)
        {
            if (modelBinder == null)
            {
                throw new ArgumentNullException("modelBinder");
            }

            _modelBinder = modelBinder;
        }

 /// <summary>
 /// Provides custom logic for creating an <see cref="ISectionID"/> object from a string.
 /// </summary>
 /// <param name="controllerContext"></param>
 /// <param name="bindingContext"></param>
 /// <param name="propertyDescriptor"></param>
 /// <param name="propertyBinder"></param>
 /// <returns></returns>
 protected override object GetPropertyValue(ControllerContext controllerContext, ModelBindingContext bindingContext, System.ComponentModel.PropertyDescriptor propertyDescriptor, IModelBinder propertyBinder)
 {
     Type propertyType = propertyDescriptor.PropertyType;
       if (propertyType == typeof(SectionID) || propertyType.IsSubclassOf(typeof(SectionID)))
       {
     return SectionID.FromString(bindingContext.ValueProvider.GetValue(bindingContext.ModelName).AttemptedValue);
       }
       return base.GetPropertyValue(controllerContext, bindingContext, propertyDescriptor, propertyBinder);
 }

		protected GenericModelBinderProvider(Type type, IModelBinder binder) 
		{
			Precondition.Require(type, () => Error.ArgumentNull("type"));
			Precondition.Require(binder, () => Error.ArgumentNull("binder"));

            ValidateParameters(type, null);

			_type = type;
            _factory = (args) => binder;
        }

        public SimpleModelBinderProvider(Type modelType, IModelBinder modelBinder) {
            if (modelType == null) {
                throw new ArgumentNullException("modelType");
            }
            if (modelBinder == null) {
                throw new ArgumentNullException("modelBinder");
            }

            _modelType = modelType;
            _modelBinderFactory = () => modelBinder;
        }

        public void ProceedAndWarnWithRuntimePolicyOnAndIModelBinder(AlternateType<IModelBinder> alternateModelBinder, IAlternateMethodContext context, Type arg1, IModelBinder returnValue)
        {
            context.Setup(c => c.Arguments).Returns(new object[] { arg1 });
            context.Setup(c => c.ReturnValue).Returns(returnValue);

            var sut = new ModelBinderProvider.GetBinder(alternateModelBinder);
            sut.NewImplementation(context);

            context.TimerStrategy().Verify(t => t.Time(It.IsAny<Action>()));
            context.Verify(mb => mb.ReturnValue);
        }

        private async Task BindModelAsync(ModelBindingContext bindingContext, IModelBinder binder)
        {
            await binder.BindModelAsync(bindingContext);
            
/*            bindingContext.Result = await binder.BindModelAsync(bindingContext);
            var modelBindingResult = result != ModelBindingResult.NoResult
                ? result
                : ModelBindingResult.NoResult;

            return bindingContext;*/
        }

        public void UpdateModelBinders(ModelBinderInspector sut, IInspectorContext context, DummyDefaultModelBinder seedBinder, IModelBinder proxy)
        {
            ModelBinders.Binders.Add(typeof(object), seedBinder);
            context.ProxyFactory.Setup(pf => pf.IsWrapInterfaceEligible<IModelBinder>(It.IsAny<Type>())).Returns(true);
            context.ProxyFactory.Setup(pf => pf.WrapInterface(It.IsAny<IModelBinder>(), It.IsAny<IEnumerable<IAlternateMethod>>())).Returns(proxy);

            sut.Setup(context);

            Assert.Contains(proxy, ModelBinders.Binders.Values);
            Assert.DoesNotContain(seedBinder, ModelBinders.Binders.Values);
            context.Logger.Verify(l => l.Info(It.IsAny<string>(), It.IsAny<object[]>()));
        }