C# Type.IsSubclassOf方法代码示例

 internal static WriteJsonValue GetWriteJsonMethod(Type type)
 {
     var t = Reflection.GetJsonDataType (type);
     if (t == JsonDataType.Primitive) {
         return typeof (decimal).Equals (type) ? WriteDecimal
                 : typeof (byte).Equals (type) ? WriteByte
                 : typeof (sbyte).Equals (type) ? WriteSByte
                 : typeof (short).Equals (type) ? WriteInt16
                 : typeof (ushort).Equals (type) ? WriteUInt16
                 : typeof (uint).Equals (type) ? WriteUInt32
                 : typeof (ulong).Equals (type) ? WriteUInt64
                 : typeof (char).Equals (type) ? WriteChar
                 : (WriteJsonValue)WriteUnknown;
     }
     else if (t == JsonDataType.Undefined) {
         return type.IsSubclassOf (typeof (Array)) && type.GetArrayRank () > 1 ? WriteMultiDimensionalArray
             : type.IsSubclassOf (typeof (Array)) && typeof (byte[]).Equals (type) == false ? WriteArray
             : typeof (KeyValuePair<string,object>).Equals (type) ? WriteKeyObjectPair
             : typeof (KeyValuePair<string,string>).Equals (type) ? WriteKeyValuePair
             : (WriteJsonValue)WriteObject;
     }
     else {
         return _convertMethods[(int)t];
     }
 }

 private static bool IsEcommerceType(Type entityType)
 {
     return MrCMSApp.AllAppTypes.ContainsKey(entityType) &&
            MrCMSApp.AllAppTypes[entityType] == EcommerceApp.EcommerceAppName &&
            (!entityType.IsSubclassOf(typeof (Document)) &&
             !entityType.IsSubclassOf(typeof (UserProfileData)) && !entityType.IsSubclassOf(typeof (Widget)));
 }

        static ILockTest CreateTest( Type testType, Type lockType, object[] parameters )
        {
            if ( ! testType.IsSubclassOf(typeof(ILockTest)) )
            {
                throw new InvalidCastException("Test type must be derived from ILockTest");
            }

            if ( null != lockType )
            {
                if ( ! testType.IsSubclassOf(typeof(ISyncLock)) )
                {
                    throw new InvalidCastException("Lock type must be derived from ISyncLock");
                }
            }

            ISyncLock syncLock = (ISyncLock) CreateTypeInstance(lockType);

            if ( null == syncLock )
            {
                throw new ArgumentException("Unable to construct an ISyncLock instance with specified parameters");
            }

            ILockTest test = (ILockTest) CreateTypeInstance(testType, new object[] {syncLock});

            if ( null == test )
            {
                throw new ArgumentException("Unable to construct an ILockTest instance with specified ISyncLock");
            }

            return test;
        }

		public static BulkGenericType Classify( BODType deedType, Type itemType )
		{
			if ( deedType == BODType.Tailor )
			{
				if ( itemType == null || itemType.IsSubclassOf( typeof( BaseArmor ) ) || itemType.IsSubclassOf( typeof( BaseShoes ) ) )
					return BulkGenericType.Leather;

				return BulkGenericType.Cloth;
			}
			//else if ( deedType == BODType.Fletcher )
//////////////////////////////////
//  Cap & Fletch BOD Addon 2/2  //
//////////////////////////////////
            else if ( deedType == BODType.Fletcher )
			{
				if ( itemType == null || itemType.IsSubclassOf( typeof( BaseRanged ) ) )
					return BulkGenericType.Wood;

				return BulkGenericType.Wood;
			}
            else if ( deedType == BODType.Carpenter )
			{
				if ( itemType == null || itemType.IsSubclassOf( typeof( BaseStaff ) ) || itemType.IsSubclassOf( typeof( BaseShield ) ) )
					return BulkGenericType.Wood;

				return BulkGenericType.Wood;
			}
//////////////////////////////////
//  End of Edit            2/2  //
//////////////////////////////////
				//return BulkGenericType.Wood;

			return BulkGenericType.Iron;
		}

 public virtual ICauterizeTypeFormatter GetFormatter(Type t)
 {
     ICauterizeTypeFormatter formatter;
     if (t.IsSubclassOf(typeof (CauterizeComposite)))
     {
         formatter = new CauterizeCompositeFormatter(this);
     }
     else if (t.IsSubclassOf(typeof (CauterizeGroup)))
     {
         formatter = new CauterizeGroupFormatter(this);
     }
     else if (t.IsSubclassOf(typeof (CauterizeFixedArray)))
     {
         formatter = new CauterizeFixedArrayFormatter(this);
     }
     else if (t.IsSubclassOf(typeof (CauterizeVariableArray)))
     {
         formatter = new CauterizeVariableArrayFormatter(this);
     }
     else if (t.IsSubclassOf(typeof (Enum)))
     {
         formatter = new CauterizeEnumFormatter();
     }
     else
     {
         formatter = new CauterizePrimitiveFormatter();
     }
     return formatter;
 }

 static bool AssemblyPredicate( Type t )
 {
     return
         !t.IsAbstract &&
         t.IsSubclassOf( typeof(ScriptableObject) ) &&
         !t.IsSubclassOf( typeof(Editor) );
 }

		public override bool CanConvert(Type objectType)
		{
		    return objectType == typeof (RavenJToken) ||
		           objectType == typeof (DynamicJsonObject) ||
		           objectType == typeof (DynamicNullObject) ||
		           objectType.IsSubclassOf(typeof (RavenJToken)) ||
		           objectType.IsSubclassOf(typeof (DynamicJsonObject));
		}

 private static bool IsTypeCompatible(Type type)
 {
     if ((type == null) || (!type.IsSubclassOf(typeof(MonoBehaviour)) && !type.IsSubclassOf(typeof(ScriptableObject))))
     {
         return false;
     }
     return true;
 }

 public object GetService(Type serviceType)
 {
     return serviceType.IsSubclassOf(typeof (ControllerBase))
         ? Activator.CreateInstance(serviceType, new ServiceManager())
         : serviceType.IsSubclassOf(typeof (ApiController))
             ? Activator.CreateInstance(serviceType)
             : null;
 }

 public IBsonSerializer GetSerializer(Type type)
 {
     if (type == typeof(IGameObject) || type.IsSubclassOf(typeof(IGameObject)) || type.GetInterface(typeof(IGameObject).Name) != null)
         return new GameObjectSerializer();
     if (type == typeof(IDataObject) || type.IsSubclassOf(typeof(IDataObject)) || type.GetInterface(typeof(IDataObject).Name) != null)
         return new DataObjectSerializer<IDataObject>();
     return null;
 }

        protected void BuildPropertySet(Type p, StringCollection propertySet)
        {
            if (TypeToLdapPropListMap[this.MappingTableIndex].ContainsKey(p))
            {
                Debug.Assert(TypeToLdapPropListMap[this.MappingTableIndex].ContainsKey(p));
                string[] props = new string[TypeToLdapPropListMap[this.MappingTableIndex][p].Count];
                TypeToLdapPropListMap[this.MappingTableIndex][p].CopyTo(props, 0);
                propertySet.AddRange(props);
            }
            else
            {
                Type baseType;

                if (p.IsSubclassOf(typeof(UserPrincipal)))
                {
                    baseType = typeof(UserPrincipal);
                }
                else if (p.IsSubclassOf(typeof(GroupPrincipal)))
                {
                    baseType = typeof(GroupPrincipal);
                }
                else if (p.IsSubclassOf(typeof(ComputerPrincipal)))
                {
                    baseType = typeof(ComputerPrincipal);
                }
                else if (p.IsSubclassOf(typeof(AuthenticablePrincipal)))
                {
                    baseType = typeof(AuthenticablePrincipal);
                }
                else
                {
                    baseType = typeof(Principal);
                }

                Hashtable propertyList = new Hashtable();

                // Load the properties for the base types...
                foreach (string s in TypeToLdapPropListMap[this.MappingTableIndex][baseType])
                {
                    if (!propertyList.Contains(s))
                    {
                        propertyList.Add(s, s);
                    }
                }

                // Reflect the properties off the extension class and add them to the list.                
                BuildExtensionPropertyList(propertyList, p);

                foreach (string property in propertyList.Values)
                {
                    propertySet.Add(property);
                }

                // Cache the list for this property type so we don't need to reflect again in the future.                                
                this.AddPropertySetToTypePropListMap(p, propertySet);
            }
        }

        public override bool IsDiscriminated(Type type)
        {
            //return true;
            if (type.IsSubclassOf(typeof(BillingTransaction)) || type.IsSubclassOf(typeof(AccountMeta)))
            {
                return true;
            }

            return false;
        }

        //TODO: If placed in your domain, uncomment and replace MyDbContext with your domain's DbContext/ObjectContext class.
        //public UniqueAttribute() : this(typeof(MyDbContext)) { }
        /// <summary>
        /// Initializes a new instance of <see cref="UniqueAttribute"/>.
        /// </summary>
        /// <param name="contextType">The type of <see cref="DbContext"/> or <see cref="ObjectContext"/> subclass that will be used to search for duplicates.</param>
        public UniqueAttribute(Type contextType)
        {
            if (contextType == null)
                throw new ArgumentNullException("contextType");
            if (!contextType.IsSubclassOf(typeof(DbContext)) && !contextType.IsSubclassOf(typeof(ObjectContext)))
                throw new ArgumentException("The contextType Type must be a subclass of DbContext or ObjectContext.", "contextType");
            if (contextType.GetConstructor(Type.EmptyTypes) == null)
                throw new ArgumentException("The contextType type must declare a public parameterless consructor.");

            _ContextType = contextType;
        }

		public static BulkGenericType Classify( BODType deedType, Type itemType )
		{
			if ( deedType == BODType.Tailor )
			{
				if ( itemType == null || itemType.IsSubclassOf( typeof( BaseArmor ) ) || itemType.IsSubclassOf( typeof( BaseShoes ) ) )
					return BulkGenericType.Leather;

				return BulkGenericType.Cloth;
			}

			return BulkGenericType.Iron;
		}

        protected override void GenerateCodeFor(Type type)
        {
            var codeNamespace = GetNamespace(type);

            Action<Action<Type>> run = action =>
            {
                AppendUsings(UsingNamespaces);
                sb.AppendLine();

                cw.Indented("namespace ");
                sb.AppendLine(codeNamespace);
                cw.InBrace(delegate {
                    action(type);
                });
            };

            if (type.GetIsEnum())
                run(GenerateEnum);
            else if (type.IsSubclassOf(typeof(Controller)))
                run(GenerateService);
            else
            {
                var formScriptAttr = type.GetCustomAttribute<FormScriptAttribute>();
                if (formScriptAttr != null)
                {
                    run(t => GenerateForm(t, formScriptAttr));
                    EnqueueTypeMembers(type);

                    if (type.IsSubclassOf(typeof(ServiceRequest)))
                    {
                        AddFile(RemoveRootNamespace(codeNamespace,
                            this.fileIdentifier + (IsTS() ? ".ts" : ".cs")));

                        this.fileIdentifier = type.Name;
                        run(GenerateBasicType);
                    }

                    return;
                }
                else if (type.GetCustomAttribute<ColumnsScriptAttribute>() != null)
                {
                    //GenerateColumns(type);
                    run(EnqueueTypeMembers);
                    return;
                }
                else
                    run(GenerateBasicType);
            }
        }