Esempio n. 1
0
        // Token: 0x0600177B RID: 6011 RVA: 0x0006F0E0 File Offset: 0x0006D2E0
        public static void GetDictionaryKeyValueTypes(Type dictionaryType, out Type keyType, out Type valueType)
        {
            Class_517.ArgumentNotNull(dictionaryType, "type");
            Type type;

            if (Class_514.ImplementsGenericDefinition(dictionaryType, typeof(IDictionary <, >), out type))
            {
                if (type.IsGenericTypeDefinition)
                {
                    throw new Exception("Type {0} is not a dictionary.".FormatWith(CultureInfo.InvariantCulture, 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, dictionaryType));
            }
        }
Esempio n. 2
0
        // Token: 0x06001784 RID: 6020 RVA: 0x0006F5E8 File Offset: 0x0006D7E8
        private static bool IsOverridenGenericMember(MemberInfo memberInfo, BindingFlags bindingAttr)
        {
            if (memberInfo.MemberType != MemberTypes.Property)
            {
                return(false);
            }
            PropertyInfo propertyInfo = (PropertyInfo)memberInfo;

            if (!propertyInfo.IsVirtual())
            {
                return(false);
            }
            Type declaringType = propertyInfo.DeclaringType;

            if (!declaringType.IsGenericType)
            {
                return(false);
            }
            Type genericTypeDefinition = declaringType.GetGenericTypeDefinition();

            if (genericTypeDefinition == null)
            {
                return(false);
            }
            MemberInfo[] member = genericTypeDefinition.GetMember(propertyInfo.Name, bindingAttr);
            if (member.Length == 0)
            {
                return(false);
            }
            Type memberUnderlyingType = Class_514.GetMemberUnderlyingType(member[0]);

            return(memberUnderlyingType.IsGenericParameter);
        }
Esempio n. 3
0
        // Token: 0x0600177D RID: 6013 RVA: 0x0006F204 File Offset: 0x0006D404
        public static bool IsIndexedProperty(MemberInfo member)
        {
            Class_517.ArgumentNotNull(member, "member");
            PropertyInfo propertyInfo = member as PropertyInfo;

            return(propertyInfo != null && Class_514.IsIndexedProperty(propertyInfo));
        }
Esempio n. 4
0
        // Token: 0x0600176C RID: 5996 RVA: 0x0006EC6C File Offset: 0x0006CE6C
        public static string GetTypeName(Type t, FormatterAssemblyStyle assemblyFormat, SerializationBinder binder)
        {
            string text2;

            if (binder != null)
            {
                string text;
                string str;
                binder.BindToName(t, out text, out str);
                text2 = str + ((text == null) ? "" : (", " + text));
            }
            else
            {
                text2 = t.AssemblyQualifiedName;
            }
            switch (assemblyFormat)
            {
            case FormatterAssemblyStyle.Simple:
                return(Class_514.RemoveAssemblyDetails(text2));

            case FormatterAssemblyStyle.Full:
                return(text2);

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Esempio n. 5
0
        // Token: 0x060016AE RID: 5806 RVA: 0x0006AC24 File Offset: 0x00068E24
        public static Class_496 GetTypeCode(Type t, out bool isEnum)
        {
            Class_496 result;

            if (Class_499.TypeCodeMap.TryGetValue(t, out result))
            {
                isEnum = false;
                return(result);
            }
            if (t.IsEnum)
            {
                isEnum = true;
                return(Class_499.GetTypeCode(Enum.GetUnderlyingType(t)));
            }
            if (Class_514.IsNullableType(t))
            {
                Type underlyingType = Nullable.GetUnderlyingType(t);
                if (underlyingType.IsEnum)
                {
                    Type t2 = typeof(Nullable <>).MakeGenericType(new Type[]
                    {
                        Enum.GetUnderlyingType(underlyingType)
                    });
                    isEnum = true;
                    return(Class_499.GetTypeCode(t2));
                }
            }
            isEnum = false;
            return(Class_496.Object);
        }
Esempio n. 6
0
        // Token: 0x0600177A RID: 6010 RVA: 0x0006F044 File Offset: 0x0006D244
        public static Type GetCollectionItemType(Type type)
        {
            Class_517.ArgumentNotNull(type, "type");
            if (type.IsArray)
            {
                return(type.GetElementType());
            }
            Type type2;

            if (Class_514.ImplementsGenericDefinition(type, typeof(IEnumerable <>), out type2))
            {
                if (type2.IsGenericTypeDefinition)
                {
                    throw new Exception("Type {0} is not a collection.".FormatWith(CultureInfo.InvariantCulture, 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, type));
            }
        }
Esempio n. 7
0
 // Token: 0x06001773 RID: 6003 RVA: 0x0006EE5A File Offset: 0x0006D05A
 public static Type EnsureNotNullableType(Type t)
 {
     if (!Class_514.IsNullableType(t))
     {
         return(t);
     }
     return(Nullable.GetUnderlyingType(t));
 }
Esempio n. 8
0
        // Token: 0x0600178C RID: 6028 RVA: 0x0006F9A0 File Offset: 0x0006DBA0
        public static IEnumerable <FieldInfo> GetFields(Type targetType, BindingFlags bindingAttr)
        {
            Class_517.ArgumentNotNull(targetType, "targetType");
            List <MemberInfo> list = new List <MemberInfo>(targetType.GetFields(bindingAttr));

            Class_514.GetChildPrivateFields(list, targetType, bindingAttr);
            return(list.Cast <FieldInfo>());
        }
Esempio n. 9
0
 // Token: 0x06001786 RID: 6022 RVA: 0x0006F680 File Offset: 0x0006D880
 public static T GetAttribute <T>(object attributeProvider, bool inherit) where T : Attribute
 {
     T[] attributes = Class_514.GetAttributes <T>(attributeProvider, inherit);
     if (attributes == null)
     {
         return(default(T));
     }
     return(attributes.FirstOrDefault <T>());
 }
Esempio n. 10
0
 // Token: 0x06001787 RID: 6023 RVA: 0x0006F6AC File Offset: 0x0006D8AC
 public static T[] GetAttributes <T>(object attributeProvider, bool inherit) where T : Attribute
 {
     Attribute[] attributes = Class_514.GetAttributes(attributeProvider, typeof(T), inherit);
     T[]         array      = attributes as T[];
     if (array != null)
     {
         return(array);
     }
     return(attributes.Cast <T>().ToArray <T>());
 }
Esempio n. 11
0
 // Token: 0x06001778 RID: 6008 RVA: 0x0006EF98 File Offset: 0x0006D198
 public static bool InheritsGenericDefinition(Type type, Type genericClassDefinition, out Type implementingType)
 {
     Class_517.ArgumentNotNull(type, "type");
     Class_517.ArgumentNotNull(genericClassDefinition, "genericClassDefinition");
     if (!genericClassDefinition.IsClass || !genericClassDefinition.IsGenericTypeDefinition)
     {
         throw new ArgumentNullException("'{0}' is not a generic class definition.".FormatWith(CultureInfo.InvariantCulture, genericClassDefinition));
     }
     return(Class_514.InheritsGenericDefinitionInternal(type, genericClassDefinition, out implementingType));
 }
Esempio n. 12
0
        // Token: 0x06001668 RID: 5736 RVA: 0x0006A3D8 File Offset: 0x000685D8
        public virtual Func <T> kmethod_4047 <T>(Type arg_0)
        {
            Class_488 <T> .NClass_2 nclass_ = new Class_488 <T> .NClass_2();

            nclass_.type = arg_0;
            Class_517.ArgumentNotNull(nclass_.type, "type");
            if (nclass_.type.IsValueType)
            {
                return(new Func <T>(nclass_.< CreateDefaultConstructor > b__7));
            }
            nclass_.constructorInfo = Class_514.GetDefaultConstructor(nclass_.type, true);
            return(new Func <T>(nclass_.< CreateDefaultConstructor > b__8));
        }
Esempio n. 13
0
        // Token: 0x06001789 RID: 6025 RVA: 0x0006F83C File Offset: 0x0006DA3C
        public static void SplitFullyQualifiedTypeName(string fullyQualifiedTypeName, out string typeName, out string assemblyName)
        {
            int?assemblyDelimiterIndex = Class_514.GetAssemblyDelimiterIndex(fullyQualifiedTypeName);

            if (assemblyDelimiterIndex != null)
            {
                typeName     = fullyQualifiedTypeName.Substring(0, assemblyDelimiterIndex.Value).Trim();
                assemblyName = fullyQualifiedTypeName.Substring(assemblyDelimiterIndex.Value + 1, fullyQualifiedTypeName.Length - assemblyDelimiterIndex.Value - 1).Trim();
                return;
            }
            typeName     = fullyQualifiedTypeName;
            assemblyName = null;
        }
Esempio n. 14
0
        // Token: 0x0600178E RID: 6030 RVA: 0x0006FA44 File Offset: 0x0006DC44
        public static IEnumerable <PropertyInfo> GetProperties(Type targetType, BindingFlags bindingAttr)
        {
            Class_517.ArgumentNotNull(targetType, "targetType");
            List <PropertyInfo> list = new List <PropertyInfo>(targetType.GetProperties(bindingAttr));

            Class_514.GetChildPrivateProperties(list, targetType, bindingAttr);
            for (int i = 0; i < list.Count; i++)
            {
                PropertyInfo propertyInfo = list[i];
                if (propertyInfo.DeclaringType != targetType)
                {
                    PropertyInfo value = (PropertyInfo)Class_514.GetMemberInfoFromType(propertyInfo.DeclaringType, propertyInfo);
                    list[i] = value;
                }
            }
            return(list);
        }
Esempio n. 15
0
        // Token: 0x060016B8 RID: 5816 RVA: 0x0006B364 File Offset: 0x00069564
        public static object ConvertOrCast(object initialValue, CultureInfo culture, Type targetType)
        {
            if (targetType == typeof(object))
            {
                return(initialValue);
            }
            if (initialValue == null && Class_514.IsNullable(targetType))
            {
                return(null);
            }
            object result;

            if (Class_499.TryConvert(initialValue, culture, targetType, out result))
            {
                return(result);
            }
            return(Class_499.EnsureTypeAssignable(initialValue, Class_514.GetObjectType(initialValue), targetType));
        }
Esempio n. 16
0
 // Token: 0x06001779 RID: 6009 RVA: 0x0006EFF0 File Offset: 0x0006D1F0
 private static bool InheritsGenericDefinitionInternal(Type currentType, Type genericClassDefinition, out Type implementingType)
 {
     if (currentType.IsGenericType)
     {
         Type genericTypeDefinition = currentType.GetGenericTypeDefinition();
         if (genericClassDefinition == genericTypeDefinition)
         {
             implementingType = currentType;
             return(true);
         }
     }
     if (currentType.BaseType == null)
     {
         implementingType = null;
         return(false);
     }
     return(Class_514.InheritsGenericDefinitionInternal(currentType.BaseType, genericClassDefinition, out implementingType));
 }
Esempio n. 17
0
 // Token: 0x06001790 RID: 6032 RVA: 0x0006FACC File Offset: 0x0006DCCC
 private static void GetChildPrivateProperties(IList <PropertyInfo> initialProperties, Type targetType, BindingFlags bindingAttr)
 {
     while ((targetType = targetType.BaseType) != null)
     {
         PropertyInfo[] properties = targetType.GetProperties(bindingAttr);
         for (int i = 0; i < properties.Length; i++)
         {
             PropertyInfo subTypeProperty2 = properties[i];
             PropertyInfo subTypeProperty  = subTypeProperty2;
             if (!Class_514.IsPublic(subTypeProperty))
             {
                 int num = initialProperties.IndexOf((PropertyInfo p) => p.Name == subTypeProperty.Name);
                 if (num == -1)
                 {
                     initialProperties.Add(subTypeProperty);
                 }
                 else
                 {
                     PropertyInfo property = initialProperties[num];
                     if (!Class_514.IsPublic(property))
                     {
                         initialProperties[num] = subTypeProperty;
                     }
                 }
             }
             else if (!subTypeProperty.IsVirtual())
             {
                 int num2 = initialProperties.IndexOf((PropertyInfo p) => p.Name == subTypeProperty.Name && p.DeclaringType == subTypeProperty.DeclaringType);
                 if (num2 == -1)
                 {
                     initialProperties.Add(subTypeProperty);
                 }
             }
             else
             {
                 int num3 = initialProperties.IndexOf((PropertyInfo p) => p.Name == subTypeProperty.Name && p.IsVirtual() && p.GetBaseDefinition() != null && p.GetBaseDefinition().DeclaringType.IsAssignableFrom(subTypeProperty.DeclaringType));
                 if (num3 == -1)
                 {
                     initialProperties.Add(subTypeProperty);
                 }
             }
         }
     }
 }
Esempio n. 18
0
        // Token: 0x060016B9 RID: 5817 RVA: 0x0006B3BC File Offset: 0x000695BC
        private static object EnsureTypeAssignable(object value, Type initialType, Type targetType)
        {
            Type type = (value != null) ? value.GetType() : null;

            if (value != null)
            {
                if (targetType.IsAssignableFrom(type))
                {
                    return(value);
                }
                Func <object, object> func = Class_499.CastConverters.Get(new Class_499.TypeConvertKey(type, targetType));
                if (func != null)
                {
                    return(func(value));
                }
            }
            else if (Class_514.IsNullable(targetType))
            {
                return(null);
            }
            throw new ArgumentException("Could not cast or convert from {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, (initialType != null) ? initialType.ToString() : "{null}", targetType));
        }
Esempio n. 19
0
        // Token: 0x06001783 RID: 6019 RVA: 0x0006F488 File Offset: 0x0006D688
        public static List <MemberInfo> GetFieldsAndProperties(Type type, BindingFlags bindingAttr)
        {
            List <MemberInfo> list = new List <MemberInfo>();

            list.AddRange(Class_514.GetFields(type, bindingAttr));
            list.AddRange(Class_514.GetProperties(type, bindingAttr));
            List <MemberInfo> list2 = new List <MemberInfo>(list.Count);

            foreach (IGrouping <string, MemberInfo> source in from m in list
                     group m by m.Name)
            {
                int num = source.Count <MemberInfo>();
                IList <MemberInfo> list3 = source.ToList <MemberInfo>();
                if (num == 1)
                {
                    list2.Add(list3.First <MemberInfo>());
                }
                else
                {
                    IList <MemberInfo> list4 = new List <MemberInfo>();
                    foreach (MemberInfo memberInfo in list3)
                    {
                        if (list4.Count == 0)
                        {
                            list4.Add(memberInfo);
                        }
                        else if (!Class_514.IsOverridenGenericMember(memberInfo, bindingAttr) || memberInfo.Name == "Item")
                        {
                            list4.Add(memberInfo);
                        }
                    }
                    list2.AddRange(list4);
                }
            }
            return(list2);
        }
Esempio n. 20
0
        // Token: 0x060016B7 RID: 5815 RVA: 0x0006B054 File Offset: 0x00069254
        private static Class_499.ConvertResult TryConvertInternal(object initialValue, CultureInfo culture, Type targetType, out object value)
        {
            if (initialValue == null)
            {
                throw new ArgumentNullException("initialValue");
            }
            if (Class_514.IsNullableType(targetType))
            {
                targetType = Nullable.GetUnderlyingType(targetType);
            }
            Type type = initialValue.GetType();

            if (targetType == type)
            {
                value = initialValue;
                return(Class_499.ConvertResult.Success);
            }
            if (Class_499.IsConvertible(initialValue.GetType()) && Class_499.IsConvertible(targetType))
            {
                if (targetType.IsEnum)
                {
                    if (initialValue is string)
                    {
                        value = Enum.Parse(targetType, initialValue.ToString(), true);
                        return(Class_499.ConvertResult.Success);
                    }
                    if (Class_499.IsInteger(initialValue))
                    {
                        value = Enum.ToObject(targetType, initialValue);
                        return(Class_499.ConvertResult.Success);
                    }
                }
                value = System.Convert.ChangeType(initialValue, targetType, culture);
                return(Class_499.ConvertResult.Success);
            }
            if (initialValue is DateTime && targetType == typeof(DateTimeOffset))
            {
                value = new DateTimeOffset((DateTime)initialValue);
                return(Class_499.ConvertResult.Success);
            }
            if (initialValue is byte[] && targetType == typeof(Guid))
            {
                value = new Guid((byte[])initialValue);
                return(Class_499.ConvertResult.Success);
            }
            if (initialValue is Guid && targetType == typeof(byte[]))
            {
                value = ((Guid)initialValue).ToByteArray();
                return(Class_499.ConvertResult.Success);
            }
            if (initialValue is string)
            {
                if (targetType == typeof(Guid))
                {
                    value = new Guid((string)initialValue);
                    return(Class_499.ConvertResult.Success);
                }
                if (targetType == typeof(Uri))
                {
                    value = new Uri((string)initialValue, UriKind.RelativeOrAbsolute);
                    return(Class_499.ConvertResult.Success);
                }
                if (targetType == typeof(TimeSpan))
                {
                    value = Class_499.ParseTimeSpan((string)initialValue);
                    return(Class_499.ConvertResult.Success);
                }
                if (targetType == typeof(byte[]))
                {
                    value = System.Convert.FromBase64String((string)initialValue);
                    return(Class_499.ConvertResult.Success);
                }
                if (typeof(Type).IsAssignableFrom(targetType))
                {
                    value = Type.GetType((string)initialValue, true);
                    return(Class_499.ConvertResult.Success);
                }
            }
            if (targetType == typeof(BigInteger))
            {
                value = Class_499.ToBigInteger(initialValue);
                return(Class_499.ConvertResult.Success);
            }
            if (initialValue is BigInteger)
            {
                value = Class_499.FromBigInteger((BigInteger)initialValue, targetType);
                return(Class_499.ConvertResult.Success);
            }
            TypeConverter typeConverter = Class_470.GetTypeConverter(type);

            if (typeConverter != null && typeConverter.CanConvertTo(targetType))
            {
                value = typeConverter.ConvertTo(null, culture, initialValue, targetType);
                return(Class_499.ConvertResult.Success);
            }
            TypeConverter typeConverter2 = Class_470.GetTypeConverter(targetType);

            if (typeConverter2 != null && typeConverter2.CanConvertFrom(type))
            {
                value = typeConverter2.ConvertFrom(null, culture, initialValue);
                return(Class_499.ConvertResult.Success);
            }
            if (initialValue == DBNull.Value)
            {
                if (Class_514.IsNullable(targetType))
                {
                    value = Class_499.EnsureTypeAssignable(null, type, targetType);
                    return(Class_499.ConvertResult.Success);
                }
                value = null;
                return(Class_499.ConvertResult.CannotConvertNull);
            }
            else
            {
                if (initialValue is INullable)
                {
                    value = Class_499.EnsureTypeAssignable(Class_499.ToValue((INullable)initialValue), type, targetType);
                    return(Class_499.ConvertResult.Success);
                }
                if (targetType.IsInterface || targetType.IsGenericTypeDefinition || targetType.IsAbstract)
                {
                    value = null;
                    return(Class_499.ConvertResult.NotInstantiableType);
                }
                value = null;
                return(Class_499.ConvertResult.NoValidConversion);
            }
        }
Esempio n. 21
0
        // Token: 0x06001775 RID: 6005 RVA: 0x0006EE98 File Offset: 0x0006D098
        public static bool ImplementsGenericDefinition(Type type, Type genericInterfaceDefinition)
        {
            Type type2;

            return(Class_514.ImplementsGenericDefinition(type, genericInterfaceDefinition, out type2));
        }
Esempio n. 22
0
 // Token: 0x06001785 RID: 6021 RVA: 0x0006F676 File Offset: 0x0006D876
 public static T GetAttribute <T>(object attributeProvider) where T : Attribute
 {
     return(Class_514.GetAttribute <T>(attributeProvider, true));
 }
Esempio n. 23
0
 // Token: 0x0600176E RID: 5998 RVA: 0x0006ED91 File Offset: 0x0006CF91
 public static bool HasDefaultConstructor(Type t, bool nonPublic)
 {
     Class_517.ArgumentNotNull(t, "t");
     return(t.IsValueType || Class_514.GetDefaultConstructor(t, nonPublic) != null);
 }
Esempio n. 24
0
 // Token: 0x0600176F RID: 5999 RVA: 0x0006EDB8 File Offset: 0x0006CFB8
 public static ConstructorInfo GetDefaultConstructor(Type t)
 {
     return(Class_514.GetDefaultConstructor(t, false));
 }
Esempio n. 25
0
 // Token: 0x06001771 RID: 6001 RVA: 0x0006EE0B File Offset: 0x0006D00B
 public static bool IsNullable(Type t)
 {
     Class_517.ArgumentNotNull(t, "t");
     return(!t.IsValueType || Class_514.IsNullableType(t));
 }
Esempio n. 26
0
 // Token: 0x060016E0 RID: 5856 RVA: 0x0006C110 File Offset: 0x0006A310
 private static bool pmethod_4099(object obje_0)
 {
     return(obje_0 is T || (obje_0 == null && (!typeof(T).IsValueType || Class_514.IsNullableType(typeof(T)))));
 }
Esempio n. 27
0
        // Token: 0x06001792 RID: 6034 RVA: 0x0006FC5C File Offset: 0x0006DE5C
        public static object GetDefaultValue(Type type)
        {
            if (!type.IsValueType)
            {
                return(null);
            }
            Class_496 typeCode = Class_499.GetTypeCode(type);

            switch (typeCode)
            {
            case Class_496.Char:
            case Class_496.SByte:
            case Class_496.Int16:
            case Class_496.UInt16:
            case Class_496.Int32:
            case Class_496.Byte:
            case Class_496.UInt32:
                return(0);

            case Class_496.CharNullable:
            case Class_496.BooleanNullable:
            case Class_496.SByteNullable:
            case Class_496.Int16Nullable:
            case Class_496.UInt16Nullable:
            case Class_496.Int32Nullable:
            case Class_496.ByteNullable:
            case Class_496.UInt32Nullable:
            case Class_496.Int64Nullable:
            case Class_496.UInt64Nullable:
            case Class_496.SingleNullable:
            case Class_496.DoubleNullable:
            case Class_496.DateTimeNullable:
            case Class_496.DateTimeOffsetNullable:
            case Class_496.DecimalNullable:
                break;

            case Class_496.Boolean:
                return(false);

            case Class_496.Int64:
            case Class_496.UInt64:
                return(0L);

            case Class_496.Single:
                return(0f);

            case Class_496.Double:
                return(0.0);

            case Class_496.DateTime:
                return(default(DateTime));

            case Class_496.DateTimeOffset:
                return(default(DateTimeOffset));

            case Class_496.Decimal:
                return(0m);

            case Class_496.Guid:
                return(default(Guid));

            default:
                if (typeCode == Class_496.BigInteger)
                {
                    return(default(BigInteger));
                }
                break;
            }
            if (Class_514.IsNullable(type))
            {
                return(null);
            }
            return(Activator.CreateInstance(type));
        }
Esempio n. 28
0
 // Token: 0x06001749 RID: 5961 RVA: 0x0006E264 File Offset: 0x0006C464
 public static bool IsDictionaryType(Type type)
 {
     Class_517.ArgumentNotNull(type, "type");
     return(typeof(IDictionary).IsAssignableFrom(type) || Class_514.ImplementsGenericDefinition(type, typeof(IDictionary <, >)));
 }
Esempio n. 29
0
        // Token: 0x06001693 RID: 5779 RVA: 0x0006A6A4 File Offset: 0x000688A4
        public static Class_491 dmethod_4066(Type arg_0, MethodBase arg_1, params string[] strDizi_0)
        {
            Class_491 class_ = new Class_491();
            Class_480 reflectionDelegateFactory = Class_470.ReflectionDelegateFactory;

            if (arg_1 != null)
            {
                class_.prop_0 = reflectionDelegateFactory.pmethod_4009(arg_1);
            }
            else if (Class_514.HasDefaultConstructor(arg_0, false))
            {
                Class_491.NClass_0 nclass_ = new Class_491.NClass_0();
                nclass_.field_3 = reflectionDelegateFactory.smethod_4010 <object>(arg_0);
                class_.prop_0   = new Class_482 <object>(nclass_.nmethod_1);
            }
            int i = 0;

            while (i < strDizi_0.Length)
            {
                string       text   = strDizi_0[i];
                MemberInfo[] member = arg_0.GetMember(text, BindingFlags.Instance | BindingFlags.Public);
                if (member.Length != 1)
                {
                    throw new ArgumentException("Expected a single member with the name '{0}'.".FormatWith(CultureInfo.InvariantCulture, text));
                }
                MemberInfo  memberInfo = member.Single <MemberInfo>();
                Class_490   class_2    = new Class_490();
                MemberTypes memberType = memberInfo.MemberType;
                if (memberType == MemberTypes.Field)
                {
                    goto IL_CE;
                }
                if (memberType != MemberTypes.Method)
                {
                    if (memberType == MemberTypes.Property)
                    {
                        goto IL_CE;
                    }
                    throw new ArgumentException("Unexpected member type '{0}' for member '{1}'.".FormatWith(CultureInfo.InvariantCulture, memberInfo.MemberType, memberInfo.Name));
                }
                else
                {
                    MethodInfo methodInfo = (MethodInfo)memberInfo;
                    if (methodInfo.IsPublic)
                    {
                        ParameterInfo[] parameters = methodInfo.GetParameters();
                        if (parameters.Length == 0 && methodInfo.ReturnType != typeof(void))
                        {
                            Class_491.NClass_1 nclass_2 = new Class_491.NClass_1();
                            nclass_2.field_4 = reflectionDelegateFactory.lmethod_4008 <object>(methodInfo);
                            class_2.prop_1   = new Func <object, object>(nclass_2.nmethod_3);
                        }
                        else if (parameters.Length == 1 && methodInfo.ReturnType == typeof(void))
                        {
                            Class_491.NClass_2 nclass_3 = new Class_491.NClass_2();
                            nclass_3.field_5 = reflectionDelegateFactory.lmethod_4008 <object>(methodInfo);
                            class_2.prop_2   = new Action <object, object>(nclass_3.nmethod_5);
                        }
                    }
                }
IL_1F9:
                if (Class_514.CanReadMemberValue(memberInfo, false))
                {
                    class_2.prop_1 = reflectionDelegateFactory.dmethod_4006 <object>(memberInfo);
                }
                if (Class_514.CanSetMemberValue(memberInfo, false, false))
                {
                    class_2.prop_2 = reflectionDelegateFactory.kmethod_4007 <object>(memberInfo);
                }
                class_2.prop_0      = Class_514.GetMemberUnderlyingType(memberInfo);
                class_.prop_1[text] = class_2;
                i++;
                continue;
IL_CE:
                if (Class_514.CanReadMemberValue(memberInfo, false))
                {
                    class_2.prop_1 = reflectionDelegateFactory.dmethod_4006 <object>(memberInfo);
                }
                if (Class_514.CanSetMemberValue(memberInfo, false, false))
                {
                    class_2.prop_2 = reflectionDelegateFactory.kmethod_4007 <object>(memberInfo);
                    goto IL_1F9;
                }
                goto IL_1F9;
            }
            return(class_);
        }
Esempio n. 30
0
        // Token: 0x06001777 RID: 6007 RVA: 0x0006EF80 File Offset: 0x0006D180
        public static bool InheritsGenericDefinition(Type type, Type genericClassDefinition)
        {
            Type type2;

            return(Class_514.InheritsGenericDefinition(type, genericClassDefinition, out type2));
        }