/// <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);
}
