/// <inheritdoc /> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var modelType = context.Metadata.ModelType; if (modelType.IsGenericType && modelType.GetGenericTypeDefinition() == typeof(KeyValuePair <,>)) { var typeArguments = modelType.GenericTypeArguments; var keyMetadata = context.MetadataProvider.GetMetadataForType(typeArguments[0]); var keyBinder = context.CreateBinder(keyMetadata); var valueMetadata = context.MetadataProvider.GetMetadataForType(typeArguments[1]); var valueBinder = context.CreateBinder(valueMetadata); var binderType = typeof(KeyValuePairModelBinder <,>).MakeGenericType(typeArguments); var loggerFactory = context.Services.GetRequiredService <ILoggerFactory>(); return((IModelBinder)Activator.CreateInstance(binderType, keyBinder, valueBinder, loggerFactory)); } return(null); }
/// <inheritdoc /> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var modelTypeInfo = context.Metadata.ModelType.GetTypeInfo(); if (modelTypeInfo.IsGenericType && modelTypeInfo.GetGenericTypeDefinition().GetTypeInfo() == typeof(KeyValuePair<,>).GetTypeInfo()) { var typeArguments = modelTypeInfo.GenericTypeArguments; var keyMetadata = context.MetadataProvider.GetMetadataForType(typeArguments[0]); var keyBinder = context.CreateBinder(keyMetadata); var valueMetadata = context.MetadataProvider.GetMetadataForType(typeArguments[1]); var valueBinder = context.CreateBinder(valueMetadata); var binderType = typeof(KeyValuePairModelBinder<,>).MakeGenericType(typeArguments); return (IModelBinder)Activator.CreateInstance(binderType, keyBinder, valueBinder); } return null; }
public IModelBinder?GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var modelType = context.Metadata.ModelType; var dictionaryType = ClosedGenericMatcher.ExtractGenericInterface(modelType, typeof(IDictionary <,>)); if (dictionaryType != null) { var binderType = typeof(DictionaryModelBinder <,>).MakeGenericType(dictionaryType.GenericTypeArguments); var keyType = dictionaryType.GenericTypeArguments[0]; var keyBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(keyType)); var valueType = dictionaryType.GenericTypeArguments[1]; var valueBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(valueType)); var loggerFactory = context.Services.GetRequiredService <ILoggerFactory>(); var mvcOptions = context.Services.GetRequiredService <IOptions <MvcOptions> >().Value; return((IModelBinder)Activator.CreateInstance( binderType, keyBinder, valueBinder, loggerFactory, true /* allowValidatingTopLevelNodes */, mvcOptions) !); } return(null); }
/// <inheritdoc /> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var modelType = context.Metadata.ModelType; // Arrays are handled by another binder. if (modelType.IsArray) { return(null); } var loggerFactory = context.Services.GetRequiredService <ILoggerFactory>(); var mvcOptions = context.Services.GetRequiredService <IOptions <MvcOptions> >().Value; // If the model type is ICollection<> then we can call its Add method, so we can always support it. var collectionType = ClosedGenericMatcher.ExtractGenericInterface(modelType, typeof(ICollection <>)); if (collectionType != null) { var elementType = collectionType.GenericTypeArguments[0]; var elementBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(elementType)); var binderType = typeof(CollectionModelBinder <>).MakeGenericType(collectionType.GenericTypeArguments); return((IModelBinder)Activator.CreateInstance( binderType, elementBinder, loggerFactory, mvcOptions.AllowValidatingTopLevelNodes)); } // If the model type is IEnumerable<> then we need to know if we can assign a List<> to it, since // that's what we would create. (The cases handled here are IEnumerable<>, IReadOnlyCollection<> and // IReadOnlyList<>). var enumerableType = ClosedGenericMatcher.ExtractGenericInterface(modelType, typeof(IEnumerable <>)); if (enumerableType != null) { var listType = typeof(List <>).MakeGenericType(enumerableType.GenericTypeArguments); if (modelType.GetTypeInfo().IsAssignableFrom(listType.GetTypeInfo())) { var elementType = enumerableType.GenericTypeArguments[0]; var elementBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(elementType)); var binderType = typeof(CollectionModelBinder <>).MakeGenericType(enumerableType.GenericTypeArguments); return((IModelBinder)Activator.CreateInstance( binderType, elementBinder, loggerFactory, mvcOptions.AllowValidatingTopLevelNodes)); } } return(null); }
/// <inheritdoc /> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context.Metadata.ModelType.IsGenericType && context.Metadata.ModelType.GetGenericTypeDefinition() == typeof(PolymorphicModels <,>)) { var model_types = context.Metadata.ModelType.GenericTypeArguments; var polymorphic_submodel_binders = new List <(Type, ModelMetadata, IModelBinder)>(); foreach (var model_type in model_types) { var model_metadata = context.MetadataProvider.GetMetadataForType(model_type); var model_binder = context.CreateBinder(model_metadata); polymorphic_submodel_binders.Add((model_type, model_metadata, model_binder)); } // go through PolymorphicModels<T1,T2> properties Dictionary <ModelMetadata, IModelBinder> polymorphic_models_binders = new Dictionary <ModelMetadata, IModelBinder>(); for (int i = 0; i < context.Metadata.Properties.Count; i++) { var property = context.Metadata.Properties[i]; IModelBinder model_binder; if (property.ModelType == typeof(List <PolymorphicModelWrapper>)) { var polymorphic_model_wrapper_property_binders = new Dictionary <ModelMetadata, IModelBinder>(); var polymorphic_model_wrapper_metadata = context.MetadataProvider.GetMetadataForType(typeof(PolymorphicModelWrapper)); for (int j = 0; j < polymorphic_model_wrapper_metadata.Properties.Count; j++) { var wrapper_property = polymorphic_model_wrapper_metadata.Properties[j]; IModelBinder wrapper_property_binder; if (wrapper_property.ModelType == typeof(IPolymorphicModel)) { wrapper_property_binder = new IPolymorphicModelBinder(polymorphic_submodel_binders); } else { wrapper_property_binder = context.CreateBinder(wrapper_property); } polymorphic_model_wrapper_property_binders.Add(wrapper_property, wrapper_property_binder); } var polymorphic_model_wrapper_binder = new ComplexTypeModelBinder(polymorphic_model_wrapper_property_binders, context.Services.GetService(typeof(ILoggerFactory)) as ILoggerFactory); model_binder = new CollectionModelBinder <PolymorphicModelWrapper>(polymorphic_model_wrapper_binder, context.Services.GetService(typeof(ILoggerFactory)) as ILoggerFactory); } else { model_binder = context.CreateBinder(property); } polymorphic_models_binders.Add(property, model_binder); } return(new ComplexTypeModelBinder(polymorphic_models_binders, context.Services.GetService(typeof(ILoggerFactory)) as ILoggerFactory)); } return(null); }
/// <inheritdoc /> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var modelType = context.Metadata.ModelType; // Arrays are handled by another binder. if (modelType.IsArray) { return(null); } // If the model type is ICollection<> then we can call its Add method, so we can always support it. var collectionType = ClosedGenericMatcher.ExtractGenericInterface(modelType, typeof(ICollection <>)); if (collectionType != null) { var elementType = collectionType.GenericTypeArguments[0]; var elementBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(elementType)); var binderType = typeof(CollectionModelBinder <>).MakeGenericType(collectionType.GenericTypeArguments); return((IModelBinder)Activator.CreateInstance(binderType, elementBinder)); } // If the model type is IEnumerable<> then we need to know if we can assign a List<> to it, since // that's what we would create. (The cases handled here are IEnumerable<>, IReadOnlyColection<> and // IReadOnlyList<>). // // We need to check IsReadOnly because we need to know if we can SET the property. var enumerableType = ClosedGenericMatcher.ExtractGenericInterface(modelType, typeof(IEnumerable <>)); if (enumerableType != null && !context.Metadata.IsReadOnly) { var listType = typeof(List <>).MakeGenericType(enumerableType.GenericTypeArguments); if (modelType.GetTypeInfo().IsAssignableFrom(listType.GetTypeInfo())) { var elementType = enumerableType.GenericTypeArguments[0]; var elementBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(elementType)); var binderType = typeof(CollectionModelBinder <>).MakeGenericType(enumerableType.GenericTypeArguments); return((IModelBinder)Activator.CreateInstance(binderType, elementBinder)); } } return(null); }
/// <summary> /// Gets the correct binder for the context. /// </summary> /// <param name="context">The current context.</param> /// <returns>The model binder</returns> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context != null) { // We only care about regions, blocks and fields if (context.Metadata.ModelType == typeof(PageEditRegionBase) || context.Metadata.ModelType == typeof(Extend.IField) || context.Metadata.ModelType == typeof(Extend.Block)) { var binders = new Dictionary <string, AbstractBinderType>(); var metadata = context.MetadataProvider.GetMetadataForType(typeof(PageEditRegion)); binders.Add(typeof(PageEditRegion).FullName, new AbstractBinderType() { Type = typeof(PageEditRegion), Binder = context.CreateBinder(metadata) }); metadata = context.MetadataProvider.GetMetadataForType(typeof(PageEditRegionCollection)); binders.Add(typeof(PageEditRegionCollection).FullName, new AbstractBinderType() { Type = typeof(PageEditRegionCollection), Binder = context.CreateBinder(metadata) }); foreach (var fieldType in App.Fields) { metadata = context.MetadataProvider.GetMetadataForType(fieldType.Type); binders.Add(fieldType.TypeName, new AbstractBinderType() { Type = fieldType.Type, Binder = context.CreateBinder(metadata) }); } foreach (var blockType in App.Blocks) { metadata = context.MetadataProvider.GetMetadataForType(blockType.Type); binders.Add(blockType.TypeName, new AbstractBinderType() { Type = blockType.Type, Binder = context.CreateBinder(metadata) }); } return(new AbstractModelBinder(context.MetadataProvider, binders)); } return(null); } throw new ArgumentNullException(nameof(context)); }
public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var isAssignableMT4Model = context.Metadata.ModelType.IsAssignableToGenericType(typeof(MT4Model <>)); if (context.Metadata.IsComplexType && !context.Metadata.IsCollectionType && isAssignableMT4Model) { var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); for (var i = 0; i < context.Metadata.Properties.Count; i++) { var property = context.Metadata.Properties[i]; propertyBinders.Add(property, context.CreateBinder(property)); } var loggerFactory = context.Services.GetRequiredService <ILoggerFactory>(); var mvcOptions = context.Services.GetRequiredService <IOptions <MvcOptions> >().Value; return(GetBinder( context, propertyBinders, loggerFactory, /*mvcOptions.AllowValidatingTopLevelNodes*/ true)); } return(null); }
/// <inheritdoc/> public async Task BindModelAsync(ModelBindingContext bindingContext) { if (bindingContext == null) { throw new ArgumentNullException(nameof(bindingContext)); } var model = (ActionExecutionModel)bindingContext.Model; var metadataProvider = bindingContext.HttpContext.RequestServices.GetService <IModelMetadataProvider>(); var metadataDetailsProvider = bindingContext.HttpContext.RequestServices.GetService <ICompositeMetadataDetailsProvider>(); var loggerFactory = bindingContext.HttpContext.RequestServices.GetService <ILoggerFactory>(); bindingContext.ModelMetadata = ActionExecutionModelMetadataFactory.GetMetadata( metadataProvider, metadataDetailsProvider, model); var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(bindingContext.ModelMetadata.Properties.Count); foreach (var propertyMetadata in bindingContext.ModelMetadata.Properties) { propertyBinders[propertyMetadata] = providerContext.CreateBinder(propertyMetadata); } #pragma warning disable CS0618 // Type or member is obsolete var modelBinder = new ComplexTypeModelBinder(propertyBinders, loggerFactory); #pragma warning restore CS0618 // Type or member is obsolete await modelBinder.BindModelAsync(bindingContext); }
/// <inheritdoc /> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.Metadata.IsComplexType && !context.Metadata.IsCollectionType) { var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); for (var i = 0; i < context.Metadata.Properties.Count; i++) { var property = context.Metadata.Properties[i]; propertyBinders.Add(property, context.CreateBinder(property)); } var loggerFactory = context.Services.GetRequiredService <ILoggerFactory>(); return(new ComplexTypeModelBinder( propertyBinders, loggerFactory, allowValidatingTopLevelNodes: true)); } return(null); }
/// <summary> /// Looks for an implementation of the Microsoft.AspNetCore.Mvc.ModelBinding.IModelBinder within the framework. /// </summary> /// <param name="context">The Microsoft.AspNetCore.Mvc.ModelBinding.ModelBinderProviderContext.</param> /// <returns>An Microsoft.AspNetCore.Mvc.ModelBinding.IModelBinder.</returns> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.Metadata.UnderlyingOrModelType == FWKnownTypes.Decimal) { return(new FWDecimalModelBinder()); } if (context.Metadata.UnderlyingOrModelType == _formFile || context.Metadata.UnderlyingOrModelType.IsGenericType && context.Metadata.UnderlyingOrModelType.GetGenericArguments().First().UnderlyingSystemType == _formFile) { return(new FWFormFileBinder()); } if (context.Metadata.ModelType.IsConstructedGenericType && context.Metadata.ModelType.GetGenericTypeDefinition() == _fwList) { var genericType = _detailListBinder.MakeGenericType(context.Metadata.ModelType.GenericTypeArguments); return(Activator.CreateInstance(genericType, context.CreateBinder(context.Metadata.ElementMetadata)) as IModelBinder); } return(null); }
public IModelBinder GetBinder(ModelBinderProviderContext context) { if (typeof(UiFlowScreenModel).IsAssignableFrom(context.Metadata.ModelType)) { using (context.Services.Resolve <IProfiler>().RecordStep($"{GetType().Name}.{nameof(GetBinder)}")) { return(new UiFlowStepDataModelBinder(context.Services.Resolve <ILoggerFactory>(), t => { return _propertyBinders.GetOrAdd(t, type => { Logger.Debug(() => $"Started adding model binder for {type}"); var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); var metadata = context.MetadataProvider.GetMetadataForType(type); foreach (var property in metadata.Properties) { Logger.Debug(() => $"Started adding property binder for {type}.{property.Name}"); propertyBinders.Add(property, context.CreateBinder(property)); Logger.Debug(() => $"Added property binder for {type}.{property.Name}"); } Logger.Debug(() => $"Added model binder for {type}"); return propertyBinders; }); })); } } return(null); }
public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.Metadata.IsCollectionType || (!context.Metadata.ModelType.GetTypeInfo().IsInterface&& !context.Metadata.ModelType.GetTypeInfo().IsAbstract) || (context.BindingInfo.BindingSource != null && context.BindingInfo.BindingSource .CanAcceptDataFrom(BindingSource.Services))) { return(null); } var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); var len = context.Metadata.Properties.Count; for (var i = 0; i < len; i++) { var property = context.Metadata.Properties[i]; propertyBinders.Add(property, context.CreateBinder(property)); } return(new InterfacesModelBinder(propertyBinders)); }
/// <inheritdoc /> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var modelType = context.Metadata.ModelType; // Arrays are handled by another binder. if (modelType.IsArray) { return null; } // If the model type is ICollection<> then we can call its Add method, so we can always support it. var collectionType = ClosedGenericMatcher.ExtractGenericInterface(modelType, typeof(ICollection<>)); if (collectionType != null) { var elementType = collectionType.GenericTypeArguments[0]; var elementBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(elementType)); var binderType = typeof(AltinnCoreCollectionModelBinder<>).MakeGenericType(collectionType.GenericTypeArguments); return (IModelBinder)Activator.CreateInstance(binderType, elementBinder); } return null; }
/// <summary>获取绑定器</summary> /// <param name="context"></param> /// <returns></returns> public IModelBinder GetBinder(ModelBinderProviderContext context) { var modelType = context.Metadata.ModelType; var isGenericType = false; if (modelType.BaseType?.FullName != null && modelType.BaseType.FullName.StartsWith("NewLife.Configuration.Config`1[")) { var genericType = typeof(Config <>).MakeGenericType(modelType); isGenericType = genericType.FullName != null && modelType.As(genericType); } if (modelType.As <ICubeModel>() || isGenericType) { var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); foreach (var property in context.Metadata.Properties) { propertyBinders.Add(property, context.CreateBinder(property)); } var loggerFactory = context.Services.GetRequiredService <ILoggerFactory>(); return(new JsonModelBinder(propertyBinders, loggerFactory)); } return(null); }
public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.Metadata.ModelType != typeof(Dictionary <string, object>)) { return(null); } if (!context.Metadata.ContainerType.IsAssignableTo <IHasExtraProperties>()) { return(null); } var binderType = typeof(DictionaryModelBinder <string, object>); var keyBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(typeof(string))); var valueBinder = new AbpExtraPropertyModelBinder(context.Metadata.ContainerType); var loggerFactory = context.Services.GetRequiredService <ILoggerFactory>(); var mvcOptions = context.Services.GetRequiredService <IOptions <MvcOptions> >().Value; return((IModelBinder)Activator.CreateInstance( binderType, keyBinder, valueBinder, loggerFactory, true /* allowValidatingTopLevelNodes */, mvcOptions)); }
/// <inheritdoc /> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.Metadata.ModelType.IsArray) { var elementType = context.Metadata.ElementMetadata.ModelType; var binderType = typeof(ArrayModelBinder <>).MakeGenericType(elementType); var elementBinder = context.CreateBinder(context.Metadata.ElementMetadata); var loggerFactory = context.Services.GetRequiredService <ILoggerFactory>(); var mvcOptions = context.Services.GetRequiredService <IOptions <MvcOptions> >().Value; return((IModelBinder)Activator.CreateInstance( binderType, elementBinder, loggerFactory, true /* allowValidatingTopLevelNodes */, mvcOptions)); } return(null); }
public IModelBinder GetBinder(ModelBinderProviderContext context) { var extender = LyniconSystem.Instance.Extender; if ((context.BindingInfo.BindingSource == null || context.BindingInfo.BindingSource == BindingSource.Body) && context.Metadata.IsComplexType && !context.Metadata.IsCollectionType && ContentTypeHierarchy.AllContentTypes .Any(ct => context.Metadata.ModelType.IsAssignableFrom(ct) || context.Metadata.ModelType.IsAssignableFrom(extender[ct])) ) { var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); foreach (var property in context.Metadata.Properties) { propertyBinders.Add(property, context.CreateBinder(property)); } return(new RouteModelBinder(propertyBinders)); } if (context.Metadata.IsCollectionType && (context.BindingInfo.BindingSource == null || context.BindingInfo.BindingSource == BindingSource.Body) && ContentTypeHierarchy.AllContentTypes .Any(ct => context.Metadata.ElementType.IsAssignableFrom(ct))) { return(new RouteModelBinder(null)); } return(null); }
public IModelBinder?GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var metadata = context.Metadata; if (metadata.IsComplexType && !metadata.IsCollectionType) { var loggerFactory = context.Services.GetRequiredService <ILoggerFactory>(); var logger = loggerFactory.CreateLogger <ComplexObjectModelBinder>(); var parameterBinders = GetParameterBinders(context); var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); for (var i = 0; i < context.Metadata.Properties.Count; i++) { var property = context.Metadata.Properties[i]; propertyBinders.Add(property, context.CreateBinder(property)); } return(new ComplexObjectModelBinder(propertyBinders, parameterBinders, logger)); } return(null); }
public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.Metadata.IsComplexType && context.Metadata.BinderType == typeof(QueryObjectModelBinder)) { var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); foreach (var p in context.Metadata.Properties) { if (p.BinderType == DateTimeModelBinderType) { propertyBinders.Add(p, context.Services.GetRequiredService <DefaultDateTimeModelBinder>()); } else { propertyBinders.Add(p, context.CreateBinder(p)); } } var loggerFactory = context.Services.GetRequiredService <ILoggerFactory>(); return(new QueryObjectModelBinder(propertyBinders, loggerFactory)); } return(null); }
public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.Metadata.ModelType == typeof(AbstractSearch)) { var assembly = typeof(AbstractSearch).Assembly; var abstractSearchClasses = assembly.GetExportedTypes() .Where(t => t.BaseType.Equals(typeof(AbstractSearch))) .Where(t => !t.IsAbstract) .ToList(); var modelBuilderByType = new Dictionary <Type, ComplexTypeModelBinder>(); foreach (var type in abstractSearchClasses) { var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); var metadata = context.MetadataProvider.GetMetadataForType(type); foreach (var property in metadata.Properties) { propertyBinders.Add(property, context.CreateBinder(property)); } modelBuilderByType.Add(type, new ComplexTypeModelBinder(propertyBinders)); } return(new AbstractSearchModelBinder(modelBuilderByType, context.MetadataProvider)); } return(null); }
/// <inheritdoc /> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var modelType = context.Metadata.ModelType; // Arrays are handled by another binder. if (modelType.IsArray) { return null; } // If the model type is ICollection<> then we can call its Add method, so we can always support it. var collectionType = ClosedGenericMatcher.ExtractGenericInterface(modelType, typeof(ICollection<>)); if (collectionType != null) { var elementType = collectionType.GenericTypeArguments[0]; var elementBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(elementType)); var binderType = typeof(CollectionModelBinder<>).MakeGenericType(collectionType.GenericTypeArguments); return (IModelBinder)Activator.CreateInstance(binderType, elementBinder); } // If the model type is IEnumerable<> then we need to know if we can assign a List<> to it, since // that's what we would create. (The cases handled here are IEnumerable<>, IReadOnlyColection<> and // IReadOnlyList<>). // // We need to check IsReadOnly because we need to know if we can SET the property. var enumerableType = ClosedGenericMatcher.ExtractGenericInterface(modelType, typeof(IEnumerable<>)); if (enumerableType != null && !context.Metadata.IsReadOnly) { var listType = typeof(List<>).MakeGenericType(enumerableType.GenericTypeArguments); if (modelType.GetTypeInfo().IsAssignableFrom(listType.GetTypeInfo())) { var elementType = enumerableType.GenericTypeArguments[0]; var elementBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(elementType)); var binderType = typeof(CollectionModelBinder<>).MakeGenericType(enumerableType.GenericTypeArguments); return (IModelBinder)Activator.CreateInstance(binderType, elementBinder); } } return null; }
private async Task BindModelCoreAsync(ModelBindingContext bindingContext) { ModelPropertyCollection propertiesRuntime = new ModelPropertyCollection(new List <ModelMetadata>()); //Type Definition if (Int32.TryParse(bindingContext.FieldName, out int index)) { var stackField = typeof(DefaultModelBindingContext).GetField("_stack", BindingFlags.Instance | BindingFlags.NonPublic); dynamic stack = stackField.GetValue(bindingContext); dynamic collectionModel = null; foreach (var stackItem in stack) { var prop = stackItem.GetType().GetField("_Model", BindingFlags.Instance | BindingFlags.NonPublic); FieldInfo[] fields = stackItem.GetType().DeclaredFields; var field = fields.Where(f => f.Name == "Model").First(); collectionModel = field.GetValue(stackItem); } if (index < collectionModel.Length) { var model = collectionModel[index]; bindingContext.Model = model; propertiesRuntime = ((DynamicFormsModelMetadata)bindingContext.ModelMetadata).Contextualize(model); } } else { propertiesRuntime = ((DynamicFormsModelMetadata)_modelBinderProviderContext.Metadata).Contextualize(bindingContext.Model); } //New Instance if required if (bindingContext.Model == null) { bindingContext.Model = await CreateModelAsync(bindingContext); propertiesRuntime = ((DynamicFormsModelMetadata)bindingContext.ModelMetadata).Contextualize(bindingContext.Model); } var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); //https://github.com/aspnet/AspNetCore/blob/c565386a3ed135560bc2e9017aa54a950b4e35dd/src/Mvc/Mvc.Core/src/ModelBinding/Binders/ComplexTypeModelBinderProvider.cs for (var i = 0; i < propertiesRuntime.Count; i++) { var property = propertiesRuntime[i]; ((DynamicFormsModelMetadata)property).NormalHashing = true; propertyBinders.Add(property, _modelBinderProviderContext.CreateBinder(property)); ((DynamicFormsModelMetadata)property).NormalHashing = false; } ((DynamicFormsModelMetadata)_modelBinderProviderContext.Metadata).NormalHashing = false; var complexModelBinder = new CustomComplexTypeModelBinder(propertyBinders); await complexModelBinder.BindModelAsync(bindingContext); }
public IModelBinder GetBinder(ModelBinderProviderContext context) { var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); foreach (var property in context.Metadata.Properties) { propertyBinders.Add(property, context.CreateBinder(property)); } return(new CustomComplexTypeModelBinder(propertyBinders)); }
/// <summary> /// Generate a new instance with the found data /// </summary> /// <param name="type">The type to relate to the current instance.</param> /// <param name="context">The context with the metadata of the instance.</param> public CrudModelBinderMetadata(Type type, ModelBinderProviderContext context) { Type = type ?? throw new ArgumentNullException(nameof(type)); if (context is null) { throw new ArgumentNullException(nameof(context)); } Metadata = context.MetadataProvider.GetMetadataForType(type); Binder = context.CreateBinder(Metadata); }
private Dictionary <ModelMetadata, IModelBinder> GetPropertyBinders(ModelMetadata metadata) { var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); for (var i = 0; i < metadata.Properties.Count; i++) { var property = metadata.Properties[i]; propertyBinders.Add(property, _modelBinderProviderContext.CreateBinder(property)); } return(propertyBinders); }
public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.Metadata.ModelType == typeof(IEnumerable <FilterType>)) { var elementBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(typeof(FilterType))); return(new EmptyCollectionModelBinder(elementBinder)); } return(null); }
public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.Metadata.ModelType == typeof(Controllers.DayOfWeek?)) { return(new DayOfWeekBinder()); } if (context.Metadata.IsComplexType && !context.Metadata.IsCollectionType && typeof(MyParams).IsAssignableFrom(context.Metadata.ModelType)) { var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); for (var i = 0; i < context.Metadata.Properties.Count; i++) { var property = context.Metadata.Properties[i]; propertyBinders.Add(property, context.CreateBinder(property)); } return(new ParentBinder(propertyBinders)); } if (context.Metadata.IsComplexType && !context.Metadata.IsCollectionType && typeof(Parent).IsAssignableFrom(context.Metadata.ModelType)) { var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); for (var i = 0; i < context.Metadata.Properties.Count; i++) { var property = context.Metadata.Properties[i]; propertyBinders.Add(property, context.CreateBinder(property)); } return(new ParentBinder(propertyBinders)); } return(null); }
public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context.Metadata.IsComplexType && !context.Metadata.IsCollectionType) { var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); for (int i = 0; i < context.Metadata.Properties.Count; i++) { var property = context.Metadata.Properties[i]; propertyBinders.Add(property, context.CreateBinder(property)); } return(new TrimModelBinder(propertyBinders)); } return(null); }
/// <inheritdoc /> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var modelType = context.Metadata.ModelType; var dictionaryType = ClosedGenericMatcher.ExtractGenericInterface(modelType, typeof(IDictionary<,>)); if (dictionaryType != null) { var keyType = dictionaryType.GenericTypeArguments[0]; var keyBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(keyType)); var valueType = dictionaryType.GenericTypeArguments[1]; var valueBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(valueType)); var binderType = typeof(DictionaryModelBinder<,>).MakeGenericType(dictionaryType.GenericTypeArguments); return (IModelBinder)Activator.CreateInstance(binderType, keyBinder, valueBinder); } return null; }
/// <inheritdoc /> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var modelType = context.Metadata.ModelType; var dictionaryType = ClosedGenericMatcher.ExtractGenericInterface(modelType, typeof(IDictionary <,>)); if (dictionaryType != null) { var keyType = dictionaryType.GenericTypeArguments[0]; var keyBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(keyType)); var valueType = dictionaryType.GenericTypeArguments[1]; var valueBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(valueType)); var binderType = typeof(DictionaryModelBinder <,>).MakeGenericType(dictionaryType.GenericTypeArguments); return((IModelBinder)Activator.CreateInstance(binderType, keyBinder, valueBinder)); } return(null); }
public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context.Metadata.ModelType == typeof(T)) { var propertyBinders = new Dictionary <ModelMetadata, IModelBinder>(); for (var i = 0; i < context.Metadata.Properties.Count; i++) { var property = context.Metadata.Properties[i]; propertyBinders.Add(property, context.CreateBinder(property)); } return(new AliasModelBinder(propertyBinders, (ILoggerFactory)context.Services.GetService(typeof(ILoggerFactory)))); } return(null); }
private IModelBinder CreateBinder(ModelBinderProviderContext context, Type keyType, Type elementType) { var binderType = typeof(EntityCollectionModelBinder <,>).MakeGenericType(keyType, elementType); var elementBinder = context.CreateBinder(context.MetadataProvider.GetMetadataForType(elementType)); var loggerFactory = context.Services.GetRequiredService <ILoggerFactory>(); var mvcOptions = context.Services.GetRequiredService <IOptions <MvcOptions> >().Value; var modelMetadataProvider = context.Services.GetRequiredService <IModelMetadataProvider>(); var keyMetadata = modelMetadataProvider.GetMetadataForType(keyType); var keyBinder = context.CreateBinder(keyMetadata); return((IModelBinder)Activator.CreateInstance( binderType, keyBinder, keyMetadata, elementBinder, loggerFactory, true /* allowValidatingTopLevelNodes */, mvcOptions )); }
/// <inheritdoc /> public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.Metadata.IsComplexType && !context.Metadata.IsCollectionType) { var propertyBinders = new Dictionary<ModelMetadata, IModelBinder>(); foreach (var property in context.Metadata.Properties) { propertyBinders.Add(property, context.CreateBinder(property)); } return new ComplexTypeModelBinder(propertyBinders); } return null; }
public IModelBinder GetBinder(ModelBinderProviderContext context) { if (context.Metadata.IsComplexType) { var propertyBinders = new Dictionary<ModelMetadata, IModelBinder>(); foreach (var property in context.Metadata.Properties) { propertyBinders.Add(property, context.CreateBinder(property)); } return new TestableComplexTypeModelBinder(propertyBinders); } return null; }
/// <summary> /// Returns the model binder for a question. /// </summary> public IModelBinder GetBinder(ModelBinderProviderContext context) { var modelType = context.Metadata.ModelType; if (!_baseTypes.Contains(modelType)) return null; var derivedModelBinders = _subTypes[modelType].ToDictionary ( t => t, t => context.CreateBinder ( context.MetadataProvider.GetMetadataForType(t) ) ); return new AbstractModelBinder(modelType, derivedModelBinders, context.MetadataProvider); }