mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
122 lines
5.9 KiB
C#
122 lines
5.9 KiB
C#
namespace System.Web.ModelBinding {
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Globalization;
|
|
|
|
internal static class CollectionModelBinderUtil {
|
|
|
|
public static void CreateOrReplaceCollection<TElement>(ModelBindingContext bindingContext, IEnumerable<TElement> incomingElements, Func<ICollection<TElement>> creator) {
|
|
ICollection<TElement> collection = bindingContext.Model as ICollection<TElement>;
|
|
if (collection == null || collection.IsReadOnly) {
|
|
collection = creator();
|
|
bindingContext.Model = collection;
|
|
}
|
|
|
|
collection.Clear();
|
|
foreach (TElement element in incomingElements) {
|
|
collection.Add(element);
|
|
}
|
|
}
|
|
|
|
public static void CreateOrReplaceDictionary<TKey, TValue>(ModelBindingContext bindingContext, IEnumerable<KeyValuePair<TKey, TValue>> incomingElements, Func<IDictionary<TKey, TValue>> creator) {
|
|
IDictionary<TKey, TValue> dictionary = bindingContext.Model as IDictionary<TKey, TValue>;
|
|
if (dictionary == null || dictionary.IsReadOnly) {
|
|
dictionary = creator();
|
|
bindingContext.Model = dictionary;
|
|
}
|
|
|
|
dictionary.Clear();
|
|
foreach (var element in incomingElements) {
|
|
if (element.Key != null) {
|
|
dictionary[element.Key] = element.Value;
|
|
}
|
|
}
|
|
}
|
|
|
|
// supportedInterfaceType: type that is updatable by this binder
|
|
// newInstanceType: type that will be created by the binder if necessary
|
|
// openBinderType: model binder type
|
|
// modelMetadata: metadata for the model to bind
|
|
//
|
|
// example: GetGenericBinder(typeof(IList<>), typeof(List<>), typeof(ListBinder<>), ...) means that the ListBinder<T>
|
|
// type can update models that implement IList<T>, and if for some reason the existing model instance is not
|
|
// updatable the binder will create a List<T> object and bind to that instead. This method will return a ListBinder<T>
|
|
// or null, depending on whether the type and updatability checks succeed.
|
|
public static IModelBinder GetGenericBinder(Type supportedInterfaceType, Type newInstanceType, Type openBinderType, ModelMetadata modelMetadata) {
|
|
Type[] typeArguments = GetTypeArgumentsForUpdatableGenericCollection(supportedInterfaceType, newInstanceType, modelMetadata);
|
|
return (typeArguments != null) ? (IModelBinder)Activator.CreateInstance(openBinderType.MakeGenericType(typeArguments)) : null;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Globalization", "CA1304:SpecifyCultureInfo", MessageId = "System.Web.ModelBinding.ValueProviderResult.ConvertTo(System.Type)", Justification = @"The default CultureInfo used by ValueProvider is fine.")]
|
|
public static IEnumerable<string> GetIndexNamesFromValueProviderResult(ValueProviderResult vpResultIndex) {
|
|
IEnumerable<string> indexNames = null;
|
|
if (vpResultIndex != null) {
|
|
string[] indexes = (string[])(vpResultIndex.ConvertTo(typeof(string[])));
|
|
if (indexes != null && indexes.Length > 0) {
|
|
indexNames = indexes;
|
|
}
|
|
}
|
|
return indexNames;
|
|
}
|
|
|
|
public static IEnumerable<string> GetZeroBasedIndexes() {
|
|
for (int i = 0; ; i++) {
|
|
yield return i.ToString(CultureInfo.InvariantCulture);
|
|
}
|
|
}
|
|
|
|
// Returns the generic type arguments for the model type if updatable, else null.
|
|
// supportedInterfaceType: open type (like IList<>) of supported interface, must implement ICollection<>
|
|
// newInstanceType: open type (like List<>) of object that will be created, must implement supportedInterfaceType
|
|
public static Type[] GetTypeArgumentsForUpdatableGenericCollection(Type supportedInterfaceType, Type newInstanceType, ModelMetadata modelMetadata) {
|
|
/*
|
|
* Check that we can extract proper type arguments from the model.
|
|
*/
|
|
|
|
if (!modelMetadata.ModelType.IsGenericType || modelMetadata.ModelType.IsGenericTypeDefinition) {
|
|
// not a closed generic type
|
|
return null;
|
|
}
|
|
|
|
Type[] modelTypeArguments = modelMetadata.ModelType.GetGenericArguments();
|
|
if (modelTypeArguments.Length != supportedInterfaceType.GetGenericArguments().Length) {
|
|
// wrong number of generic type arguments
|
|
return null;
|
|
}
|
|
|
|
/*
|
|
* Is it possible just to change the reference rather than update the collection in-place?
|
|
*/
|
|
|
|
if (!modelMetadata.IsReadOnly) {
|
|
Type closedNewInstanceType = newInstanceType.MakeGenericType(modelTypeArguments);
|
|
if (modelMetadata.ModelType.IsAssignableFrom(closedNewInstanceType)) {
|
|
return modelTypeArguments;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* At this point, we know we can't change the reference, so we need to verify that
|
|
* the model instance can be updated in-place.
|
|
*/
|
|
|
|
Type closedSupportedInterfaceType = supportedInterfaceType.MakeGenericType(modelTypeArguments);
|
|
if (!closedSupportedInterfaceType.IsInstanceOfType(modelMetadata.Model)) {
|
|
return null; // not instance of correct interface
|
|
}
|
|
|
|
Type closedCollectionType = TypeHelpers.ExtractGenericInterface(closedSupportedInterfaceType, typeof(ICollection<>));
|
|
bool collectionInstanceIsReadOnly = (bool)closedCollectionType.GetProperty("IsReadOnly").GetValue(modelMetadata.Model, null);
|
|
if (collectionInstanceIsReadOnly) {
|
|
return null;
|
|
}
|
|
else {
|
|
return modelTypeArguments;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|