public static IEnumerable <MemberInfo> GetMembersFromType(System.Type tp, bool includeNonPublic) { const BindingFlags BINDING = BindingFlags.Public | BindingFlags.Instance; const BindingFlags PRIV_BINDING = BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly; const MemberTypes MASK = MemberTypes.Field | MemberTypes.Property | MemberTypes.Method; if (tp == null) { yield break; } foreach (var m in tp.GetMembers(BINDING)) { if ((m.MemberType & MASK) != 0) { yield return(m); } } if (includeNonPublic) { while (tp != null) { foreach (var m in tp.GetMembers(PRIV_BINDING)) { if ((m.MemberType & MASK) != 0) { yield return(m); } } tp = tp.BaseType; } } }
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)); }
static public void DoUpdateGetComponentAttribute(MonoBehaviour pMonobehaviourOwner, object pClass_Anything) { // BindingFloags를 일일이 써야 잘 동작한다.. System.Type pType = pClass_Anything.GetType(); MemberInfo[] arrMembers = pType.GetMembers(BindingFlags.Public | BindingFlags.Instance); UpdateComponentAttribute(pMonobehaviourOwner, pClass_Anything, arrMembers); arrMembers = pType.GetMembers(BindingFlags.NonPublic | BindingFlags.Instance); UpdateComponentAttribute(pMonobehaviourOwner, pClass_Anything, arrMembers); }
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 void LogMembers() { Test test = new Test(); System.Type type = test.GetType(); MemberInfo[] info = type.GetMembers(); for (int i = 0; i < info.Length; ++i) { // MemberInfo: displays the type and name of the member with a space between them (I.E. "System.single speed") // MemberInfo.Name: displays the name of the member // MemberInfo.MemberType: displays the type of member (I.E., field or method) // MemberInfo.ReflectedType: displays the type that the member belongs to (I.E., the class name) // MemberInfo.DeclaringType: the type that originally declared the member (either the class from ReflectedType or Object for more global members) // MemberInfo.Module: the source of the type, usually a DLL // MemberInfo.MetadataToken: an unique ID for metadata if (info[i].DeclaringType.Name != "Object" && info[i].MemberType == MemberTypes.Field) { Debug.Log(info[i].Name + "\nMemberType: " + info[i]); string typeAsString = GetTypeAsString(info[i]); members.Add(new MemberInfoTest(info[i].Name, typeAsString, Type.GetType(typeAsString))); } } Debug.Log(""); }
/// <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; }
/// <summary> /// Given T, the method will return a Dictionary[string,MemberInfo] where /// string is the field/property name and MemberInfo is the reflected /// member info of the field/property that will be used for invocation /// and setting values. The returned Dictionary must encompass the full /// set of viable properties/fields that can be faked on T. /// </summary> /// <returns>The full set of MemberInfos for injection.</returns> public Dictionary<string, MemberInfo> GetMembers(Type t) { return t.GetMembers(BindingFlags) .Where(m => { if (m.GetCustomAttributes(typeof(CompilerGeneratedAttribute), true).Any()) { //no compiler generated stuff return false; } var pi = m as PropertyInfo; if (pi != null) { return pi.CanWrite; } var fi = m as FieldInfo; if( fi != null ) { //No private fields. //Github Issue #13 return !fi.IsPrivate; } return false; }) .ToDictionary(pi => pi.Name); }
private void SystemNameSake(System.Type sType, IList <ISignature> signatures, String elementName, String elementPrototype, bool comma) { XSharpProjectPackage.Instance.DisplayOutPutMessage("XSharpSignatureHelpSource.SystemNameSake()"); MemberInfo[] members; // Get Public, Internal, Protected & Private Members, we also get Instance vars, Static members...all that WITHOUT inheritance members = sType.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly); // bool ctor = false; foreach (var member in members.Where(x => nameEquals(x.Name, elementName))) { if (member.MemberType == MemberTypes.Constructor) { ctor = true; } XSharpLanguage.MemberAnalysis analysis = new XSharpLanguage.MemberAnalysis(member); if (analysis.IsInitialized) { // But don't add the current one if (String.Compare(elementPrototype, analysis.Prototype, true) != 0) { signatures.Add(CreateSignature(m_textBuffer, analysis.Prototype, "", ApplicableToSpan, comma)); } } } // fill members of parent class,but not for constructorsS if (sType.BaseType != null && !ctor) { SystemNameSake(sType.BaseType, signatures, elementName, elementPrototype, comma); } }
public TypeDescription(System.Type type) { var ignoredMembers = new string[] { "ToString", "Equals", "GetHashCode", "GetType", "Finalize", "MemberwiseClone", ".ctor" }; foreach (var member in type.GetMembers( Reflection.BindingFlags.Instance | Reflection.BindingFlags.Public | Reflection.BindingFlags.NonPublic ).Where( member => !ignoredMembers.Any( ignoredMember => ignoredMember == member.Name ) ) ) { var memberType = member.MemberType == Reflection.MemberTypes.Method ? Type.Function : Type.Variable; this.Add( member.Name, (int)memberType ); MemberDescriptions.Add(member.Name, this.GetMemberDescription(member, memberType)); } }
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); } }
public static ClassWrapper CreateFromType (TypeRegistry registry, Type type, string name) { ClassWrapper wrapper = new ClassWrapper (registry, type, name); foreach (MemberInfo info in type.GetMembers (BindingFlags.Public | BindingFlags.Static)) { switch (info.MemberType) { case MemberTypes.Method: if (!wrapper.HasAttribute (info.Name)) { wrapper.SetAttribute (info.Name, CreateMultiMethod (registry, type, info.Name)); } break; case MemberTypes.Field: wrapper.SetAttribute (info.Name, FieldWrapper.Create (registry, (FieldInfo)info)); break; case MemberTypes.Property: wrapper.SetAttribute (info.Name, PropertyWrapper.Create (registry, (PropertyInfo)info)); break; } } registry.AddTypeMapping (type, wrapper, new ObjectTypeMapping (wrapper, registry)); return wrapper; }
public static string Generate(Type type) { MemberInfo[] memberInfos = type.GetMembers(); const string methodString = @"public override string ToString() {{ return {0}; }}"; const string outer = "GetType().Name + string.Format(\"{{{{{0}}}}}\", {1}{2})"; List<MemberInfo> properties = memberInfos.Where(mi => mi.MemberType == MemberTypes.Property).ToList(); int count = 0; var inners = new List<string>(); foreach (var property in properties) { string inner = string.Format("{0}={{{1}}}", property.Name, count); inners.Add(inner); count++; } string firstHalf = string.Join(", ", inners); string secondHalf = string.Join(", ", properties.Select(p => p.Name)); string body = string.Format(outer, firstHalf, "\n\t\t\t\t", secondHalf); return string.Format(methodString, body); }
internal static void CollectMembers(Dictionary<string, string> members, Type t) { foreach (MemberInfo mi in t.GetMembers()) { if (mi.MemberType != MemberTypes.Constructor) { members[mi.Name] = mi.Name; } } }
static void AnalyzeType(Type t) { TypeInfo typeInfo = t.GetTypeInfo(); AddToOutput($"Type Name: {t.Name}"); AddToOutput($"Full Name: {t.FullName}"); AddToOutput($"Namespace: {t.Namespace}"); Type tBase = typeInfo.BaseType; if (tBase != null) { AddToOutput($"Base Type: {tBase.Name}"); } AddToOutput("\npublic members:"); foreach (MemberInfo member in t.GetMembers()) { #if NET46 AddToOutput($"{member.DeclaringType} {member.MemberType} {member.Name}"); #else AddToOutput($"{member.DeclaringType} {member.Name}"); #endif } }
/// <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 + "."); } }
private IList GetMembers (Type type) { ArrayList members = new ArrayList (); members.AddRange (type.GetMembers (BindingFlags)); members.Sort (NameComparer); return members; }
void ProcessType(DemoTreeNode parent, System.Type t) { foreach (MemberInfo mi in t.GetMembers()) { parent.AddChild(new DemoTreeNode(mi.Name, mi.ToString())); } }
public static ProxyConfiguration Create(Type type) { return configurations.GetOrAdd(type, (t) => { object[] args = t.GetCustomAttributes(typeof(ProxyAttribute), true); ProxyConfiguration config = null; if (args.Length > 0) { config = new ProxyConfiguration(args[0] as ProxyAttribute); } else { config = new ProxyConfiguration(); } foreach (var item in type.GetMembers()) { object[] memberStatus = item.GetCustomAttributes(typeof(ProxyAttribute), true); if (memberStatus.Length > 0) { config.MemberAutoProxyStatus[item.Name] = (memberStatus[0] as ProxyAttribute).DisableAutoProxy; } } if (string.IsNullOrWhiteSpace(config.DllCachedPath)) { config.DllCachedPath = AppDomain.CurrentDomain.BaseDirectory; if (!config.DllCachedPath.EndsWith("\\")) { config.DllCachedPath += "\\"; } } return config; }); }
public TypeSerializer(Type targetType) { var fields = new List<BlobFieldAttribute>(); this.targetType = targetType; foreach (MemberInfo member in targetType.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) { BlobFieldAttribute[] attribs = (BlobFieldAttribute[])member.GetCustomAttributes(typeof(BlobFieldAttribute), false); if (attribs.Length == 0) continue; BlobFieldAttribute attrib = attribs[0]; switch (member.MemberType) { case MemberTypes.Field: attrib.Serializer = new FieldSerializer((FieldInfo)member); break; case MemberTypes.Property: attrib.Serializer = new PropertySerializer((PropertyInfo)member); break; default: throw new NotImplementedException(); } fields.Add(attrib); } this.fields = fields.ToArray(); }
private static void ProcessType(TreeIter parent, System.Type t) { foreach (MemberInfo mi in t.GetMembers()) { store.AppendValues(parent, mi.Name, mi.ToString()); } }
private MessagePartDescriptionCollection GetWrappedParts(MessagePartDescription bodyPart) { System.Type type = bodyPart.Type; MessagePartDescriptionCollection descriptions = new MessagePartDescriptionCollection(); foreach (MemberInfo info in type.GetMembers(BindingFlags.Public | BindingFlags.Instance)) { if (((info.MemberType & (MemberTypes.Property | MemberTypes.Field)) != 0) && !info.IsDefined(typeof(SoapIgnoreAttribute), false)) { MessagePartDescription description; System.ServiceModel.Description.XmlName name = new System.ServiceModel.Description.XmlName(info.Name); description = new MessagePartDescription(name.EncodedName, string.Empty) { AdditionalAttributesProvider = description.MemberInfo = info, Index = description.SerializationPosition = descriptions.Count, Type = (info.MemberType == MemberTypes.Property) ? ((PropertyInfo)info).PropertyType : ((FieldInfo)info).FieldType }; if (bodyPart.HasProtectionLevel) { description.ProtectionLevel = bodyPart.ProtectionLevel; } descriptions.Add(description); } } return(descriptions); }
public string Generate(Type resource) { Schema schema = new Schema(); ResourceBaseAttribute resourceAttr = resource.GetCustomAttribute<ResourceBaseAttribute>(); if (resourceAttr == null) return null; // Setting the schema master attributes schema.Name = resource.Name; schema.ApsVersion = resourceAttr.ApsVersion; schema.Implements = resourceAttr.Implements; schema.Id = resourceAttr.Id; List<PropertyInfo> properties = new List<PropertyInfo>(); List<PropertyInfo> links = new List<PropertyInfo>(); List<PropertyInfo> structures = new List<PropertyInfo>(); schema.Properties = new Dictionary<string, Property>(); foreach (PropertyInfo property in resource.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)) { if (property.GetCustomAttribute<SDK.Attributes.RelationAttribute>() != null) schema.Relations.Add(property.Name, Relation.CreateRelationObject(property)); } schema.Operations = new Dictionary<string, Operation>(); foreach(MemberInfo method in resource.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)) { if (method.GetCustomAttribute<OperationAttribute>() != null) schema.Operations.Add(method.Name, Operation.CreateOperationObject(method)); } return JsonConvert.SerializeObject(schema, Formatting.Indented); }
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("}"); }
//反射获取成员 public static void getMember(Type t) { foreach (var member in t.GetMembers()) { Console.WriteLine(member.Name); } }
public static void DisplayFixes(System.Type t) { object[] fixes = t.GetCustomAttributes(typeof(BugFixAttribute), false); Console.WriteLine("Displaying fixes for {0}", t); foreach (BugFixAttribute bugFix in fixes) { Console.WriteLine(" {0}", bugFix); } foreach (MemberInfo member in t.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)) { object[] memberFixes = member.GetCustomAttributes(typeof(BugFixAttribute), false); if (memberFixes.Length > 0) { Console.WriteLine(" {0}", member.Name); foreach (BugFixAttribute memberFix in memberFixes) { Console.WriteLine(" {0}", memberFix); } } } }
private void WriteEnum(StreamWriter s, System.Type t) { s.WriteLine("public enum " + t.Name + " {"); bool first = true; foreach (MemberInfo mb in t.GetMembers()) { if (mb.ToString().Contains(t.Name)) { if (mb.ToString().Contains("(")) { continue; // Skip functions } string[] possibleType = mb.ToString().Split('.'); if (possibleType.Length > 1) { if (!first) { s.Write(",\n"); } first = false; s.Write("\t" + possibleType[1].Split(' ')[1]); } } } s.WriteLine(); s.WriteLine("}"); }
public static T Cast <T>(this Object myobj) { System.Type objectType = myobj.GetType(); System.Type target = typeof(T); var x = Activator.CreateInstance(target, false); var z = from source in objectType.GetMembers().ToList() where source.MemberType == MemberTypes.Property select source; var d = from source in target.GetMembers().ToList() where source.MemberType == MemberTypes.Property select source; List <MemberInfo> members = d.Where(memberInfo => d.Select(c => c.Name) .ToList().Contains(memberInfo.Name)).ToList(); PropertyInfo propertyInfo; object value; foreach (var memberInfo in members) { try { propertyInfo = typeof(T).GetProperty(memberInfo.Name); value = myobj.GetType().GetProperty(memberInfo.Name).GetValue(myobj, null); propertyInfo.SetValue(x, value, null); } catch (Exception) { } } return((T)x); }
public string GetDisPlayName(object entity) { StringBuilder str = new StringBuilder(); if (entity != null) { System.Type t = entity.GetType(); System.Reflection.MemberInfo[] memberInfot = t.GetMembers(); foreach (MemberInfo var in memberInfot) { if (var.MemberType == MemberTypes.Property) { System.Reflection.PropertyInfo propertyInfo = entity.GetType().GetProperty(var.Name); try { string val = propertyInfo.GetValue(entity, null).ToString(); str.Append(var.Name + ":" + val + ","); } catch { } } } } return(str.ToString()); }
public AttributedMetaType(Type classType) { type = classType; // associations and members var associationsList = new List<MetaAssociation>(); var dataMembersList = new List<MetaDataMember>(); var identityMembersList = new List<MetaDataMember>(); foreach (var memberInfo in classType.GetMembers()) { var association = memberInfo.GetAttribute<AssociationAttribute>(); if (association != null) { var dataMember = new AttributedAssociationMetaDataMember(memberInfo, association, this); var metaAssociation = new AttributedMetaAssociation(memberInfo, association, dataMember); associationsList.Add(metaAssociation); dataMember.SetAssociation(metaAssociation); } var column = memberInfo.GetAttribute<ColumnAttribute>(); if (column != null) { var dataMember = new AttributedColumnMetaDataMember(memberInfo, column, this); dataMembersList.Add(dataMember); if (dataMember.IsPrimaryKey) identityMembersList.Add(dataMember); } } associations = new ReadOnlyCollection<MetaAssociation>(associationsList); persistentDataMembers = new ReadOnlyCollection<MetaDataMember>(dataMembersList); identityMembers = new ReadOnlyCollection<MetaDataMember>(identityMembersList); }
internal static IEnumerable<MemberInfo> GetVisibleMembers(Type type) { var unfiltered = type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static); var result = unfiltered.Filter(IsVisible); return result; }
private static IDictionary<string, DdeTableColumn> GetColumnsDictionary(Type type) { if (type == null) throw new ArgumentNullException(nameof(type)); return type.GetMembers<PropertyInfo>().ToDictionary(p => p.Name, p => p.GetValue<VoidType, DdeTableColumn>(null)); }
/// <summary> /// Adds all members to the node's children, grabbing the parameters /// for methods. /// </summary> /// <param name="treeNode"></param> /// <param name="type"></param> private void addMembers(TreeNode treeNode, System.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.ToString() + " " + parameterInfo[f].Name + ", "; } // Knock off remaining ", " if (parms.Length > 2) { parms = parms.Substring(0, parms.Length - 2); } node.Tag = parms; } }
public static MemberInfo[] GetPublicFieldsAndProperties(Type type) { return type .GetMembers(BindingFlags.Instance | BindingFlags.Public) .Where(mi => mi.MemberType == MemberTypes.Property || mi.MemberType == MemberTypes.Field) .ToArray(); }
internal SqlCallInfo(AssemblyInventory inventory, ISerializationTypeInfoProvider serializationTypeInfoProvider, Type interfaceType, ISerializationTypeMappingProvider typeMappingProvider) { if (inventory == null) { throw new ArgumentNullException("inventory"); } if (serializationTypeInfoProvider == null) { throw new ArgumentNullException("serializationTypeInfoProvider"); } Debug.Assert(interfaceType != null); if ((!interfaceType.IsInterface) || (interfaceType.IsGenericTypeDefinition) || (!typeof(IStoredProcedures).IsAssignableFrom(interfaceType))) { throw new ArgumentException("The interface must inherit from IStoredProcedures", "interfaceType"); } this.interfaceType = interfaceType; foreach (Type innerInterface in interfaceType.GetInterfaces()) { if (innerInterface != typeof(IStoredProcedures)) { throw new ArgumentException("The interface cannot inherit from other interfaces then IStoredProcedures", "interfaceType"); } } foreach (MemberInfo memberInfo in interfaceType.GetMembers(BindingFlags.Instance|BindingFlags.Public|BindingFlags.DeclaredOnly)) { MethodInfo methodInfo = memberInfo as MethodInfo; if (methodInfo == null) { throw new ArgumentException("Only methods are supported on the IStoredProcedures interfaces", "interfaceType"); } methods.Add(methodInfo, new SqlCallProcedureInfo(inventory, serializationTypeInfoProvider, methodInfo, typeMappingProvider)); } }
public Resolution Check(Type type) { if (type.IsInterface && type.GetMembers().Length == 0) { // FIXME: I18N return new Resolution (this, String.Format ("Use a custom attribute to replace the empty interface <code>{0}</code>. Or specify behaviour for this interface.", type.FullName), type.FullName); } return null; }
private static MemberInfo[] GetFieldProperty <T>() where T : class, new() { System.Type t = typeof(T); MemberInfo[] mems = t.GetMembers(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public ); return(mems); }
void InitGameNames() { GameEnum genum = new GameEnum(); System.Type type = typeof(GameEnum); System.Reflection.MemberInfo[] minfos = type.GetMembers(); _names = new string[minfos.Length]; for (int i = 0; i < minfos.Length; i++) { _names[i] = minfos[i].Name; } }
private MemberInfo GetMember(System.Type type, string identifier) { MemberInfo[] members = type.GetMembers(); for (int i = 0; i < members.Length; i += 1) { if (members[i].Name == identifier) { return(members[i]); } } return(null); }
static StackObject *GetMembers_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 1); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); System.Type instance_of_this_method = (System.Type) typeof(System.Type).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); var result_of_this_method = instance_of_this_method.GetMembers(); return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method)); }
public virtual DecodedObject <object> decodeEnum(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream) { Type enumClass = null; foreach (MemberInfo member in objectClass.GetMembers()) { if (member is System.Type) { Type cls = (Type)member; if (cls.IsEnum) { enumClass = cls; break; } } } ; System.Reflection.PropertyInfo field = objectClass.GetProperty("Value"); DecodedObject <object> itemValue = decodeEnumItem(decodedTag, field.PropertyType, enumClass, elementInfo, stream); System.Reflection.FieldInfo param = null; if (itemValue != null) { object result = createInstanceForElement(objectClass, elementInfo); foreach (FieldInfo enumItem in enumClass.GetFields()) { if (CoderUtils.isAttributePresent <ASN1EnumItem>(enumItem)) { ASN1EnumItem meta = CoderUtils.getAttribute <ASN1EnumItem>(enumItem); if (meta.Tag.Equals(itemValue.Value)) { param = enumItem; break; } } } invokeSetterMethodForField(field, result, param.GetValue(null), null); return(new DecodedObject <object>(result, itemValue.Size)); } else { return(null); } }
private Dictionary <string, MemberInfo> GetMemberInfoDict(System.Type type) { MemberInfo[] mis = type.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy); Dictionary <string, MemberInfo> dict = new Dictionary <string, MemberInfo>(); foreach (MemberInfo mi in mis) { if (mi.MemberType == MemberTypes.Property || mi.MemberType == MemberTypes.Field) { dict[mi.Name] = mi; } } return(dict); }
void LoadMembers(System.Type refType, Type type, bool loadAttributes) { type.Members = new List <Member>(); BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly; foreach (System.Reflection.MemberInfo refMember in refType.GetMembers(bindingFlags)) { Member member = LoadMember(refMember, loadAttributes); if (member != null) { type.Members.Add(member); } } }
private Object getStaticMember(string key) { var members = ClassType.GetMembers(BindingFlags.Static | BindingFlags.Public); var target = (from member in members where ((member.MemberType == MemberTypes.Field || member.MemberType == MemberTypes.Property || member.MemberType == MemberTypes.Method || member.MemberType == MemberTypes.NestedType) && member.Name == key) select member); Object result = null; if (target.Any()) { MemberInfo memberInfo = target.First(); MemberTypes memberTypes = memberInfo.MemberType; if (memberTypes == MemberTypes.Property) { result = new DotnetObject ((memberInfo as PropertyInfo).GetValue(null)); } else if (memberTypes == MemberTypes.Field) { result = new DotnetObject ((memberInfo as FieldInfo).GetValue(null)); } else if (memberTypes == MemberTypes.NestedType) { result = new DotnetClass { ClassType = memberInfo as Type }; } else { result = new DotnetMethod { Target = null, Type = ClassType, methodName = key }; } } return(result); }
public void ReflectMembers() { ClearMembers(); comps = GetComponents(typeof(Component)); for (int i = 0; i < comps.Length; ++i) { // exclude Replicator from the list if (comps[i].GetType().Name != "Replicator") { // save name of component for display purposes classNames.Add(comps[i].GetType().Name); // get type of component and save its member info System.Type type = comps[i].GetType(); MemberInfo[] info = type.GetMembers(); for (int j = 0; j < info.Length; ++j) { // MemberInfo: displays the type and name of the member with a space between them (I.E. "System.single speed") // MemberInfo.Name: displays the name of the member // MemberInfo.MemberType: displays the type of member (I.E., field or method) // MemberInfo.ReflectedType: displays the type that the member belongs to (I.E., the class name) // MemberInfo.DeclaringType: the type that originally declared the member (either the class from ReflectedType or Object for more global members) // MemberInfo.Module: the source of the type, usually a DLL // MemberInfo.MetadataToken: an unique ID for metadata if (info[j].DeclaringType.Name != "Object" && info[j].DeclaringType.Name != "Component" && info[j].DeclaringType.Name != "MonoBehaviour" && // for extra things like GUILayout info[j].DeclaringType.Name != "Behaviour" && // for extra things like IsActiveAndEnabled (info[j].MemberType == MemberTypes.Property || info[j].MemberType == MemberTypes.Field)) { Debug.Log(info[j].Name + "\nMemberType: " + info[j]); string typeAsString = GetTypeAsString(info[j]); members.Add(new MyMemberInfo(info[j].Name, typeAsString, Type.GetType(typeAsString), info[j].MemberType.ToString(), classNames[i])); } } } } Debug.Log(""); }
private void WriteInterface(StreamWriter s, System.Type t) { s.Write("public interface "); s.Write(t.Name); if (t.BaseType != typeof(object) && t.BaseType != null) { s.Write(" : "); s.Write(t.BaseType.Name); } s.Write(" {\n"); foreach (MemberInfo mb in t.GetMembers()) { s.Write(mb); s.Write(";\n"); } s.WriteLine("}"); }
private void Parse(System.Type aType) { object[] attrs; foreach (MemberInfo info in aType.GetMembers()) { bool found = false; attrs = info.GetCustomAttributes(false); foreach (object attr in attrs) { if (TypeValidator.IsCompatible(attr.GetType(), typeof(DevelopmentInformationAttribute)) == true) { members.Add(info); found = true; break; } } } }
public static bool PassesRequiredFieldValidation(Object thing, out List <string> _failedFields) { bool isValid = true; int ffIndex = 0; _failedFields = new List <string>(); Type thingType = thing.GetType(); int count; MemberInfo[] members = thingType.GetMembers(_BINDINGS); count = members.Length; for (int i = 0; i < count; ++i) { MemberInfo member = members[i]; if (member.GetCustomAttributes(typeof(RequiredFieldAttribute), false).Length <= 0) { continue; } bool memberValid = true; if (member.MemberType == MemberTypes.Field) { FieldInfo field = (FieldInfo)member; memberValid = field.GetValue(thing) != null; } else if (member.MemberType == MemberTypes.Property) { PropertyInfo property = (PropertyInfo)member; memberValid = property.GetValue(thing, new object[0] { }) != null; } if (!memberValid) { _failedFields[ffIndex] = member.Name; } isValid = isValid && memberValid; } return(isValid); }
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="data"></param> public void Initialize <T>(object data) { System.Type t = typeof(T); MemberInfo[] members = t.GetMembers(BindingFlags.Public | BindingFlags.Instance); foreach (MemberInfo m in members) { if (m.MemberType == MemberTypes.Property) { PropertyInfo pi = t.GetProperty(m.Name); if (pi != null) { if (pi.PropertyType.Name.Equals("String")) { var ret = (string)pi.GetValue(data, null); if (ret == null) { pi.SetValue(data, "", null); } } else if (pi.PropertyType.Name.Equals("DateTime")) { var ret = (DateTime)pi.GetValue(data, null); if (ret == DateTime.MinValue) { pi.SetValue(data, new DateTime(1753, 1, 1, 0, 0, 0), null); } } else if (pi.PropertyType.Name.Equals("Byte")) { var ret = (Byte[])pi.GetValue(data, null); if (ret == null) { //pi.SetValue(data, "", null); } } } } } }
internal static MatchType Reflect(System.Type type) { MatchType type2 = new MatchType { type = type }; MemberInfo[] members = type.GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); ArrayList list = new ArrayList(); for (int i = 0; i < members.Length; i++) { MatchMember member = MatchMember.Reflect(members[i]); if (member != null) { list.Add(member); } } type2.fields = (MatchMember[])list.ToArray(typeof(MatchMember)); return(type2); }
internal static MemberInfo[] GetBindableMembers(TypeInfo typeInfo) { ReflectionSerializerVerifier.AssertEitherExtModelAttribute(typeInfo); var list = new List <MemberInfo>(); foreach (var mi in typeInfo.GetMembers(BindingFlags.Public | BindingFlags.Instance)) { if ((mi.MemberType == MemberTypes.Property && ReflectionUtil.TryGetSetter(mi) != null) || mi.MemberType == MemberTypes.Field) { if (mi.DeclaringType != null && !mi.DeclaringType.GetTypeInfo().IsAssignableFrom(typeof(RdReflectionBindableBase))) { list.Add(mi); } } } return(list.ToArray()); }
protected virtual void CheckAccessibleMembersAreVirtual(System.Type type) { MemberInfo[] members = type.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); foreach (var member in members) { if (member is PropertyInfo) { var property = (PropertyInfo)member; if (property.ShouldBeProxiable()) { MethodInfo[] accessors = property.GetAccessors(true); if (accessors != null) { foreach (var accessor in accessors) { CheckMethodIsVirtual(type, accessor); } } } } else if (member is MethodInfo) { var methodInfo = (MethodInfo)member; // avoid the check of properties getter and setter because already checked when the PropertyInfo was found. if (!IsPropertyMethod(methodInfo) && methodInfo.ShouldBeProxiable()) { CheckMethodIsVirtual(type, methodInfo); } } else if (member is FieldInfo) { var memberField = (FieldInfo)member; if (memberField.IsPublic || memberField.IsAssembly || memberField.IsFamilyOrAssembly) { EnlistError(type, "field " + member.Name + " should not be public nor internal (ecapsulate it in a property)."); } } } }
public bool PredictStaticMember(string input, System.Type type, List <string> list) { MemberInfo[] members = type.GetMembers(BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly); for (int i = 0; i < members.Length; i += 1) { string memberName = members[i].Name; if (memberName == "GetType" || memberName.StartsWith("op_") || memberName.StartsWith("get_") || memberName.StartsWith("set_") || memberName.StartsWith(".")) { continue; } if (input == "" || memberName.StartsWith(input)) { list.Add(memberName); } } return(members.Length > 0); }