C# Object.GetType方法代码示例

 public new void DestroyObject(Object target)
 {
     if (target.GetType() == typeof(Transform))
         ObjectPooler.Deposit(((Transform)target).gameObject);
     else if (target.GetType() == typeof(GameObject))
         ObjectPooler.Deposit((GameObject)target);
     else
         Destroy(target);
 }

		public override void OnGUI (Rect position, SerializedProperty property, GUIContent label) {
			battribute = attribute as ButtonAttribute;
			obj = property.serializedObject.targetObject;
			MethodInfo method = obj.GetType().GetMethod(battribute.methodName, battribute.flags);
			
			if (method == null) {
				EditorGUI.HelpBox(position, "Method Not Found", MessageType.Error);
				
			} else {
				if (battribute.useValue) {
					valueRect = new Rect(position.x, position.y, position.width/2f, position.height);
					buttonRect = new Rect(position.x + position.width/2f, position.y, position.width/2f, position.height);
					
					EditorGUI.PropertyField(valueRect, property, GUIContent.none);
					if (GUI.Button(buttonRect, battribute.buttonName)) {
						method.Invoke(obj, new object[]{fieldInfo.GetValue(obj)});
					}
					
				} else {
					if (GUI.Button(position, battribute.buttonName)) {
						method.Invoke(obj, null);
					}
				}
			}
		}

 public static void ScreenShotComponent(Rect contentRect, Object target)
 {
   ScreenShots.s_TakeComponentScreenshot = false;
   contentRect.yMax += 2f;
   ++contentRect.xMin;
   ScreenShots.SaveScreenShotWithBorder(contentRect, ScreenShots.kWindowBorderColor, target.GetType().Name + "Inspector");
 }

        public override void OnXGUI()
        {
            DoButton( "OpenMonoScript", OpenMonoScript );

            DoButton( "Clear", () => ScriptFile = null );

            ScriptFile = CreateObjectField( ScriptFile );

            flags = (BindingFlags)CreateEnumPopup( "BindingFlags", flags );

            if( null != ScriptFile ) {

                Type scriptType = ScriptFile.GetType();

                CreateLabel( "Fields" );
                if( scriptType == typeof( MonoScript ) ) {
                    scriptType = ( ScriptFile as MonoScript ).GetClass();
                }
                ShowMemberInfo( scriptType.GetFields( flags ) );

                CreateLabel( "Properties" );
                ShowMemberInfo( scriptType.GetProperties( flags ) );

                CreateLabel( "Members" );
                ShowMemberInfo( scriptType.GetMembers( flags ) );
            }
        }

 public static void AddInputListener(Object c)
 {
     foreach (var elem in c.GetType().GetFields()) {
         if (elem.FieldType==typeof (key))
             AddInput((key) elem.GetValue(c), elem.Name);
         else if (elem.FieldType==typeof (axis))
             AddInput((axis) elem.GetValue(c), elem.Name);
     }
 }

 public void Init(Object targetObject)
 {
     this.targetObject = targetObject;
     methods = targetObject.GetType().GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Where(m =>
      m.GetCustomAttributes(typeof(ButtonAttribute), false).Length == 1 &&
      m.GetParameters().Length == 0 &&
      !m.ContainsGenericParameters
     ).ToList();
 }

 public void SetSelectedStructure(Object asset)
 {
     if(asset != null && asset.GetType() == typeof(TileStructureScriptableObject))
     {
         tileStructureScriptableObject = (TileStructureScriptableObject)asset;
     }
     else
     {
         tileStructureScriptableObject = null;
     }
 }

			public void PrintObject(Object o, int recursionDepth = 0) {
				var asComponent = o as Component;
				var asGameObject = o as GameObject;
				if (asComponent == null && asGameObject == null) {
					_writer.WriteLine("{0} : {1}", o.GetType(), o.name);
					_writer.Indent++;
					PrintObjectMembers(o);
					_writer.Indent--;
					return;
				}
				if (asComponent != null) {
					asGameObject = asComponent.gameObject;
				}
				PrintUnityGameObject(asGameObject, recursionDepth);
			}

        public static void ShowInspectorForSerializedObject(UnityObject target)
        {
            DrawOpenScriptButton(target);

            // Run the editor
            BehaviorEditor.Get(target.GetType()).EditWithGUILayout(target);

            // Inspector for the serialized state
            var inspectedObject = target as ISerializedObject;
            if (inspectedObject != null) {
                EditorGUI.BeginChangeCheck();
                DrawSerializedState(inspectedObject);
                if (EditorGUI.EndChangeCheck()) {
                    EditorUtility.SetDirty(target);
                    inspectedObject.RestoreState();
                }
            }
        }

        private IEnumerator OnTargetAssetChanged( Object asset )
        {
            string assetPath = AssetDatabase.GetAssetPath( asset );
            EditorSupport.ESUtility.CurRootPath = assetPath.Substring( 0, assetPath.IndexOf( "/res/", StringComparison.Ordinal ) + 1 );//+1是为了把"/"包含进去
            if( asset is ScriptableObject ){
                Type editorType = Utility.GetCustomEditor( asset.GetType() );
                BaseEditor_ = Editor.CreateEditor( asset, editorType ) as BaseEditor;
                if( BaseEditor_ ){
                    RawAsset_ = asset;
                    BaseEditor_.RawAsset = asset;
                }
                else{
                    LastError_ = "不是自定义格式的资源:" + assetPath;
                }
            }
            else{
                EditorWww www = EditorWww.Create( assetPath );
                while ( !www.Finished ) {
                    yield return null;
                }
                var scriptableObj = www.GetAsset() as ScriptableObject;
                www.Unload();
                if ( !scriptableObj ){
                    LastError_ = "无法识别的资源: " + assetPath;
                    yield break;
                }

                Type editorType = Utility.GetCustomEditor( scriptableObj.GetType() );
                if ( editorType == null || editorType.BaseType != typeof( BaseEditor ) ) {
                    LastError_ = "没有找到对应的编辑器: " + scriptableObj.GetType();
                }
                else {
                    ScriptableObject tempObj = CreateInstance( scriptableObj.GetType() );
                    EditorUtility.CopySerialized( scriptableObj, tempObj );
                    string filePath = Path.ChangeExtension( assetPath, PalmPoineer.Defines.AssetExt.UnityAsset );
                    AssetDatabase.CreateAsset( tempObj, filePath );
                    RawAsset_ = tempObj;
                    BaseEditor_ = Editor.CreateEditor( tempObj, editorType ) as BaseEditor;
                    BaseEditor_.RawAsset = tempObj;
                }
            }
        }

 private IEnumerator OnTargetAssetChanged(Object asset)
 {
     string assetPath = AssetDatabase.GetAssetPath(asset);
     //Debug.Log("OnTargetAssetChanged(), assetPath : " + assetPath);
     EditorSupport.ESUtility.CurRootPath = assetPath.Substring(0, assetPath.IndexOf("/res/", StringComparison.Ordinal) + 1);//+1是为了把"/"包含进去
     //Debug.Log("OnTargetAssetChanged(), CurRootPath : " + EditorSupport.ESUtility.CurRootPath);
     if (asset is ScriptableObject) {
         Type editorType = Utility.GetCustomEditor(asset.GetType());
         BaseEditor_ = Editor.CreateEditor(asset, editorType) as BaseEditor;
         if (BaseEditor_) {
             ObjFieldShow_ = asset;
             BaseEditor_.RawAsset = asset;
         }
         else {
             LastError_ = "不是自定义格式的资源:" + assetPath;
         }
     }
     else {
         yield return null;
     }
 }

        static EditorTools()
        {
            System.Type internalEditorUtilityType = typeof(InternalEditorUtility);

            sortingLayersProperty = internalEditorUtilityType.GetProperty("sortingLayerNames", BindingFlags.Static | BindingFlags.NonPublic);
            sortingLayerUniqueIDsProperty = internalEditorUtilityType.GetProperty("sortingLayerUniqueIDs", BindingFlags.Static | BindingFlags.NonPublic);
            getSortingLayerCountMethod = internalEditorUtilityType.GetMethod( "GetSortingLayerCount",BindingFlags.Static | BindingFlags.NonPublic );
            #if UNITY_5
            getSortingLayerUniqueIDMethod = internalEditorUtilityType.GetMethod( "GetSortingLayerUniqueID",BindingFlags.Static | BindingFlags.NonPublic );
            #else
            getSortingLayerUserIDMethod = internalEditorUtilityType.GetMethod( "GetSortingLayerUserID",BindingFlags.Static | BindingFlags.NonPublic );
            #endif
            getSortingLayerNameFromUniqueIDMethod = internalEditorUtilityType.GetMethod( "GetSortingLayerNameFromUniqueID",BindingFlags.Static | BindingFlags.NonPublic );
            getSortingLayerNameMethod = internalEditorUtilityType.GetMethod( "GetSortingLayerName",BindingFlags.Static | BindingFlags.NonPublic );

            System.Type editorApplicationType = typeof(EditorApplication);

            PropertyInfo tagManagerProperty = editorApplicationType.GetProperty( "tagManager",BindingFlags.Static | BindingFlags.NonPublic);

            tagManager = (Object)tagManagerProperty.GetValue( null,new object[0] );

            defaultExpandedFoldoutField = tagManager.GetType().GetField( "m_DefaultExpandedFoldout" );
        }

        private static ObjectType GetObjectType(Object activeObject)
        {
            if (activeObject == null) return ObjectType.None;

            if (activeObject is GameObject)
            {
				if (Instance._breadcrumbs != null)
					if (activeObject == Instance._breadcrumbs.gameObject) return ObjectType.InspectorBreadcrumbs;

                PrefabType pt = PrefabUtility.GetPrefabType((GameObject)activeObject);
                if (pt == PrefabType.None || pt == PrefabType.DisconnectedModelPrefabInstance || pt == PrefabType.DisconnectedPrefabInstance ||
                    pt == PrefabType.MissingPrefabInstance || pt == PrefabType.ModelPrefabInstance || pt == PrefabType.PrefabInstance) 
                    return ObjectType.Instance;
            }

            if (activeObject as UnityEngine.TextAsset != null)
                return ObjectType.TextAssets;
            
            if (activeObject.ToString().Contains("UnityEngine.SceneAsset"))
                return ObjectType.Scene;

            var asset_path = AssetDatabase.GetAssetPath(activeObject);
            if (string.IsNullOrEmpty(asset_path))
            {
                if (activeObject.GetType().ToString().Contains("AssetStoreAssetInspector"))
                    return ObjectType.AssetStoreAssetInspector;
                else
                    return ObjectType.Asset;
            }
            if (asset_path.StartsWith("ProjectSettings/")) return ObjectType.ProjectSettings;
                
            try
            {
                System.IO.FileAttributes file_attr = System.IO.File.GetAttributes(Application.dataPath + "/" + asset_path.Replace("Assets/", ""));
                if ((file_attr & System.IO.FileAttributes.Directory) == System.IO.FileAttributes.Directory)
                    return ObjectType.Folder;
            }
            catch { }

            return ObjectType.Asset;
        }

 private void WriteUnityObjectData( string depth, Object uo, bool seen )
 {
     // shows some additional info on UnityObjects
     writer.WriteLine( depth + "<unityObject type=\"{0}\" name=\"{1}\" seen=\"{2}\" hash=\"{3}\"/>",
                       SecurityElement.Escape( uo.GetType().GetFormattedName() ),
                       SecurityElement.Escape( uo ? uo.name : "--missing reference--" ),
                       seen,
                       uo ? uo.GetHashCode().ToString() : "0");
     // todo we can show referenced assets for renderers, materials, audiosources etc
 }

        /// <summary>
        /// Create a PlaceHolder object for a given Component.  We can reference this component later.
        /// </summary>
        /// <param name="component"></param>
        /// <returns></returns>
        private static Object GetPlaceholder( SubScene subScene, Object originalObj, string hashId )
        {
            string name = string.Format( "Cross-Scene Ref ({0})", hashId );
            GameObject newGameObj = null;

            SceneData sceneData = SceneDataEx.GetSceneData(subScene);

            // First try searching by name (old behaviour)
            Transform existsChild = sceneData.transform.FindChild( name );
            if ( existsChild )
                newGameObj = existsChild.gameObject;

            if ( !newGameObj )
            {
                newGameObj = EditorUtility.CreateGameObjectWithHideFlags( name, HideFlags.None );
                newGameObj.transform.parent = sceneData.transform;
                newGameObj.SetActive(false);

				SubSceneEx.SetIsDirty( subScene, true );
            }

            if ( !AdditiveScenePreferences.DebugShowBookkepingObjects )
                newGameObj.hideFlags = HideFlags.HideInHierarchy;

            // Create a new, cloned component on the current GameObject.
            if ( originalObj is GameObject )
            {
                return newGameObj;
            }
            else if ( originalObj is Transform )
            {
                return newGameObj.transform;
            }
            else if ( originalObj is Component )
            {
                Component component = (Component)originalObj;
                Unsupported.CopyComponentToPasteboard( component );

                Component newComp = newGameObj.GetComponent( originalObj.GetType() );
                if ( !newComp )
				{
                    newComp = newGameObj.AddComponent( component.GetType() );
					SubSceneEx.SetIsDirty( subScene, true );
				}

                Unsupported.PasteComponentValuesFromPasteboard( newComp );
                return newComp;
            }

            throw new System.ArgumentException( "Placeholders can only be created for GameObjects or Components", "originalObj" );
        }