あなたをオープンソースに連れて行きます-ASP.NET_MVC(十三)

       protected virtual objectGetParameterValue(ControllerContext controllerContext, ParameterDescriptorparameterDescriptor)
        {
            // collect all of the necessarybinding properties
            Type parameterType =parameterDescriptor.ParameterType;
            IModelBinder binder =GetModelBinder(parameterDescriptor);
            IValueProvider valueProvider =controllerContext.Controller.ValueProvider;
            string parameterName =parameterDescriptor.BindingInfo.Prefix ?? parameterDescriptor.ParameterName;
            Predicate<string>propertyFilter = GetPropertyFilter(parameterDescriptor);
 
            // finally, call into the binder
            ModelBindingContext bindingContext= new ModelBindingContext()
            {
                FallbackToEmptyPrefix =(parameterDescriptor.BindingInfo.Prefix == null), // only fall back if prefixnot specified
                ModelMetadata =ModelMetadataProviders.Current.GetMetadataForType(null, parameterType),
                ModelName = parameterName,
                ModelState =controllerContext.Controller.ViewData.ModelState,
                PropertyFilter =propertyFilter,
                ValueProvider = valueProvider
            };
 
            object result =binder.BindModel(controllerContext, bindingContext);
            return result ??parameterDescriptor.DefaultValue;
        }

        private IModelBinderGetModelBinder(ParameterDescriptor parameterDescriptor)
        {
            // look on the parameter itself,then look in the global table
            returnparameterDescriptor.BindingInfo.Binder ?? Binders.GetBinder(parameterDescriptor.ParameterType);
        }

        private IModelBinder GetBinder(TypemodelType, IModelBinder fallbackBinder)
        {
            // Try to look up a binder for thistype. We use this order of precedence:
            // 1. Binder returned from provider
            // 2. Binder registered in theglobal table
            // 3. Binder attribute defined onthe type
            // 4. Supplied fallback binder
 
            IModelBinder binder =_modelBinderProviders.GetBinder(modelType);
            if (binder != null)
            {
                return binder;
            }
 
            if(_innerDictionary.TryGetValue(modelType, out binder))
            {
                return binder;
            }
 
            // Function is called frequently,so ensure the error delegate is stateless
            binder =ModelBinders.GetBinderFromAttributes(modelType, (Type errorModel) =>
                {
                    throw new InvalidOperationException(
                       String.Format(CultureInfo.CurrentCulture,MvcResources.ModelBinderDictionary_MultipleAttributes, errorModel.FullName));
                });
 
            return binder ?? fallbackBinder;
        }

        public ModelBinderDictionary()
            :this(ModelBinderProviders.BinderProviders)
        {
        }
 
        internal ModelBinderDictionary(ModelBinderProviderCollectionmodelBinderProviders)
        {
            _modelBinderProviders =modelBinderProviders;
        }

protected voidApplication_Start()
{
AreaRegistration.RegisterAllAreas();
 
ModelBinderProviders.BinderProviders.Add(newCustomModelBinderProvider());//*
 
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
}

       internal static IModelBinder GetBinderFromAttributes(Type type,Action<Type> errorAction)
       {
           AttributeList allAttrs = newAttributeList(TypeDescriptorHelper.Get(type).GetAttributes());
           CustomModelBinderAttributebinder = allAttrs.SingleOfTypeDefaultOrError<Attribute,CustomModelBinderAttribute, Type>(errorAction, type);
           return binder == null ? null : binder.GetBinder();
       }

       /// <summary>
       /// Returns a single value in list matching type TMatch if there is onlyone, null if there are none of type TMatch or calls the
       /// errorAction with errorArg1 if there is more than one.
       /// </summary>
       public static TMatch SingleOfTypeDefaultOrError<TInput, TMatch,TArg1>(this IList<TInput> list, Action<TArg1> errorAction, TArg1errorArg1) where TMatch : class
       {
           Contract.Assert(list != null);
           Contract.Assert(errorAction != null);
 
           TMatch result = null;
           for (int i = 0; i < list.Count; i++)
           {
                TMatch typedValue = list[i] asTMatch;
                if (typedValue != null)
                {
                    if (result == null)
                    {
                        result = typedValue;
                    }
                    else
                    {
                        errorAction(errorArg1);
                        return null;
                    }
                }
           }
           return result;
       }