public static IWrappedDictionary CreateDictionaryWrapper(object dictionary) { ValidationUtils.ArgumentNotNull(dictionary, "dictionary"); Type dictionaryDefinition; if (ReflectionUtils.ImplementsGenericDefinition(dictionary.GetType(), typeof(IDictionary <,>), out dictionaryDefinition)) { Type dictionaryKeyType = ReflectionUtils.GetDictionaryKeyType(dictionaryDefinition); Type dictionaryValueType = ReflectionUtils.GetDictionaryValueType(dictionaryDefinition); // Activator.CreateInstance throws AmbiguousMatchException. Manually invoke constructor Func <Type, IList <object>, object> instanceCreator = (t, a) => { ConstructorInfo c = t.GetConstructor(new[] { dictionaryDefinition }); return(c.Invoke(new[] { dictionary })); }; return((IWrappedDictionary)ReflectionUtils.CreateGeneric(typeof(DictionaryWrapper <,>), new[] { dictionaryKeyType, dictionaryValueType }, instanceCreator, dictionary)); } else if (dictionary is IDictionary) { return(new DictionaryWrapper <object, object>((IDictionary)dictionary)); } else { throw new Exception("Can not create DictionaryWrapper for type {0}.".FormatWith(CultureInfo.InvariantCulture, dictionary.GetType())); } }
public static void GetDictionaryKeyValueTypes(Type dictionaryType, out Type keyType, out Type valueType) { ValidationUtils.ArgumentNotNull(dictionaryType, "type"); Type type; if (ReflectionUtils.ImplementsGenericDefinition(dictionaryType, typeof(IDictionary <, >), out type)) { if (type.IsGenericTypeDefinition) { throw new Exception("Type {0} is not a dictionary.".FormatWith(CultureInfo.InvariantCulture, new object[] { dictionaryType })); } Type[] genericArguments = type.GetGenericArguments(); keyType = genericArguments[0]; valueType = genericArguments[1]; return; } else { if (typeof(IDictionary).IsAssignableFrom(dictionaryType)) { keyType = null; valueType = null; return; } throw new Exception("Type {0} is not a dictionary.".FormatWith(CultureInfo.InvariantCulture, new object[] { dictionaryType })); } }
public static IWrappedList CreateListWrapper(object list) { ValidationUtils.ArgumentNotNull(list, "list"); Type listDefinition; if (ReflectionUtils.ImplementsGenericDefinition(list.GetType(), typeof(IList <>), out listDefinition)) { Type collectionItemType = ReflectionUtils.GetCollectionItemType(listDefinition); // Activator.CreateInstance throws AmbiguousMatchException. Manually invoke constructor Func <Type, IList <object>, object> instanceCreator = (t, a) => { ConstructorInfo c = t.GetConstructor(new[] { listDefinition }); return(c.Invoke(new[] { list })); }; return((IWrappedList)ReflectionUtils.CreateGeneric(typeof(ListWrapper <>), new[] { collectionItemType }, instanceCreator, list)); } else if (list is IList) { return(new ListWrapper <object>((IList)list)); } else { throw new Exception("Can not create ListWrapper for type {0}.".FormatWith(CultureInfo.InvariantCulture, list.GetType())); } }
public static IWrappedDictionary CreateDictionaryWrapper(object dictionary) { ValidationUtils.ArgumentNotNull(dictionary, "dictionary"); Type dictionaryDefinition; if (ReflectionUtils.ImplementsGenericDefinition(dictionary.GetType(), typeof(IDictionary <,>), out dictionaryDefinition)) { return((IWrappedDictionary)ReflectionUtils.CreateGeneric(typeof(DictionaryWrapper <,>), (IList <Type>) new Type[2] { ReflectionUtils.GetDictionaryKeyType(dictionaryDefinition), ReflectionUtils.GetDictionaryValueType(dictionaryDefinition) }, (Func <Type, IList <object>, object>)((t, a) => t.GetConstructor(new Type[1] { dictionaryDefinition }).Invoke(new object[1] { dictionary })), new object[1] { dictionary })); } else if (dictionary is IDictionary) { return((IWrappedDictionary) new DictionaryWrapper <object, object>((IDictionary)dictionary)); } else { throw new ArgumentException(StringUtils.FormatWith("Can not create DictionaryWrapper for type {0}.", (IFormatProvider)CultureInfo.InvariantCulture, (object)dictionary.GetType()), "dictionary"); } }
public static Type GetCollectionItemType(Type type) { ValidationUtils.ArgumentNotNull(type, "type"); if (type.IsArray) { return(type.GetElementType()); } Type type2; if (ReflectionUtils.ImplementsGenericDefinition(type, typeof(IEnumerable <>), out type2)) { if (type2.IsGenericTypeDefinition) { throw new Exception("Type {0} is not a collection.".FormatWith(CultureInfo.InvariantCulture, new object[] { type })); } return(type2.GetGenericArguments()[0]); } else { if (typeof(IEnumerable).IsAssignableFrom(type)) { return(null); } throw new Exception("Type {0} is not a collection.".FormatWith(CultureInfo.InvariantCulture, new object[] { type })); } }
public static IWrappedCollection CreateCollectionWrapper(object list) { ValidationUtils.ArgumentNotNull(list, "list"); Type collectionDefinition; if (ReflectionUtils.ImplementsGenericDefinition(list.GetType(), typeof(ICollection <>), out collectionDefinition)) { return((IWrappedCollection)ReflectionUtils.CreateGeneric(typeof(CollectionWrapper <>), (IList <Type>) new Type[1] { ReflectionUtils.GetCollectionItemType(collectionDefinition) }, (Func <Type, IList <object>, object>)((t, a) => t.GetConstructor(new Type[1] { collectionDefinition }).Invoke(new object[1] { list })), new object[1] { list })); } else if (list is IList) { return((IWrappedCollection) new CollectionWrapper <object>((IList)list)); } else { throw new ArgumentException(StringUtils.FormatWith("Can not create ListWrapper for type {0}.", (IFormatProvider)CultureInfo.InvariantCulture, (object)list.GetType()), "list"); } }
public static void GetDictionaryKeyValueTypes( Type dictionaryType, out Type keyType, out Type valueType) { ValidationUtils.ArgumentNotNull((object)dictionaryType, nameof(dictionaryType)); Type implementingType; if (ReflectionUtils.ImplementsGenericDefinition(dictionaryType, typeof(IDictionary <,>), out implementingType)) { if (implementingType.IsGenericTypeDefinition()) { throw new Exception("Type {0} is not a dictionary.".FormatWith((IFormatProvider)CultureInfo.InvariantCulture, (object)dictionaryType)); } Type[] genericArguments = implementingType.GetGenericArguments(); keyType = genericArguments[0]; valueType = genericArguments[1]; } else { if (!typeof(IDictionary).IsAssignableFrom(dictionaryType)) { throw new Exception("Type {0} is not a dictionary.".FormatWith((IFormatProvider)CultureInfo.InvariantCulture, (object)dictionaryType)); } keyType = (Type)null; valueType = (Type)null; } }
public static IWrappedDictionary CreateDictionaryWrapper(object dictionary) { ValidationUtils.ArgumentNotNull(dictionary, "dictionary"); if (ReflectionUtils.ImplementsGenericDefinition(dictionary.GetType(), typeof(IDictionary <, >), out var dictionaryDefinition)) { Type dictionaryKeyType = ReflectionUtils.GetDictionaryKeyType(dictionaryDefinition); Type dictionaryValueType = ReflectionUtils.GetDictionaryValueType(dictionaryDefinition); Func <Type, IList <object>, object> instanceCreator = delegate(Type t, IList <object> a) { ConstructorInfo constructor = t.GetConstructor(new Type[1] { dictionaryDefinition }); return(constructor.Invoke(new object[1] { dictionary })); }; return((IWrappedDictionary)ReflectionUtils.CreateGeneric(typeof(DictionaryWrapper <, >), new Type[2] { dictionaryKeyType, dictionaryValueType }, instanceCreator, dictionary)); } if (dictionary is IDictionary) { return(new DictionaryWrapper <object, object>((IDictionary)dictionary)); } throw new Exception("Can not create DictionaryWrapper for type {0}.".FormatWith(CultureInfo.InvariantCulture, dictionary.GetType())); }
public static IWrappedList CreateListWrapper(object list) { ValidationUtils.ArgumentNotNull(list, "list"); if (ReflectionUtils.ImplementsGenericDefinition(list.GetType(), typeof(IList <>), out var listDefinition)) { Type collectionItemType = ReflectionUtils.GetCollectionItemType(listDefinition); Func <Type, IList <object>, object> instanceCreator = delegate(Type t, IList <object> a) { ConstructorInfo constructor = t.GetConstructor(new Type[1] { listDefinition }); return(constructor.Invoke(new object[1] { list })); }; return((IWrappedList)ReflectionUtils.CreateGeneric(typeof(ListWrapper <>), new Type[1] { collectionItemType }, instanceCreator, list)); } if (list is IList) { return(new ListWrapper <object>((IList)list)); } throw new Exception("Can not create ListWrapper for type {0}.".FormatWith(CultureInfo.InvariantCulture, list.GetType())); }
public static IList CreateList(Type listType, out bool isReadOnlyOrFixedSize) { ValidationUtils.ArgumentNotNull((object)listType, "listType"); isReadOnlyOrFixedSize = false; IList list1; if (listType.IsArray) { list1 = (IList) new List <object>(); isReadOnlyOrFixedSize = true; } else { Type implementingType; if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>), out implementingType)) { Type listType1 = implementingType.GetGenericArguments()[0]; Type type = ReflectionUtils.MakeGenericType(typeof(IEnumerable <>), new Type[1] { listType1 }); bool flag = false; foreach (MethodBase methodBase in listType.GetConstructors()) { IList <ParameterInfo> list2 = (IList <ParameterInfo>)methodBase.GetParameters(); if (list2.Count == 1 && type.IsAssignableFrom(list2[0].ParameterType)) { flag = true; break; } } if (!flag) { throw new Exception(StringUtils.FormatWith("Read-only type {0} does not have a public constructor that takes a type that implements {1}.", (IFormatProvider)CultureInfo.InvariantCulture, (object)listType, (object)type)); } list1 = CollectionUtils.CreateGenericList(listType1); isReadOnlyOrFixedSize = true; } else { list1 = !typeof(IList).IsAssignableFrom(listType) ? (!ReflectionUtils.ImplementsGenericDefinition(listType, typeof(ICollection <>)) ? (IList)null : (!ReflectionUtils.IsInstantiatableType(listType) ? (IList)null : (IList)CollectionUtils.CreateCollectionWrapper(Activator.CreateInstance(listType)))) : (!ReflectionUtils.IsInstantiatableType(listType) ? (listType != typeof(IList) ? (IList)null : (IList) new List <object>()) : (IList)Activator.CreateInstance(listType)); } } if (list1 == null) { throw new InvalidOperationException(StringUtils.FormatWith("Cannot create and populate list type {0}.", (IFormatProvider)CultureInfo.InvariantCulture, (object)listType)); } else { return(list1); } }
public static bool IsDictionaryType(Type type) { ValidationUtils.ArgumentNotNull(type, "type"); if (typeof(IDictionary).IsAssignableFrom(type)) { return(true); } if (ReflectionUtils.ImplementsGenericDefinition(type, typeof(IDictionary <,>))) { return(true); } return(false); }
public static bool IsCollectionType(Type type) { ValidationUtils.ArgumentNotNull(type, "type"); if (type.IsArray) { return(true); } if (typeof(ICollection).IsAssignableFrom(type)) { return(true); } if (ReflectionUtils.ImplementsGenericDefinition(type, typeof(ICollection <>))) { return(true); } return(false); }
public static bool IsDictionaryType(Type type) { ValidationUtils.ArgumentNotNull(type, "type"); if (typeof(IDictionary).IsAssignableFrom(type)) { return(true); } if (ReflectionUtils.ImplementsGenericDefinition(type, typeof(IDictionary <,>))) { return(true); } #if !(NET40 || NET35 || NET20 || PORTABLE40) if (ReflectionUtils.ImplementsGenericDefinition(type, typeof(IReadOnlyDictionary <,>))) { return(true); } #endif return(false); }
public static bool IsDictionaryType(Type type) { ValidationUtils.ArgumentNotNull(type, nameof(type)); if (typeof(IDictionary).IsAssignableFrom(type)) { return(true); } if (ReflectionUtils.ImplementsGenericDefinition(type, typeof(IDictionary <,>))) { return(true); } #if HAVE_READ_ONLY_COLLECTIONS if (ReflectionUtils.ImplementsGenericDefinition(type, typeof(IReadOnlyDictionary <,>))) { return(true); } #endif return(false); }
public static IWrappedList CreateListWrapper(object list) { Type type; ValidationUtils.ArgumentNotNull(list, "list"); if (!ReflectionUtils.ImplementsGenericDefinition(list.GetType(), typeof(IList <>), out type)) { if (!(list is IList)) { throw new Exception("Can not create ListWrapper for type {0}.".FormatWith(CultureInfo.InvariantCulture, new object[] { list.GetType() })); } return(new ListWrapper <object>((IList)list)); } Type collectionItemType = ReflectionUtils.GetCollectionItemType(type); Func <Type, IList <object>, object> func = (Type t, IList <object> a) => t.GetConstructor(new Type[] { type }).Invoke(new object[] { list }); Type type1 = typeof(ListWrapper <>); Type[] typeArray = new Type[] { collectionItemType }; object[] objArray = new object[] { list }; return((IWrappedList)ReflectionUtils.CreateGeneric(type1, (IList <Type>)typeArray, func, objArray)); }
public static IWrappedDictionary CreateDictionaryWrapper(object dictionary) { Type type; ValidationUtils.ArgumentNotNull(dictionary, "dictionary"); if (!ReflectionUtils.ImplementsGenericDefinition(dictionary.GetType(), typeof(IDictionary <,>), out type)) { if (!(dictionary is IDictionary)) { throw new Exception("Can not create DictionaryWrapper for type {0}.".FormatWith(CultureInfo.InvariantCulture, new object[] { dictionary.GetType() })); } return(new DictionaryWrapper <object, object>((IDictionary)dictionary)); } Type dictionaryKeyType = ReflectionUtils.GetDictionaryKeyType(type); Type dictionaryValueType = ReflectionUtils.GetDictionaryValueType(type); Func <Type, IList <object>, object> func = (Type t, IList <object> a) => t.GetConstructor(new Type[] { type }).Invoke(new object[] { dictionary }); Type type1 = typeof(DictionaryWrapper <,>); Type[] typeArray = new Type[] { dictionaryKeyType, dictionaryValueType }; object[] objArray = new object[] { dictionary }; return((IWrappedDictionary)ReflectionUtils.CreateGeneric(type1, (IList <Type>)typeArray, func, objArray)); }
/// <summary>Gets the type of the typed collection's items.</summary> /// <param name="type">The type.</param> /// <returns>The type of the typed collection's items.</returns> public static Type GetCollectionItemType(Type type) { ValidationUtils.ArgumentNotNull((object)type, nameof(type)); if (type.IsArray) { return(type.GetElementType()); } Type implementingType; if (ReflectionUtils.ImplementsGenericDefinition(type, typeof(IEnumerable <>), out implementingType)) { if (implementingType.IsGenericTypeDefinition()) { throw new Exception("Type {0} is not a collection.".FormatWith((IFormatProvider)CultureInfo.InvariantCulture, (object)type)); } return(implementingType.GetGenericArguments()[0]); } if (typeof(IEnumerable).IsAssignableFrom(type)) { return((Type)null); } throw new Exception("Type {0} is not a collection.".FormatWith((IFormatProvider)CultureInfo.InvariantCulture, (object)type)); }
public static bool IsDictionaryType(Type type) { ValidationUtils.ArgumentNotNull(type, "type"); return(typeof(IDictionary).IsAssignableFrom(type) || (ReflectionUtils.ImplementsGenericDefinition(type, typeof(IDictionary <,>)) || ReflectionUtils.ImplementsGenericDefinition(type, typeof(IReadOnlyDictionary <,>)))); }
public static object CreateAndPopulateList(Type listType, Action <IList, bool> populateList) { ValidationUtils.ArgumentNotNull(listType, "listType"); ValidationUtils.ArgumentNotNull(populateList, "populateList"); IList list; Type collectionType; bool isReadOnlyOrFixedSize = false; if (listType.IsArray) { // have to use an arraylist when creating array // there is no way to know the size until it is finised list = new List <object>(); isReadOnlyOrFixedSize = true; } else if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>), out collectionType)) { Type readOnlyCollectionContentsType = collectionType.GetGenericArguments()[0]; Type genericEnumerable = ReflectionUtils.MakeGenericType(typeof(IEnumerable <>), readOnlyCollectionContentsType); bool suitableConstructor = false; foreach (ConstructorInfo constructor in listType.GetConstructors()) { IList <ParameterInfo> parameters = constructor.GetParameters(); if (parameters.Count == 1) { if (genericEnumerable.IsAssignableFrom(parameters[0].ParameterType)) { suitableConstructor = true; break; } } } if (!suitableConstructor) { throw new Exception("Read-only type {0} does not have a public constructor that takes a type that implements {1}.".FormatWith(CultureInfo.InvariantCulture, listType, genericEnumerable)); } // can't add or modify a readonly list // use List<T> and convert once populated list = CreateGenericList(readOnlyCollectionContentsType); isReadOnlyOrFixedSize = true; } else if (typeof(IList).IsAssignableFrom(listType)) { if (ReflectionUtils.IsInstantiatableType(listType)) { list = (IList)Activator.CreateInstance(listType); } else if (listType == typeof(IList)) { list = new List <object>(); } else { list = null; } } else if (ReflectionUtils.ImplementsGenericDefinition(listType, typeof(ICollection <>))) { if (ReflectionUtils.IsInstantiatableType(listType)) { list = CreateCollectionWrapper(Activator.CreateInstance(listType)); } else { list = null; } } else if (listType == typeof(BitArray)) { // have to use an arraylist when creating array // there is no way to know the size until it is finised list = new List <object>(); isReadOnlyOrFixedSize = true; } else { list = null; } if (list == null) { throw new Exception("Cannot create and populate list type {0}.".FormatWith(CultureInfo.InvariantCulture, listType)); } populateList(list, isReadOnlyOrFixedSize); // create readonly and fixed sized collections using the temporary list if (isReadOnlyOrFixedSize) { if (listType.IsArray) { if (listType.GetArrayRank() > 1) { list = ToMultidimensionalArray(list, ReflectionUtils.GetCollectionItemType(listType), listType.GetArrayRank()); } else { list = ToArray(((List <object>)list).ToArray(), ReflectionUtils.GetCollectionItemType(listType)); } } else if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>))) { list = (IList)ReflectionUtils.CreateInstance(listType, list); } else if (listType == typeof(BitArray)) { var newBitArray = new BitArray(list.Count); for (var i = 0; i < list.Count; i++) { newBitArray[i] = (bool)list[i]; } return(newBitArray); } } else if (list is IWrappedCollection) { return(((IWrappedCollection)list).UnderlyingCollection); } return(list); }
// Token: 0x06000E29 RID: 3625 RVA: 0x00051B74 File Offset: 0x0004FD74 public static bool ImplementsGenericDefinition(Type type, Type genericInterfaceDefinition) { Type type2; return(ReflectionUtils.ImplementsGenericDefinition(type, genericInterfaceDefinition, out type2)); }
public static IList CreateList(Type listType, out bool isReadOnlyOrFixedSize) { ValidationUtils.ArgumentNotNull(listType, "listType"); IList list; Type collectionType; isReadOnlyOrFixedSize = false; if (listType.IsArray) { // have to use an arraylist when creating array // there is no way to know the size until it is finised list = new List <object>(); isReadOnlyOrFixedSize = true; } else if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>), out collectionType)) { Type readOnlyCollectionContentsType = collectionType.GetGenericArguments()[0]; Type genericEnumerable = ReflectionUtils.MakeGenericType(typeof(IEnumerable <>), readOnlyCollectionContentsType); bool suitableConstructor = false; foreach (ConstructorInfo constructor in listType.GetConstructors()) { IList <ParameterInfo> parameters = constructor.GetParameters(); if (parameters.Count == 1) { if (genericEnumerable.IsAssignableFrom(parameters[0].ParameterType)) { suitableConstructor = true; break; } } } if (!suitableConstructor) { throw new Exception("Read-only type {0} does not have a public constructor that takes a type that implements {1}.".FormatWith(CultureInfo.InvariantCulture, listType, genericEnumerable)); } // can't add or modify a readonly list // use List<T> and convert once populated list = CreateGenericList(readOnlyCollectionContentsType); isReadOnlyOrFixedSize = true; } else if (typeof(IList).IsAssignableFrom(listType)) { if (ReflectionUtils.IsInstantiatableType(listType)) { list = (IList)Activator.CreateInstance(listType); } else if (listType == typeof(IList)) { list = new List <object>(); } else { list = null; } } else if (ReflectionUtils.ImplementsGenericDefinition(listType, typeof(ICollection <>))) { if (ReflectionUtils.IsInstantiatableType(listType)) { list = CreateCollectionWrapper(Activator.CreateInstance(listType)); } else { list = null; } } else { list = null; } if (list == null) { throw new InvalidOperationException("Cannot create and populate list type {0}.".FormatWith(CultureInfo.InvariantCulture, listType)); } return(list); }
public static bool IsDictionaryType(Type type) { ValidationUtils.ArgumentNotNull((object)type, nameof(type)); return(typeof(IDictionary).IsAssignableFrom(type) || ReflectionUtils.ImplementsGenericDefinition(type, typeof(IDictionary <,>))); }
public static object CreateAndPopulateList(Type listType, Action <IList, bool> populateList) { ValidationUtils.ArgumentNotNull(listType, "listType"); ValidationUtils.ArgumentNotNull(populateList, "populateList"); bool flag = false; IList list; Type type; if (listType.IsArray) { list = new List <object>(); flag = true; } else if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>), out type)) { Type type2 = type.GetGenericArguments()[0]; Type type3 = ReflectionUtils.MakeGenericType(typeof(IEnumerable <>), new Type[] { type2 }); bool flag2 = false; foreach (ConstructorInfo constructorInfo in listType.GetConstructors()) { IList <ParameterInfo> parameters = constructorInfo.GetParameters(); if (parameters.Count == 1 && type3.IsAssignableFrom(parameters[0].ParameterType)) { flag2 = true; break; } } if (!flag2) { throw new Exception("Read-only type {0} does not have a public constructor that takes a type that implements {1}.".FormatWith(CultureInfo.InvariantCulture, new object[] { listType, type3 })); } list = CollectionUtils.CreateGenericList(type2); flag = true; } else if (typeof(IList).IsAssignableFrom(listType)) { if (ReflectionUtils.IsInstantiatableType(listType)) { list = (IList)Activator.CreateInstance(listType); } else if (listType == typeof(IList)) { list = new List <object>(); } else { list = null; } } else if (ReflectionUtils.ImplementsGenericDefinition(listType, typeof(ICollection <>))) { if (ReflectionUtils.IsInstantiatableType(listType)) { list = CollectionUtils.CreateCollectionWrapper(Activator.CreateInstance(listType)); } else { list = null; } } else if (listType == typeof(BitArray)) { list = new List <object>(); flag = true; } else { list = null; } if (list == null) { throw new Exception("Cannot create and populate list type {0}.".FormatWith(CultureInfo.InvariantCulture, new object[] { listType })); } populateList(list, flag); if (flag) { if (listType.IsArray) { if (listType.GetArrayRank() > 1) { list = CollectionUtils.ToMultidimensionalArray(list, ReflectionUtils.GetCollectionItemType(listType), listType.GetArrayRank()); } else { list = CollectionUtils.ToArray(((List <object>)list).ToArray(), ReflectionUtils.GetCollectionItemType(listType)); } } else if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>))) { list = (IList)ReflectionUtils.CreateInstance(listType, new object[] { list }); } else if (listType == typeof(BitArray)) { BitArray bitArray = new BitArray(list.Count); for (int j = 0; j < list.Count; j++) { bitArray[j] = (bool)list[j]; } return(bitArray); } } else if (list is IWrappedCollection) { return(((IWrappedCollection)list).UnderlyingCollection); } return(list); }
public static bool IsCollectionType(Type type) { ValidationUtils.ArgumentNotNull(type, "type"); return(type.IsArray || typeof(ICollection).IsAssignableFrom(type) || ReflectionUtils.ImplementsGenericDefinition(type, typeof(ICollection <>))); }
public static bool IsListType(Type type) { ValidationUtils.ArgumentNotNull(type, "type"); return(type.get_IsArray() || typeof(IList).IsAssignableFrom(type) || ReflectionUtils.ImplementsGenericDefinition(type, typeof(IList))); }
public static object CreateAndPopulateList(Type listType, Action <IList, bool> populateList) { IList objs; Type type; ValidationUtils.ArgumentNotNull(listType, "listType"); ValidationUtils.ArgumentNotNull(populateList, "populateList"); bool flag = false; if (listType.IsArray) { objs = new List <object>(); flag = true; } else if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>), out type)) { Type genericArguments = type.GetGenericArguments()[0]; Type type1 = ReflectionUtils.MakeGenericType(typeof(IEnumerable <>), new Type[] { genericArguments }); bool flag1 = false; ConstructorInfo[] constructors = listType.GetConstructors(); int num = 0; while (num < (int)constructors.Length) { IList <ParameterInfo> parameters = constructors[num].GetParameters(); if (parameters.Count != 1 || !type1.IsAssignableFrom(parameters[0].ParameterType)) { num++; } else { flag1 = true; break; } } if (!flag1) { throw new Exception("Read-only type {0} does not have a public constructor that takes a type that implements {1}.".FormatWith(CultureInfo.InvariantCulture, new object[] { listType, type1 })); } objs = CollectionUtils.CreateGenericList(genericArguments); flag = true; } else if (typeof(IList).IsAssignableFrom(listType)) { if (ReflectionUtils.IsInstantiatableType(listType)) { objs = (IList)Activator.CreateInstance(listType); } else if (listType != typeof(IList)) { objs = null; } else { objs = new List <object>(); } } else if (ReflectionUtils.ImplementsGenericDefinition(listType, typeof(ICollection <>))) { if (!ReflectionUtils.IsInstantiatableType(listType)) { objs = null; } else { objs = CollectionUtils.CreateCollectionWrapper(Activator.CreateInstance(listType)); } } else if (listType != typeof(BitArray)) { objs = null; } else { objs = new List <object>(); flag = true; } if (objs == null) { throw new Exception("Cannot create and populate list type {0}.".FormatWith(CultureInfo.InvariantCulture, new object[] { listType })); } populateList(objs, flag); if (!flag) { if (objs is IWrappedCollection) { return(((IWrappedCollection)objs).UnderlyingCollection); } } else if (listType.IsArray) { objs = (listType.GetArrayRank() <= 1 ? CollectionUtils.ToArray(((List <object>)objs).ToArray(), ReflectionUtils.GetCollectionItemType(listType)) : CollectionUtils.ToMultidimensionalArray(objs, ReflectionUtils.GetCollectionItemType(listType), listType.GetArrayRank())); } else if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>))) { objs = (IList)ReflectionUtils.CreateInstance(listType, new object[] { objs }); } else if (listType == typeof(BitArray)) { BitArray bitArrays = new BitArray(objs.Count); for (int i = 0; i < objs.Count; i++) { bitArrays[i] = (bool)objs[i]; } return(bitArrays); } return(objs); }
public static object CreateAndPopulateList(Type listType, Action <IList, bool> populateList) { ValidationUtils.ArgumentNotNull(listType, "listType"); ValidationUtils.ArgumentNotNull(populateList, "populateList"); bool flag = false; IList list; Type implementingType; if (listType.IsArray) { list = new List <object>(); flag = true; } else if (!ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>), out implementingType)) { list = (typeof(IList).IsAssignableFrom(listType) ? (ReflectionUtils.IsInstantiatableType(listType) ? ((IList)Activator.CreateInstance(listType)) : ((listType != typeof(IList)) ? null : new List <object>())) : ((!ReflectionUtils.ImplementsGenericDefinition(listType, typeof(ICollection <>))) ? null : ((!ReflectionUtils.IsInstantiatableType(listType)) ? null : CreateCollectionWrapper(Activator.CreateInstance(listType))))); } else { Type type = implementingType.GetGenericArguments()[0]; Type type2 = ReflectionUtils.MakeGenericType(typeof(IEnumerable <>), type); bool flag2 = false; ConstructorInfo[] constructors = listType.GetConstructors(); foreach (ConstructorInfo constructorInfo in constructors) { IList <ParameterInfo> parameters = constructorInfo.GetParameters(); if (parameters.Count == 1 && type2.IsAssignableFrom(parameters[0].ParameterType)) { flag2 = true; break; } } if (!flag2) { throw new Exception("Read-only type {0} does not have a public constructor that takes a type that implements {1}.".FormatWith(CultureInfo.InvariantCulture, listType, type2)); } list = CreateGenericList(type); flag = true; } if (list == null) { throw new Exception("Cannot create and populate list type {0}.".FormatWith(CultureInfo.InvariantCulture, listType)); } populateList(list, flag); if (flag) { if (listType.IsArray) { list = ToArray(((List <object>)list).ToArray(), ReflectionUtils.GetCollectionItemType(listType)); } else if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>))) { list = (IList)ReflectionUtils.CreateInstance(listType, list); } } else if (list is IWrappedCollection) { return(((IWrappedCollection)list).UnderlyingCollection); } return(list); }