C# Type.GetMembers方法代码示例

        public static string Generate(Type type)
        {
            const string format = "{0}::{1}-{2}#{3}";

            if (type == null)
                throw new ArgumentNullException("type");

            var hashCode = type.GetHashCode();

            var attributes =
                type.GetMembers().SelectMany(x => x.GetCustomAttributes(true)).Concat(type.GetCustomAttributes(true));

            var nonPublicMembers = type.GetMembers(BindingFlags.NonPublic | BindingFlags.Instance);
            var statics = type.GetMembers(BindingFlags.Static | BindingFlags.Public);

            var items = type.GetMembers().Concat(attributes).Concat(nonPublicMembers).Concat(statics).ToArray();

            var typeCode = items.First().GetHashCode();
            typeCode = items.Skip(1).Aggregate(typeCode, (current, item) => current ^ item.GetHashCode());

            var asmDate = File.GetLastWriteTime(type.Assembly.Location);

            return String.Format(format, hashCode.ToString("X"), typeCode, items.Count(),
                asmDate.Ticks.ToString("X"));
        }

 public TypeDefinition(Type type)
     : this()
 {
     Namespace = type.Namespace;
     Name = type.Name;
     AddMembers(type.GetMembers(BindingFlags.Public | BindingFlags.Instance));
     AddMembers(type.GetMembers(BindingFlags.Public | BindingFlags.Static));
     AddMembers(type.GetMembers(BindingFlags.Public | BindingFlags.CreateInstance));
 }

 internal TypeReflector(Type type)
   : base(null){
   this.defaultMembers = null;
   ArrayList memberLookupTable = new ArrayList(512);
   int count = 0;
   SimpleHashtable staticMembers = new SimpleHashtable(256);
   foreach (MemberInfo member in type.GetMembers(BindingFlags.Public|BindingFlags.Static|BindingFlags.FlattenHierarchy)){
     String name = member.Name;
     Object ob = staticMembers[name];
     if (ob == null){
       staticMembers[name] = count++; //Avoid allocating an array until needed
       memberLookupTable.Add(member);
     }else{
       int index = (int)ob;
       ob = memberLookupTable[index];
       MemberInfo firstMember = ob as MemberInfo;
       if (firstMember != null){
         MemberInfoList mems = new MemberInfoList(); //Allocate a flexarray of MemberInfo, and turn it into a fixed array when GetMember is called for this name
         mems.Add(firstMember);
         mems.Add(member);
         memberLookupTable[index] = mems;
       }else
         ((MemberInfoList)ob).Add(member);
     }
   }
   this.staticMembers = staticMembers;
   SimpleHashtable instanceMembers = new SimpleHashtable(256);
   foreach (MemberInfo member in type.GetMembers(BindingFlags.Public|BindingFlags.Instance)){
     String name = member.Name;
     Object ob = instanceMembers[name];
     if (ob == null){
       instanceMembers[name] = count++; //Avoid allocating an array until needed
       memberLookupTable.Add(member);
     }else{
       int index = (int)ob;
       ob = memberLookupTable[index];
       MemberInfo firstMember = ob as MemberInfo;
       if (firstMember != null){
         MemberInfoList mems = new MemberInfoList();
         mems.Add(firstMember);
         mems.Add(member);
         memberLookupTable[index] = mems;
       }else
         ((MemberInfoList)ob).Add(member);
     }
   }
   this.instanceMembers = instanceMembers;
   this.memberLookupTable = memberLookupTable;
   this.memberInfos = new MemberInfo[count][];
   this.type = type;
   this.implementsIReflect = null;
   this.hashCode = (uint)type.GetHashCode();
   this.next = null;
 }

 public static void GenerateMethod(string methodName, Type type, Lua4NetSerializer serializer, Action<List<Type>> OnGetBody)
 {
     serializer.NewLine(methodName + "(");
     List<Type> args = new List<Type>();
     if (type.IsGenericType)
         args = type.GetGenericArguments().ToList();
     else
     {
         (type.GetMembers()[0] as MethodBase).GetParameters().ToList().ForEach(pi =>
         {
             args.Add(pi.ParameterType);
         }); ;
     }
     int nNextArgIndex = 0;
     while (nNextArgIndex < args.Count)
     {
         Type arg = args[nNextArgIndex];
         serializer.Apppend(GeneratorHelper.GetTypeName(arg) + " arg" + nNextArgIndex.ToString());
         ++nNextArgIndex;
         if (nNextArgIndex <= (args.Count - 1))
             serializer.Apppend(",");
     }
     serializer.Apppend(")");
     serializer.BeginBlock("{");
     OnGetBody(args);
     serializer.EndBlock("}");
 }

        private static void CreateModuleFromClass(ScriptEngine engine, Type t, string ModuleName)
        {
            var Module = engine.CreateModule(ModuleName);
            foreach (MemberInfo m in t.GetMembers(BindingFlags.Public | BindingFlags.Static)){

                if (m.MemberType == MemberTypes.Method){
                    MethodInfo method = (MethodInfo)m;
                    Module.SetVariable(m.Name, (AllFunctions)delegate(object[] input){ return method.Invoke(null, input);});
                    continue;
                }

                if (m.MemberType == MemberTypes.Property){
                    MethodInfo method = ((PropertyInfo)m).GetGetMethod();
                    Module.SetVariable(m.Name, method.Invoke(null, null));
                    continue;
                }

                if (m.MemberType == MemberTypes.Field) {
                    FieldInfo field = (FieldInfo)m;
                    Module.SetVariable(field.Name, field.GetValue(null));
                }

                Console.WriteLine("Not supported: " + m.Name + " for module: " + ModuleName);
            }
        }

        /// <summary>
        /// Adds all members to the node's children, grabbing the parameters
        /// for methods.
        /// </summary>
        /// <param name="treeNode"></param>
        /// <param name="type"></param>
        public static void AddMembers(this TreeNode treeNode, Type type)
        {
            // Get all members except methods
            MemberInfo[] memberInfo = type.GetMembers();
            for (int j = 0; j < memberInfo.Length; j++)
            {
                if (memberInfo[j].ReflectedType.IsPublic && memberInfo[j].MemberType != MemberTypes.Method)
                {
                    TreeNode node = treeNode.Nodes.Add(memberInfo[j].Name);
                    node.Tag = memberInfo[j].MemberType;
                }
            }

            // Get all methods
            MethodInfo[] methodInfo = type.GetMethods();
            for (int j = 0; j < methodInfo.Length; j++)
            {
                TreeNode node = treeNode.Nodes.Add(methodInfo[j].Name);
                string parms = "";

                ParameterInfo[] parameterInfo = methodInfo[j].GetParameters();
                for (int f = 0; f < parameterInfo.Length; f++)
                {
                    parms += parameterInfo[f].ParameterType + " " + parameterInfo[f].Name + ", ";
                }

                // Knock off remaining ", "
                if (parms.Length > 2)
                {
                    parms = parms.Substring(0, parms.Length - 2);
                }

                node.Tag = parms;
            }
        }

        private static void Initialize(ILocalTextRegistry registry, Type type, string languageID, string prefix)
        {
            var provider = registry ?? Dependency.Resolve<ILocalTextRegistry>();
            foreach (var member in type.GetMembers(BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly))
            {
                var fi = member as FieldInfo;
                if (fi != null &&
                    fi.FieldType == typeof(LocalText))
                {
                    var value = fi.GetValue(null) as LocalText;
                    if (value != null)
                    {
                        var initialized = value as InitializedLocalText;
                        if (initialized != null)
                        {
                            provider.Add(languageID, initialized.Key, initialized.InitialText);
                        }
                        else
                        {
                            provider.Add(languageID, prefix + fi.Name, value.Key);
                            fi.SetValue(null, new InitializedLocalText(prefix + fi.Name, value.Key));
                        }
                    }
                }
            }

            foreach (var nested in type.GetNestedTypes(BindingFlags.Public | BindingFlags.DeclaredOnly))
            {
                var name = nested.Name;
                if (name.EndsWith("_"))
                    name = name.Substring(0, name.Length - 1);

                Initialize(registry, nested, languageID, prefix + name + ".");
            }
        }

 public static MemberInfo[] GetPublicFieldsAndProperties(Type type)
 {
     return type
         .GetMembers(BindingFlags.Instance | BindingFlags.Public)
         .Where(mi => mi.MemberType == MemberTypes.Property || mi.MemberType == MemberTypes.Field)
         .ToArray();
 }

        /// <summary>
        ///     Retrieve the descriptions on the enum type.
        ///     Then when you pass in the enum type (e.g. Enums.UserTitles), it will retrieve the descriptions for all the
        ///     individual enums
        /// </summary>
        /// <param name="enumType">The Enumeration Type</param>
        /// <returns>A string list representing all the friendly names</returns>
        public static List<string> GetDescriptions(Type enumType)
        {
            MemberInfo[] memInfo = enumType.GetMembers(BindingFlags.Public | BindingFlags.Static)
                .Where(m => m.MemberType == MemberTypes.Field)
                .ToArray();
            var result = new List<string>();
            if (memInfo != null && memInfo.Length > 0)
            {
                foreach (MemberInfo member in memInfo)
                {
                    object[] attrs = member.GetCustomAttributes(typeof (DescriptionAttribute), false);

                    if (attrs != null && attrs.Length > 0)
                    {
                        result.Add(((DescriptionAttribute) attrs[0]).Description);
                    }
                    else
                    {
                        result.Add(member.Name);
                    }
                }
            }

            return result;
        }

		private static IEnumerable<String> DiscoverValidValuePaths(Type type, int depth)
		{
			var validMembers = type.GetMembers(BindingFlagsForSearch)
				.Where(member => (member.MemberType & MemberTypesToSearch) > 0);
			foreach (var member in validMembers)
			{
				yield return member.Name;
				var childType = ExtractMemberType(member);
				Type recurseOnType = childType;

				// For system collections declare only Count 
				if (typeof(System.Collections.ICollection).IsAssignableFrom(childType)
					&& childType.Namespace.StartsWith("System.Collections"))
				{
					yield return member.Name + ".Count";
					recurseOnType = childType.IsGenericType
						? childType.GetGenericArguments().First()
						: typeof(Object);
				}
				else if (childType.IsArray)
				{
					yield return member.Name + ".Length";
					recurseOnType = childType.GetElementType();
				}

				if (recurseOnType.IsClass && depth > 1 && recurseOnType != typeof(String))
				{ //recurse:
					var childItems = DiscoverValidValuePaths(recurseOnType, depth - 1);
					foreach (var item in childItems)
					{
						yield return member.Name + "." + item;
					}
				}
			}
		}

 public EnumConfiguration(Type enumType)
 {
     _signed = IsSignedEnum(enumType);
     _flags = IsFlagsEnum(enumType);
     _names = enumType.GetEnumNames();
     var members = enumType.GetMembers(BindingFlags.Static | BindingFlags.Public);
     Debug.Assert(members.Length == _names.Length);
     for (int i = 0; i < members.Length; i++)
     {
         var a = members[i].GetCustomAttributes<PersistedNameAttribute>().FirstOrDefault();
         if (a != null) _names[i] = a.Name;
     }
     var undertype = enumType.GetEnumUnderlyingType();
     var enumValues = enumType.GetEnumValues();
     IEnumerable<ulong> enumValuesUlongs;
     if (undertype == typeof(int)) enumValuesUlongs = enumValues.Cast<int>().Select(i => (ulong)i);
     else if (undertype == typeof(uint)) enumValuesUlongs = enumValues.Cast<uint>().Select(i => (ulong)i);
     else if (undertype == typeof(sbyte)) enumValuesUlongs = enumValues.Cast<sbyte>().Select(i => (ulong)i);
     else if (undertype == typeof(byte)) enumValuesUlongs = enumValues.Cast<byte>().Select(i => (ulong)i);
     else if (undertype == typeof(short)) enumValuesUlongs = enumValues.Cast<short>().Select(i => (ulong)i);
     else if (undertype == typeof(ushort)) enumValuesUlongs = enumValues.Cast<ushort>().Select(i => (ulong)i);
     else if (undertype == typeof(long)) enumValuesUlongs = enumValues.Cast<long>().Select(i => (ulong)i);
     else enumValuesUlongs = enumValues.Cast<ulong>();
     _values = enumValuesUlongs.ToArray();
 }

	public ExistingNamespaceParams (Type t) 
	{
	    // Populate our tables.

	    MemberInfo[] mems = t.GetMembers ();

	    for (int i = 0; i < mems.Length; i++) {
		MemberInfo mi = mems[i];

		object[] attrs = mi.GetCustomAttributes (typeof (StructureParameterAttribute), 
							 false);

		if (attrs == null || attrs.Length == 0)
		    continue;

		sparams[mi.Name] = ((StructureParameterAttribute) attrs[0]).Kind;

		if (sparams[mi.Name] == StructureParameterKind.Structure) {
		    Type stype = null;

		    if (mi is PropertyInfo)
			stype = (mi as PropertyInfo).PropertyType;
		    else if (mi is FieldInfo)
			stype = (mi as FieldInfo).FieldType;

		    structtypes[mi.Name] = new UserType (stype);
		}
	    }
	}

        static SerializableType CompileType(Type type)
        {
            // at this point, type is a composite type
            object[] typeAttributes = type.GetCustomAttributes(typeof(AmqpContractAttribute), true);
            if (typeAttributes.Length != 1)
            {
                throw new NotSupportedException(type.FullName);
            }

            AmqpContractAttribute contractAttribute = (AmqpContractAttribute)typeAttributes[0];
            string descriptorName = contractAttribute.Name;
            ulong? descriptorCode = contractAttribute.InternalCode;
            if (descriptorName == null && descriptorCode == null)
            {
                descriptorName = type.FullName;
            }

            int lastOrder = 0;
            SortedList<int, SerialiableMember> memberList = new SortedList<int, SerialiableMember>();
            MemberInfo[] memberInfos = type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            foreach (MemberInfo memberInfo in memberInfos)
            {
                if (memberInfo.DeclaringType != type ||
                    (memberInfo.MemberType != MemberTypes.Field &&
                    memberInfo.MemberType != MemberTypes.Property))
                {
                    continue;
                }

                object[] memberAttributes = memberInfo.GetCustomAttributes(typeof(AmqpMemberAttribute), true);
                if (memberAttributes.Length != 1)
                {
                    continue;
                }

                AmqpMemberAttribute attribute = (AmqpMemberAttribute)memberAttributes[0];

                SerialiableMember member = new SerialiableMember();
                member.Name = attribute.Name ?? memberInfo.Name;
                member.Order = attribute.InternalOrder ?? lastOrder;
                member.Mandatory = attribute.Mandatory;
                member.Accessor = MemberAccessor.Create(memberInfo);

                // This will recursively resolve member types
                Type memberType = memberInfo.MemberType == MemberTypes.Field ? ((FieldInfo)memberInfo).FieldType : ((PropertyInfo)memberInfo).PropertyType;
                member.Type = GetType(memberType);

                memberList.Add(member.Order, member);
                lastOrder = member.Order >= lastOrder ? member.Order + 1 : lastOrder + 1;
            }

            SerialiableMember[] members = new SerialiableMember[memberList.Count];
            for (int i = 0; i < memberList.Count; ++i)
            {
                members[i] = memberList[i];
            }

            SerializableType serializableType = SerializableType.Create(type, descriptorName, descriptorCode, members);
            return serializableType;
        }

        private static IEnumerable<string> MemberNames(Type type, bool getFacets)
        {
            if (type == null)
            {
                yield break;
            }

            var members = type.GetMembers();

            foreach (var member in members)
            {
                if (member.MemberType == MemberTypes.Field || member.MemberType == MemberTypes.Property)
                {
                    var propertyType = type.GetProperty(member.Name).PropertyType;

                    if (typeof(IFacet).IsAssignableFrom(propertyType))
                    {
                        if (getFacets)
                        {
                            yield return member.Name;
                        }
                    }
                    else
                    {
                        if (!getFacets)
                        {
                            yield return member.Name;
                        }
                    }
                }
            }
        }

        /// <summary>Получить список (значение; наименование)</summary>
        /// <param name="enumType">Тип перечисления</param>
        /// <returns>Список (значение; наименование)</returns>
        public static Dictionary<int, string> GetList(Type enumType)
        {
            int index = 0;
            Dictionary<int,string> list = new Dictionary<int, string>();

            while (true)
            {
                string numberStr = index.ToString();
                object valueDescription = Enum.Parse(enumType, index.ToString(), true);
                string valueStr = valueDescription.ToString();

                if (numberStr == valueStr)
                {
                    break;
                }

                MemberInfo inf = enumType.GetMembers()[10 + index];
                dbFieldAtt attribute = Attribute.GetCustomAttribute(inf, typeof(dbFieldAtt)) as dbFieldAtt;

                if (attribute != null)
                {
                    list.Add(index++, attribute.Description);
                }
            }

            return list;
        }