C# System.Type.GetProperty方法代码示例

        /// <summary>
        /// Perform one-off setup when class is accessed for first time.
        /// </summary>
        static GradientWrapper()
        {
            #if (UNITY_3_5 || UNITY_3_6 || UNITY_3_7 || UNITY_3_8 || UNITY_3_9)
            Assembly editorAssembly = typeof(Editor).Assembly;

            s_tyGradientColorKey = editorAssembly.GetType("UnityEditor.GradientColorKey");
            s_tyGradientAlphaKey = editorAssembly.GetType("UnityEditor.GradientAlphaKey");

            // Note that `Gradient` is defined in the editor namespace in Unity 3.5.7!
            s_tyGradient = editorAssembly.GetType("UnityEditor.Gradient");
            s_miEvaluate = s_tyGradient.GetMethod("CalcColor", BindingFlags.Public | BindingFlags.Instance, null, new Type[] { typeof(float) }, null);
            s_piColorKeys = s_tyGradient.GetProperty("colorKeys", BindingFlags.Public | BindingFlags.Instance);
            s_piAlphaKeys = s_tyGradient.GetProperty("alphaKeys", BindingFlags.Public | BindingFlags.Instance);
            #else
            // In Unity 4 this is easy :)
            s_tyGradient = typeof(Gradient);
            #endif
        }

        private static System.Func<object, object> FindMember(Type type, string name)
        {
            if (type == null)
                throw new ArgumentNullException("type");
            if (name == null)
                throw new ArgumentNullException("name");

            lock (_memberAccessors)
            {
                Dictionary<string, System.Func<object, object>> members;
                System.Func<object, object> accessor = null;

                if (_memberAccessors.TryGetValue(type, out members))
                {
                    if (members.TryGetValue(name, out accessor))
                        return accessor;
                }
                else
                {
                    members = new Dictionary<string, System.Func<object, object>>();
                    _memberAccessors[type] = members;
                }

                // must look up using reflection
                string methodSuffix = char.ToUpperInvariant(name[0]) + name.Substring(1);
                bool checkOriginalName = !string.Equals(methodSuffix, name);

                MethodInfo method = null;
                if (method == null)
                {
                    PropertyInfo p = type.GetProperty(methodSuffix);
                    if (p == null && checkOriginalName)
                        p = type.GetProperty(name);

                    if (p != null)
                        method = p.GetGetMethod();
                }

                if (method == null)
                {
                    method = type.GetMethod("Get" + methodSuffix, Type.EmptyTypes);
                    if (method == null && checkOriginalName)
                        method = type.GetMethod("Get" + name, Type.EmptyTypes);
                }

                if (method == null)
                {
                    method = type.GetMethod("get_" + methodSuffix, Type.EmptyTypes);
                    if (method == null && checkOriginalName)
                        method = type.GetMethod("get_" + name, Type.EmptyTypes);
                }

                if (method != null)
                {
                    accessor = BuildAccessor(method);
                }
                else
                {
                    // try for an indexer
                    method = type.GetMethod("get_Item", new Type[] { typeof(string) });
                    if (method == null)
                    {
                        var property = type.GetProperties().FirstOrDefault(IsIndexer);
                        if (property != null)
                            method = property.GetGetMethod();
                    }

                    if (method != null)
                    {
                        accessor = BuildAccessor(method, name);
                    }
                    else
                    {
                        // try for a visible field
                        FieldInfo field = type.GetField(name);
                        // also check .NET naming convention for fields
                        if (field == null)
                            field = type.GetField("_" + name);

                        if (field != null)
                            accessor = BuildAccessor(field);
                    }
                }

                members[name] = accessor;

                return accessor;
            }
        }

		static API()
		{
			const BindingFlags instanceMember = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			const BindingFlags staticMember = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
			
			var editorAssembly = typeof(EditorWindow).Assembly;
			
			containerWindowType = editorAssembly.GetType("UnityEditor.ContainerWindow");
			viewType = editorAssembly.GetType("UnityEditor.View");
			dockAreaType = editorAssembly.GetType("UnityEditor.DockArea");
			splitViewType = editorAssembly.GetType("UnityEditor.SplitView");
			mainWindowType = editorAssembly.GetType("UnityEditor.MainWindow");
			windowLayoutType = editorAssembly.GetType("UnityEditor.WindowLayout");
			
			parentField = typeof(EditorWindow).GetField("m_Parent", instanceMember);
			if (viewType != null)
				parentProperty = viewType.GetProperty("parent", instanceMember);
			if (dockAreaType != null)
			{
				panesField = dockAreaType.GetField("m_Panes", instanceMember);
				addTabMethod = dockAreaType.GetMethod("AddTab", new System.Type[] { typeof(EditorWindow) });
			}
			if (containerWindowType != null)
			{
				windowsField = containerWindowType.GetProperty("windows", staticMember);
				mainViewField = containerWindowType.GetProperty("mainView", instanceMember);
			}
			if (viewType != null)
				allChildrenField = viewType.GetProperty("allChildren", instanceMember);
			
#if UNITY_4_0 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_4 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7 || UNITY_5_0
			cachedTitleContentField = typeof(EditorWindow).GetProperty("cachedTitleContent", instanceMember);
#endif
				
		//    FieldInfo windowsReorderedField = typeof(EditorApplication).GetField("windowsReordered", staticMember);
		//Debug.Log("windowsReorderedField " + windowsReorderedField);
		//    if (windowsReorderedField != null)
		//        windowsReordered = windowsReorderedField.GetValue(null) as EditorApplication.CallbackFunction;
		//Debug.Log("windowsReordered " + windowsReordered);

			System.Type projectWindowUtilType = editorAssembly.GetType("UnityEditor.ProjectWindowUtil");
			if (projectWindowUtilType != null)
				createAssetMethod = projectWindowUtilType.GetMethod("CreateAsset", new System.Type[] { typeof(Object), typeof(string) });

			if (windowLayoutType != null)
			{
				isMaximizedMethod = windowLayoutType.GetMethod("IsMaximized", staticMember);
				maximizeMethod = windowLayoutType.GetMethod("Maximize", staticMember);
				unMaximizeMethod = windowLayoutType.GetMethod("Unmaximize", staticMember);
				if (isMaximizedMethod == null || maximizeMethod == null || unMaximizeMethod == null)
					windowLayoutType = null;
			}
		}