[System.Security.SecuritySafeCritical] // auto-generated private static Comparer <T> CreateComparer() { RuntimeType t = (RuntimeType)typeof(T); // If T implements IComparable<T> return a GenericComparer<T> #if FEATURE_LEGACYNETCF // Pre-Apollo Windows Phone call the overload that sorts the keys, not values this achieves the same result if (CompatibilitySwitches.IsAppEarlierThanWindowsPhone8) { if (t.ImplementInterface(typeof(IComparable <T>))) { return((Comparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericComparer <int>), t)); } } else #endif if (typeof(IComparable <T>).IsAssignableFrom(t)) { return((Comparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericComparer <int>), t)); } // If T is a Nullable<U> where U implements IComparable<U> return a NullableComparer<U> if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable <>)) { RuntimeType u = (RuntimeType)t.GetGenericArguments()[0]; if (typeof(IComparable <>).MakeGenericType(u).IsAssignableFrom(u)) { return((Comparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableComparer <int>), u)); } } // Otherwise return an ObjectComparer<T> return(new ObjectComparer <T>()); }
// // Note that logic in this method is replicated in vm\compile.cpp to ensure that NGen // saves the right instantiations // private static Comparer <T> CreateComparer() { object result = null; RuntimeType t = (RuntimeType)typeof(T); // If T implements IComparable<T> return a GenericComparer<T> if (typeof(IComparable <T>).IsAssignableFrom(t)) { result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericComparer <int>), t); } else if (default(T) == null) { // If T is a Nullable<U> where U implements IComparable<U> return a NullableComparer<U> if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable <>)) { RuntimeType u = (RuntimeType)t.GetGenericArguments()[0]; if (typeof(IComparable <>).MakeGenericType(u).IsAssignableFrom(u)) { result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableComparer <int>), u); } } } else if (t.IsEnum) { // Explicitly call Enum.GetUnderlyingType here. Although GetTypeCode // ends up doing this anyway, we end up avoiding an unnecessary P/Invoke // and virtual method call. TypeCode underlyingTypeCode = Type.GetTypeCode(Enum.GetUnderlyingType(t)); // Depending on the enum type, we need to special case the comparers so that we avoid boxing // Specialize differently for signed/unsigned types so we avoid problems with large numbers switch (underlyingTypeCode) { case TypeCode.SByte: case TypeCode.Int16: case TypeCode.Int32: result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(Int32EnumComparer <int>), t); break; case TypeCode.Byte: case TypeCode.UInt16: case TypeCode.UInt32: result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(UInt32EnumComparer <uint>), t); break; // 64-bit enums: use UnsafeEnumCastLong case TypeCode.Int64: result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(Int64EnumComparer <long>), t); break; case TypeCode.UInt64: result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(UInt64EnumComparer <ulong>), t); break; } } return(result != null ? (Comparer <T>)result : new ObjectComparer <T>()); // Fallback to ObjectComparer, which uses boxing }
private static EqualityComparer <T> CreateComparer() { RuntimeType c = (RuntimeType)typeof(T); if (c == typeof(byte)) { return((EqualityComparer <T>) new ByteEqualityComparer()); } if (typeof(IEquatable <T>).IsAssignableFrom(c)) { return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericEqualityComparer <int>), c)); } if (c.IsGenericType && (c.GetGenericTypeDefinition() == typeof(Nullable <>))) { RuntimeType type2 = (RuntimeType)c.GetGenericArguments()[0]; if (typeof(IEquatable <>).MakeGenericType(new Type[] { type2 }).IsAssignableFrom(type2)) { return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableEqualityComparer <int>), type2)); } } if (c.IsEnum && (Enum.GetUnderlyingType(c) == typeof(int))) { return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(EnumEqualityComparer <int>), c)); } return(new ObjectEqualityComparer <T>()); }
static Comparer <T> CreateComparer() { RuntimeType t = (RuntimeType)typeof(T); if (typeof(IComparable <T>).IsAssignableFrom(t)) { return((Comparer <T>)RuntimeType.CreateInstanceForAnotherGenericParameter(typeof(GenericComparer <>), t)); } // If T is a Nullable<U> where U implements IComparable<U> return a NullableComparer<U> if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable <>)) { RuntimeType u = (RuntimeType)t.GetGenericArguments()[0]; if (typeof(IComparable <>).MakeGenericType(u).IsAssignableFrom(u)) { return((Comparer <T>)RuntimeType.CreateInstanceForAnotherGenericParameter(typeof(NullableComparer <>), u)); } } if (t.IsEnum) { return((Comparer <T>)RuntimeType.CreateInstanceForAnotherGenericParameter(typeof(EnumComparer <>), t)); } // Otherwise return an ObjectComparer<T> return(new ObjectComparer <T> ()); }
[System.Security.SecuritySafeCritical] // auto-generated private static EqualityComparer <T> CreateComparer() { Contract.Ensures(Contract.Result <EqualityComparer <T> >() != null); RuntimeType t = (RuntimeType)typeof(T); // Specialize type byte for performance reasons if (t == typeof(byte)) { return((EqualityComparer <T>)(object)(new ByteEqualityComparer())); } // If T implements IEquatable<T> return a GenericEqualityComparer<T> if (typeof(IEquatable <T>).IsAssignableFrom(t)) { return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericEqualityComparer <int>), t)); } // If T is a Nullable<U> where U implements IEquatable<U> return a NullableEqualityComparer<U> if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable <>)) { RuntimeType u = (RuntimeType)t.GetGenericArguments()[0]; if (typeof(IEquatable <>).MakeGenericType(u).IsAssignableFrom(u)) { return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableEqualityComparer <int>), u)); } } // If T is an int-based Enum, return an EnumEqualityComparer<T> // See the METHOD__JIT_HELPERS__UNSAFE_ENUM_CAST and METHOD__JIT_HELPERS__UNSAFE_ENUM_CAST_LONG cases in getILIntrinsicImplementation if (t.IsEnum && Enum.GetUnderlyingType(t) == typeof(int)) { return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(EnumEqualityComparer <int>), t)); } // Otherwise return an ObjectEqualityComparer<T> return(new ObjectEqualityComparer <T>()); }
[System.Security.SecuritySafeCritical] // auto-generated private static Comparer <T> CreateComparer() { object result = null; RuntimeType t = (RuntimeType)typeof(T); // If T implements IComparable<T> return a GenericComparer<T> if (typeof(IComparable <T>).IsAssignableFrom(t)) { result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericComparer <int>), t); } else if (default(T) == null) { // If T is a Nullable<U> where U implements IComparable<U> return a NullableComparer<U> if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable <>)) { RuntimeType u = (RuntimeType)t.GetGenericArguments()[0]; if (typeof(IComparable <>).MakeGenericType(u).IsAssignableFrom(u)) { result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableComparer <int>), u); } } } return(result != null ? (Comparer <T>)result : new ObjectComparer <T>()); // Fallback to ObjectComparer, which uses boxing }
private static EqualityComparer <T> CreateComparer() { RuntimeType t = (RuntimeType)typeof(T); ///////////////////////////////////////////////// // KEEP THIS IN SYNC WITH THE DEVIRT CODE // IN METHOD-TO-IR.C ///////////////////////////////////////////////// if (t == typeof(byte)) { return((EqualityComparer <T>)(object)(new ByteEqualityComparer())); } if (typeof(IEquatable <T>).IsAssignableFrom(t)) { return((EqualityComparer <T>)RuntimeType.CreateInstanceForAnotherGenericParameter(typeof(GenericEqualityComparer <>), t)); } if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable <>)) { RuntimeType u = (RuntimeType)t.GetGenericArguments()[0]; if (typeof(IEquatable <>).MakeGenericType(u).IsAssignableFrom(u)) { return((EqualityComparer <T>)RuntimeType.CreateInstanceForAnotherGenericParameter(typeof(NullableEqualityComparer <>), u)); } } if (t.IsEnum) { return((EqualityComparer <T>)RuntimeType.CreateInstanceForAnotherGenericParameter(typeof(EnumEqualityComparer <>), t)); } return(new ObjectEqualityComparer <T>()); }
[System.Security.SecuritySafeCritical] // auto-generated private static EqualityComparer <T> CreateComparer() { Contract.Ensures(Contract.Result <EqualityComparer <T> >() != null); RuntimeType t = (RuntimeType)typeof(T);//获取泛型格式 // 用于性能原因的专门类型字节 if (t == typeof(byte)) { return((EqualityComparer <T>)(object)(new ByteEqualityComparer())); } // If T implements IEquatable<T> return a GenericEqualityComparer<T> // 如果T实现IEquatable<T>,则返回GenericEqualityComparer<T> if (typeof(IEquatable <T>).IsAssignableFrom(t)) { return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericEqualityComparer <int>), t)); } // If T is a Nullable<U> where U implements IEquatable<U> return a NullableEqualityComparer<U> // 如果T是一个实现了IEquatable<U>的Nullable<U>,将返回一个NullableEqualityComparer<U> if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable <>)) { RuntimeType u = (RuntimeType)t.GetGenericArguments()[0]; if (typeof(IEquatable <>).MakeGenericType(u).IsAssignableFrom(u)) { return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableEqualityComparer <int>), u)); } } // See the METHOD__JIT_HELPERS__UNSAFE_ENUM_CAST and METHOD__JIT_HELPERS__UNSAFE_ENUM_CAST_LONG cases in getILIntrinsicImplementation if (t.IsEnum) { TypeCode underlyingTypeCode = Type.GetTypeCode(Enum.GetUnderlyingType(t)); // Depending on the enum type, we need to special case the comparers so that we avoid boxing // Note: We have different comparers for Short and SByte because for those types we need to make sure we call GetHashCode on the actual underlying type as the // implementation of GetHashCode is more complex than for the other types. switch (underlyingTypeCode) { case TypeCode.Int16: // short return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(ShortEnumEqualityComparer <short>), t)); case TypeCode.SByte: return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(SByteEnumEqualityComparer <sbyte>), t)); case TypeCode.Int32: case TypeCode.UInt32: case TypeCode.Byte: case TypeCode.UInt16: //ushort return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(EnumEqualityComparer <int>), t)); case TypeCode.Int64: case TypeCode.UInt64: return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(LongEnumEqualityComparer <long>), t)); } } // Otherwise return an ObjectEqualityComparer<T> return(new ObjectEqualityComparer <T>()); }
/// <summary> /// Creates the default <see cref="Comparer{T}"/> for a nullable type. /// </summary> /// <param name="nullableType">The nullable type to create the default comparer for.</param> private static object TryCreateNullableComparer(RuntimeType nullableType) { Debug.Assert(nullableType != null); Debug.Assert(nullableType.IsGenericType && nullableType.GetGenericTypeDefinition() == typeof(Nullable <>)); var embeddedType = (RuntimeType)nullableType.GetGenericArguments()[0]; if (typeof(IComparable <>).MakeGenericType(embeddedType).IsAssignableFrom(embeddedType)) { return(RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableComparer <int>), embeddedType)); } return(null); }
internal static Attribute[] GetCustomAttributes(RuntimeType type, Type caType, bool includeSecCa, out int count) { count = 0; bool flag = (caType == typeof(object)) || (caType == typeof(Attribute)); if ((!flag && (s_pca[caType] == null)) && !IsSecurityAttribute(caType)) { return(new Attribute[0]); } List <Attribute> list = new List <Attribute>(); Attribute item = null; if (flag || (caType == typeof(SerializableAttribute))) { item = SerializableAttribute.GetCustomAttribute(type); if (item != null) { list.Add(item); } } if (flag || (caType == typeof(ComImportAttribute))) { item = ComImportAttribute.GetCustomAttribute(type); if (item != null) { list.Add(item); } } if ((includeSecCa && (flag || IsSecurityAttribute(caType))) && !type.IsGenericParameter) { object[] objArray; if (type.IsGenericType) { type = (RuntimeType)type.GetGenericTypeDefinition(); } GetSecurityAttributes(type.Module.ModuleHandle, type.MetadataToken, out objArray); if (objArray != null) { foreach (object obj2 in objArray) { if ((caType == obj2.GetType()) || obj2.GetType().IsSubclassOf(caType)) { list.Add((Attribute)obj2); } } } } count = list.Count; return(list.ToArray()); }
internal static object[] GetCustomAttributes(RuntimeType type, RuntimeType caType, bool inherit) { if (type.GetElementType() != null) { if (!caType.IsValueType) { return(CustomAttribute.CreateAttributeArrayHelper(caType, 0)); } return(EmptyArray <object> .Value); } else { if (type.IsGenericType && !type.IsGenericTypeDefinition) { type = (type.GetGenericTypeDefinition() as RuntimeType); } int i = 0; Attribute[] customAttributes = PseudoCustomAttribute.GetCustomAttributes(type, caType, true, out i); if (!inherit || (caType.IsSealed && !CustomAttribute.GetAttributeUsage(caType).Inherited)) { object[] customAttributes2 = CustomAttribute.GetCustomAttributes(type.GetRuntimeModule(), type.MetadataToken, i, caType, !CustomAttribute.AllowCriticalCustomAttributes(type)); if (i > 0) { Array.Copy(customAttributes, 0, customAttributes2, customAttributes2.Length - i, i); } return(customAttributes2); } List <object> list = new List <object>(); bool mustBeInheritable = false; Type elementType = (caType == null || caType.IsValueType || caType.ContainsGenericParameters) ? typeof(object) : caType; while (i > 0) { list.Add(customAttributes[--i]); } while (type != (RuntimeType)typeof(object) && type != null) { object[] customAttributes3 = CustomAttribute.GetCustomAttributes(type.GetRuntimeModule(), type.MetadataToken, 0, caType, mustBeInheritable, list, !CustomAttribute.AllowCriticalCustomAttributes(type)); mustBeInheritable = true; for (int j = 0; j < customAttributes3.Length; j++) { list.Add(customAttributes3[j]); } type = (type.BaseType as RuntimeType); } object[] array = CustomAttribute.CreateAttributeArrayHelper(elementType, list.Count); Array.Copy(list.ToArray(), 0, array, 0, list.Count); return(array); } }
internal static Attribute[] GetCustomAttributes(RuntimeType type, RuntimeType caType, bool includeSecCa, out int count) { count = 0; bool flag = caType == (RuntimeType)typeof(object) || caType == (RuntimeType)typeof(Attribute); if (!flag && PseudoCustomAttribute.s_pca.GetValueOrDefault(caType) == null && !PseudoCustomAttribute.IsSecurityAttribute(caType)) { return(new Attribute[0]); } List <Attribute> list = new List <Attribute>(); if (flag || caType == (RuntimeType)typeof(SerializableAttribute)) { Attribute customAttribute = SerializableAttribute.GetCustomAttribute(type); if (customAttribute != null) { list.Add(customAttribute); } } if (flag || caType == (RuntimeType)typeof(ComImportAttribute)) { Attribute customAttribute = ComImportAttribute.GetCustomAttribute(type); if (customAttribute != null) { list.Add(customAttribute); } } if (includeSecCa && (flag || PseudoCustomAttribute.IsSecurityAttribute(caType)) && !type.IsGenericParameter && type.GetElementType() == null) { if (type.IsGenericType) { type = (RuntimeType)type.GetGenericTypeDefinition(); } object[] array; PseudoCustomAttribute.GetSecurityAttributes(type.Module.ModuleHandle.GetRuntimeModule(), type.MetadataToken, false, out array); if (array != null) { foreach (object obj in array) { if (caType == obj.GetType() || obj.GetType().IsSubclassOf(caType)) { list.Add((Attribute)obj); } } } } count = list.Count; return(list.ToArray()); }
internal static object[] GetCustomAttributes(RuntimeType type, RuntimeType caType, bool inherit) { if (type.GetElementType() != null) { if (!caType.IsValueType) { return(CreateAttributeArrayHelper(caType, 0)); } return(new object[0]); } if (type.IsGenericType && !type.IsGenericTypeDefinition) { type = type.GetGenericTypeDefinition() as RuntimeType; } int count = 0; Attribute[] sourceArray = PseudoCustomAttribute.GetCustomAttributes(type, caType, true, out count); if (!inherit || (caType.IsSealed && !GetAttributeUsage(caType).Inherited)) { object[] objArray = GetCustomAttributes(type.GetRuntimeModule(), type.MetadataToken, count, caType, !AllowCriticalCustomAttributes(type)); if (count > 0) { Array.Copy(sourceArray, 0, objArray, objArray.Length - count, count); } return(objArray); } List <object> derivedAttributes = new List <object>(); bool mustBeInheritable = false; Type elementType = (((caType == null) || caType.IsValueType) || caType.ContainsGenericParameters) ? typeof(object) : caType; while (count > 0) { derivedAttributes.Add(sourceArray[--count]); } while ((type != ((RuntimeType)typeof(object))) && (type != null)) { object[] objArray2 = GetCustomAttributes(type.GetRuntimeModule(), type.MetadataToken, 0, caType, mustBeInheritable, derivedAttributes, !AllowCriticalCustomAttributes(type)); mustBeInheritable = true; for (int i = 0; i < objArray2.Length; i++) { derivedAttributes.Add(objArray2[i]); } type = type.BaseType as RuntimeType; } object[] destinationArray = CreateAttributeArrayHelper(elementType, derivedAttributes.Count); Array.Copy(derivedAttributes.ToArray(), 0, destinationArray, 0, derivedAttributes.Count); return(destinationArray); }
internal static object[] GetCustomAttributes(RuntimeType type, RuntimeType caType, bool inherit) { if (type.GetElementType() != (Type)null) { if (!caType.IsValueType) { return(CustomAttribute.CreateAttributeArrayHelper((Type)caType, 0)); } return(EmptyArray <object> .Value); } if (type.IsGenericType && !type.IsGenericTypeDefinition) { type = type.GetGenericTypeDefinition() as RuntimeType; } int count = 0; Attribute[] customAttributes1 = PseudoCustomAttribute.GetCustomAttributes(type, caType, true, out count); if (!inherit || caType.IsSealed && !CustomAttribute.GetAttributeUsage(caType).Inherited) { object[] customAttributes2 = CustomAttribute.GetCustomAttributes(type.GetRuntimeModule(), type.MetadataToken, count, caType, !CustomAttribute.AllowCriticalCustomAttributes(type)); if (count > 0) { Array.Copy((Array)customAttributes1, 0, (Array)customAttributes2, customAttributes2.Length - count, count); } return(customAttributes2); } List <object> objectList = new List <object>(); bool mustBeInheritable = false; Type elementType = (caType == (RuntimeType)null || caType.IsValueType ? 1 : (caType.ContainsGenericParameters ? 1 : 0)) != 0 ? typeof(object) : (Type)caType; while (count > 0) { objectList.Add((object)customAttributes1[--count]); } for (; type != (RuntimeType)typeof(object) && type != (RuntimeType)null; type = type.BaseType as RuntimeType) { object[] customAttributes2 = CustomAttribute.GetCustomAttributes(type.GetRuntimeModule(), type.MetadataToken, 0, caType, mustBeInheritable, (IList)objectList, !CustomAttribute.AllowCriticalCustomAttributes(type)); mustBeInheritable = true; for (int index = 0; index < customAttributes2.Length; ++index) { objectList.Add(customAttributes2[index]); } } object[] attributeArrayHelper = CustomAttribute.CreateAttributeArrayHelper(elementType, objectList.Count); Array.Copy((Array)objectList.ToArray(), 0, (Array)attributeArrayHelper, 0, objectList.Count); return(attributeArrayHelper); }
private static EqualityComparer <T> CreateComparer() { RuntimeType runtimeType = (RuntimeType)typeof(T); if (runtimeType == typeof(byte)) { return((EqualityComparer <T>) new ByteEqualityComparer()); } if (typeof(IEquatable <T>).IsAssignableFrom(runtimeType)) { return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericEqualityComparer <int>), runtimeType)); } if (runtimeType.IsGenericType && runtimeType.GetGenericTypeDefinition() == typeof(Nullable <>)) { RuntimeType runtimeType2 = (RuntimeType)runtimeType.GetGenericArguments()[0]; if (typeof(IEquatable <>).MakeGenericType(new Type[] { runtimeType2 }).IsAssignableFrom(runtimeType2)) { return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableEqualityComparer <int>), runtimeType2)); } } if (runtimeType.IsEnum) { switch (Type.GetTypeCode(Enum.GetUnderlyingType(runtimeType))) { case TypeCode.SByte: return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(SByteEnumEqualityComparer <sbyte>), runtimeType)); case TypeCode.Byte: case TypeCode.UInt16: case TypeCode.Int32: case TypeCode.UInt32: return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(EnumEqualityComparer <int>), runtimeType)); case TypeCode.Int16: return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(ShortEnumEqualityComparer <short>), runtimeType)); case TypeCode.Int64: case TypeCode.UInt64: return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(LongEnumEqualityComparer <long>), runtimeType)); } } return(new ObjectEqualityComparer <T>()); }
internal virtual QName GetDictionaryQName() { string name = a != null ? a.Name : null; string ns = a != null ? a.Namespace : null; if (RuntimeType.IsGenericType && RuntimeType.GetGenericTypeDefinition() != typeof(Dictionary <,>)) { name = name ?? KnownTypeCollection.GetDefaultName(RuntimeType); } else { name = "ArrayOf" + GetItemQName().Name; } ns = ns ?? KnownTypeCollection.MSArraysNamespace; return(new QName(name, ns)); }
private static Comparer <T> CreateComparer() { RuntimeType genericParameter1 = (RuntimeType)typeof(T); if (typeof(IComparable <T>).IsAssignableFrom((Type)genericParameter1)) { return((Comparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericComparer <int>), genericParameter1)); } if (genericParameter1.IsGenericType && genericParameter1.GetGenericTypeDefinition() == typeof(Nullable <>)) { RuntimeType genericParameter2 = (RuntimeType)genericParameter1.GetGenericArguments()[0]; if (typeof(IComparable <>).MakeGenericType((Type)genericParameter2).IsAssignableFrom((Type)genericParameter2)) { return((Comparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableComparer <int>), genericParameter2)); } } return((Comparer <T>) new ObjectComparer <T>()); }
private static Comparer <T> CreateComparer() { RuntimeType c = (RuntimeType)typeof(T); if (typeof(IComparable <T>).IsAssignableFrom(c)) { return((Comparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericComparer <int>), c)); } if (c.IsGenericType && (c.GetGenericTypeDefinition() == typeof(Nullable <>))) { RuntimeType type2 = (RuntimeType)c.GetGenericArguments()[0]; if (typeof(IComparable <>).MakeGenericType(new Type[] { type2 }).IsAssignableFrom(type2)) { return((Comparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableComparer <int>), type2)); } } return(new ObjectComparer <T>()); }
object CreateInstance() { if (RuntimeType.IsInterface) { if (RuntimeType.IsGenericType && Array.IndexOf(RuntimeType.GetGenericTypeDefinition().GetInterfaces(), typeof(IDictionary <,>)) >= 0) { var gargs = RuntimeType.GetGenericArguments(); return(Activator.CreateInstance(typeof(Dictionary <,>).MakeGenericType(gargs [0], gargs [1]))); // Dictionary<T> } else // non-generic { return(new Hashtable()); } } #if NET_2_1 // FIXME: is it fine? return(Activator.CreateInstance(RuntimeType)); #else return(Activator.CreateInstance(RuntimeType, true)); #endif }
private static String NonQualifiedTypeName(this Type type) { RuntimeType runtimeType = type as RuntimeType; if (runtimeType == null) { return(null); } if (runtimeType.HasElementType) { String elementTypeName = runtimeType.InternalRuntimeElementType.NonQualifiedTypeName(); if (elementTypeName == null) { return(null); } String suffix; if (runtimeType.IsArray) { int rank = runtimeType.GetArrayRank(); if (rank == 1) { suffix = "[" + (runtimeType.InternalIsMultiDimArray ? "*" : "") + "]"; } else { suffix = "[" + new String(',', rank - 1) + "]"; } } else if (runtimeType.IsByRef) { suffix = "&"; } else if (runtimeType.IsPointer) { suffix = "*"; } else { return(null); } return(elementTypeName + suffix); } else if (runtimeType.IsGenericParameter) { return(null); } else if (runtimeType.IsConstructedGenericType) { StringBuilder sb = new StringBuilder(); String genericTypeDefinitionTypeName = runtimeType.GetGenericTypeDefinition().NonQualifiedTypeName(); if (genericTypeDefinitionTypeName == null) { return(null); } sb.Append(genericTypeDefinitionTypeName); sb.Append("["); String sep = ""; foreach (RuntimeType ga in runtimeType.InternalRuntimeGenericTypeArguments) { String gaTypeName = ga.AssemblyQualifiedTypeName(); if (gaTypeName == null) { return(null); } sb.Append(sep + "[" + gaTypeName + "]"); sep = ","; } sb.Append("]"); return(sb.ToString()); } else { RuntimeNamedTypeInfo runtimeNamedTypeInfo = type.GetTypeInfo() as RuntimeNamedTypeInfo; if (runtimeNamedTypeInfo == null) { return(null); } MetadataReader reader = runtimeNamedTypeInfo.Reader; String s = ""; TypeDefinitionHandle typeDefinitionHandle = runtimeNamedTypeInfo.TypeDefinitionHandle; NamespaceDefinitionHandle namespaceDefinitionHandle; do { TypeDefinition typeDefinition = typeDefinitionHandle.GetTypeDefinition(reader); String name = typeDefinition.Name.GetString(reader); if (s == "") { s = name; } else { s = name + "+" + s; } namespaceDefinitionHandle = typeDefinition.NamespaceDefinition; typeDefinitionHandle = typeDefinition.EnclosingType; }while (!typeDefinitionHandle.IsNull(reader)); NamespaceChain namespaceChain = new NamespaceChain(reader, namespaceDefinitionHandle); String ns = namespaceChain.NameSpace; if (ns != null) { s = ns + "." + s; } return(s); } }
[System.Security.SecuritySafeCritical] // auto-generated private static EqualityComparer <T> CreateComparer() { Contract.Ensures(Contract.Result <EqualityComparer <T> >() != null); object result = null; RuntimeType t = (RuntimeType)typeof(T); // Specialize type byte for performance reasons if (t == typeof(byte)) { result = new ByteEqualityComparer(); } // If T implements IEquatable<T> return a GenericEqualityComparer<T> else if (typeof(IEquatable <T>).IsAssignableFrom(t)) { result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericEqualityComparer <int>), t); } else if (default(T) == null) // Reference type/Nullable { // If T is a Nullable<U> where U implements IEquatable<U> return a NullableEqualityComparer<U> if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable <>)) { RuntimeType u = (RuntimeType)t.GetGenericArguments()[0]; if (typeof(IEquatable <>).MakeGenericType(u).IsAssignableFrom(u)) { result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableEqualityComparer <int>), u); } } } // See the METHOD__JIT_HELPERS__UNSAFE_ENUM_CAST and METHOD__JIT_HELPERS__UNSAFE_ENUM_CAST_LONG cases in getILIntrinsicImplementation else if (t.IsEnum) { TypeCode underlyingTypeCode = Type.GetTypeCode(Enum.GetUnderlyingType(t)); // Depending on the enum type, we need to special case the comparers so that we avoid boxing // Note: We have different comparers for Short and SByte because for those types we need to make sure we call GetHashCode on the actual underlying type as the // implementation of GetHashCode is more complex than for the other types. switch (underlyingTypeCode) { case TypeCode.Int16: // short result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(ShortEnumEqualityComparer <short>), t); break; case TypeCode.SByte: result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(SByteEnumEqualityComparer <sbyte>), t); break; case TypeCode.Int32: case TypeCode.UInt32: case TypeCode.Byte: case TypeCode.UInt16: //ushort result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(EnumEqualityComparer <int>), t); break; case TypeCode.Int64: case TypeCode.UInt64: result = RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(LongEnumEqualityComparer <long>), t); break; } } return(result != null ? (EqualityComparer <T>)result : new ObjectEqualityComparer <T>()); // Fallback to ObjectEqualityComparer, which uses boxing }
[System.Security.SecuritySafeCritical] // auto-generated private static EqualityComparer <T> CreateComparer() { Contract.Ensures(Contract.Result <EqualityComparer <T> >() != null); RuntimeType t = (RuntimeType)typeof(T); // Specialize type byte for performance reasons if (t == typeof(byte)) { return((EqualityComparer <T>)(object)(new ByteEqualityComparer())); } ///////////////////////////////////////////////// // KEEP THIS IN SYNC WITH THE DEVIRT CODE // IN METHOD-TO-IR.C ///////////////////////////////////////////////// #if MOBILE // Breaks .net serialization compatibility if (t == typeof(string)) { return((EqualityComparer <T>)(object) new InternalStringComparer()); } #endif // If T implements IEquatable<T> return a GenericEqualityComparer<T> if (typeof(IEquatable <T>).IsAssignableFrom(t)) { #if MONO return((EqualityComparer <T>)RuntimeType.CreateInstanceForAnotherGenericParameter(typeof(GenericEqualityComparer <>), t)); #else return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericEqualityComparer <int>), t)); #endif } // If T is a Nullable<U> where U implements IEquatable<U> return a NullableEqualityComparer<U> if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable <>)) { RuntimeType u = (RuntimeType)t.GetGenericArguments()[0]; if (typeof(IEquatable <>).MakeGenericType(u).IsAssignableFrom(u)) { #if MONO return((EqualityComparer <T>)RuntimeType.CreateInstanceForAnotherGenericParameter(typeof(NullableEqualityComparer <>), u)); #else return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableEqualityComparer <int>), u)); #endif } } // See the METHOD__JIT_HELPERS__UNSAFE_ENUM_CAST and METHOD__JIT_HELPERS__UNSAFE_ENUM_CAST_LONG cases in getILIntrinsicImplementation if (t.IsEnum) { TypeCode underlyingTypeCode = Type.GetTypeCode(Enum.GetUnderlyingType(t)); // Depending on the enum type, we need to special case the comparers so that we avoid boxing // Note: We have different comparers for Short and SByte because for those types we need to make sure we call GetHashCode on the actual underlying type as the // implementation of GetHashCode is more complex than for the other types. switch (underlyingTypeCode) { case TypeCode.Int16: // short #if MONO return((EqualityComparer <T>)RuntimeType.CreateInstanceForAnotherGenericParameter(typeof(ShortEnumEqualityComparer <>), t)); #else return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(ShortEnumEqualityComparer <short>), t)); #endif case TypeCode.SByte: #if MONO return((EqualityComparer <T>)RuntimeType.CreateInstanceForAnotherGenericParameter(typeof(SByteEnumEqualityComparer <>), t)); #else return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(SByteEnumEqualityComparer <sbyte>), t)); #endif case TypeCode.Int32: case TypeCode.UInt32: case TypeCode.Byte: case TypeCode.UInt16: //ushort #if MONO return((EqualityComparer <T>)RuntimeType.CreateInstanceForAnotherGenericParameter(typeof(EnumEqualityComparer <>), t)); #else return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(EnumEqualityComparer <int>), t)); #endif case TypeCode.Int64: case TypeCode.UInt64: #if MONO return((EqualityComparer <T>)RuntimeType.CreateInstanceForAnotherGenericParameter(typeof(LongEnumEqualityComparer <>), t)); #else return((EqualityComparer <T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(LongEnumEqualityComparer <long>), t)); #endif } } // Otherwise return an ObjectEqualityComparer<T> return(new ObjectEqualityComparer <T>()); }