private static void ProcessType (TreeIter parent, System.Type t) { foreach (MemberInfo mi in t.GetMembers ()) { store.AppendValues (parent, mi.Name, mi.ToString ()); count++; } }
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; } } } }
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; }
public static AssemblyType CreateAssemblyType(AssemblyImporter importer, System.Type systemType) { AssemblyType assemblyType = null; if (systemType.IsEnum) { assemblyType = new AssemblyEnumeration (importer, systemType); assemblyType.Begin (); } else if (systemType.IsInterface) { assemblyType = new AssemblyInterface (importer, systemType); assemblyType.Begin (); } else if (systemType.IsClass) { assemblyType = new AssemblyClass (importer, systemType); assemblyType.Begin (); } else if (systemType.IsPrimitive) { assemblyType = new AssemblyDataType (importer, systemType); assemblyType.Begin (); } else if (systemType.IsValueType) { if (systemType.GetMembers (AssemblyHelper.BINDING_FLAGS).Length == 1) { assemblyType = new AssemblyDataType (importer, systemType); assemblyType.Begin (); } else { assemblyType = new AssemblyStruct (importer, systemType); assemblyType.Begin (); } } else { System.Console.WriteLine ("System.FullName: "+systemType.FullName+" sealed: "+systemType.IsSealed ); } return assemblyType; }
private static UiItem[][] getUiItemList(System.Type lType) { UiItemUV lOut = new UiItemUV(); var lMembers = lType.GetMembers(); foreach (var lMember in lMembers) { UiAttributeBase[] lUIAttributes = (UiAttributeBase[])lMember.GetCustomAttributes(typeof(UiAttributeBase), false); foreach (var lAttribute in lUIAttributes) { lOut.Add(new UiItem(lAttribute, lMember)); } //if (lUIAttributes.Length > 0) //{ // lOut.Add(new UiItem(lUIAttributes[0], lMember)); //} } return lOut.toSortedArray(); }
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)."); } } } }
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; MethodInfo[] accessors = property.GetAccessors(false); if (accessors != null) { foreach (var accessor in accessors) { CheckMethodIsVirtual(type, accessor); } } } else if (member is MethodInfo) { if (member.DeclaringType == typeof (object) && member.Name == "GetType") { // object.GetType is ignored continue; } CheckMethodIsVirtual(type, (MethodInfo) member); } 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"); } } } }
PropertyInfo[] createSerializeMethod(System.Type lType, bool pNeedSerializeIn, bool pNeedSerializeOut) { List<PropertyInfo> lOut = new List<PropertyInfo>(); var lMembers = lType.GetMembers(); foreach (var lMember in lMembers) { zzSerializeAttribute[] lAttributes = (zzSerializeAttribute[])lMember.GetCustomAttributes(typeof(zzSerializeAttribute), true); if (lAttributes.Length > 0 && ( pNeedSerializeIn?lAttributes[0].serializeIn:true) && ( pNeedSerializeOut?lAttributes[0].serializeOut:true)) { lOut.Add((PropertyInfo)lMember); } } return lOut.ToArray(); }
/// <summary> /// Adds the type to the set of types, and then uses reflection to add /// all public fields, properties and methods to the set of types. /// </summary> protected static void AddAllSubTypes(HashSet<System.Type> typeSet, System.Type t) { AddSubType(typeSet, t); MemberInfo[] memberInfos = t.GetMembers(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly); foreach (MemberInfo memberInfo in memberInfos) { if (memberInfo.MemberType == MemberTypes.Field) { FieldInfo fieldInfo = memberInfo as FieldInfo; AddSubType(typeSet, fieldInfo.FieldType); } else if (memberInfo.MemberType == MemberTypes.Property) { PropertyInfo propertyInfo = memberInfo as PropertyInfo; AddSubType(typeSet, propertyInfo.PropertyType); } else if (memberInfo.MemberType == MemberTypes.Method) { MethodInfo methodInfo = memberInfo as MethodInfo; if (methodInfo.IsGenericMethod) { continue; } if (methodInfo.ReturnType != typeof(void)) { AddSubType(typeSet, methodInfo.ReturnType); } foreach (ParameterInfo pi in methodInfo.GetParameters() ) { AddSubType(typeSet, pi.ParameterType); } } } }
void ProcessType (DemoTreeNode parent, System.Type t) { foreach (MemberInfo mi in t.GetMembers ()) parent.AddChild (new DemoTreeNode (mi.Name, mi.ToString ())); }
public static IEnumerable<MemberInfo> GetMembers(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; } } }
private List<string> getComponentMembers( System.Type type ) { var propertyType = this.getPropertyType(); var members = type .GetMembers( BindingFlags.Instance | BindingFlags.Public ) .Where( x => x.MemberType == MemberTypes.Field || x.MemberType == MemberTypes.Property ); var list = new List<string>(); foreach( var member in members ) { System.Type memberType = null; if( member is FieldInfo ) { memberType = ( (FieldInfo)member ).FieldType; } else { var property = (PropertyInfo)member; if( !property.CanWrite || property.GetSetMethod() == null ) continue; memberType = property.PropertyType; } if( !propertyType.IsAssignableFrom( memberType ) ) continue; list.Add( string.Format( "{0}.{1}", type.Name, member.Name ) ); } return list; }
private static void ProcessType(TreeIter parent, System.Type t) { bool iterset = false; TreeIter iter = TreeIter.Zero; //if(!(t==typeof(Gtk.Widget) || t.IsSubclassOf(typeof(Gtk.Widget)))) // return; foreach (MemberInfo mi in t.GetMembers ()) { // properties object[] attrs = mi.GetCustomAttributes(typeof(GLib.PropertyAttribute), false); if(attrs != null && attrs.Length > 0) { PropertyInfo prop = (PropertyInfo)mi; if(prop.DeclaringType != t) continue; foreach(GLib.PropertyAttribute attr in attrs) { if(!iterset) { iterset = true; iter = store.AppendValues (parent, "<tt><b>"+NiceTypeName(t)+"</b></tt><small>" + Inherits(t)+"</small>", t.ToString()+" : "+t.BaseType.ToString(), t.Name); } string rw = ((prop.CanRead)?"r":"") + ((prop.CanWrite)?"w":""); store.AppendValues (iter, String.Format("<small>({0})</small>\t<tt><b>{1}</b></tt><small>: {2}</small>", rw, attr.Name, NiceTypeName(prop.PropertyType)), prop.PropertyType.ToString(), attr.Name); } } // signals object[] signals = mi.GetCustomAttributes(typeof(GLib.SignalAttribute), false); if(signals != null && signals.Length > 0) { EventInfo ev = (EventInfo)mi; if(ev.DeclaringType != t) continue; foreach(GLib.SignalAttribute signal in signals) { if(!iterset) { iterset = true; iter = store.AppendValues (parent, "<tt><b>"+NiceTypeName(t)+"</b></tt><small>" + Inherits(t)+"</small>", t.ToString()+" : "+t.BaseType.ToString(), t.Name); } ParameterInfo[] delegateparams = ev.EventHandlerType.GetMethod("Invoke").GetParameters(); string[] evargs = new string[delegateparams.Length]; for(int i=0; i < delegateparams.Length; i++) { evargs[i] = NiceTypeName(delegateparams[i].ParameterType)+" "+ delegateparams[i].Name; } TreeIter eventiter = store.AppendValues (iter, String.Format("<small>(sig)</small>\t<tt><b><span foreground=\"#000099\">{0}</span></b></tt><small>{1}</small>", signal.CName, /*NiceTypeName(ev.EventHandlerType) +*/ "("+ String.Join(", ", evargs)+")"), "signal", signal.CName); WriteEventArgs(eventiter, delegateparams[1].ParameterType); } } } if(iterset) { bool implicit_constructor = false; bool no_constructor = true; foreach (MemberInfo mi in t.GetMembers ()) { if(mi is ConstructorInfo) { ConstructorInfo constructor = (ConstructorInfo)mi; ParameterInfo[] p = constructor.GetParameters(); if(p.Length == 0) implicit_constructor = true; if(p.Length == 1 && p[0].ParameterType == typeof(IntPtr)) continue; no_constructor = false; string[] ptext = new string[p.Length]; for(int i=0; i<p.Length; i++) { ptext[i] = "<small>" + NiceTypeName(p[i].ParameterType) + "</small> <b>" + p[i].Name + "</b>"; } store.AppendValues (iter, "<small>new</small>\t<tt>(" + String.Join(", ", ptext) + ")</tt>", "konstruktor", ""); } } if(implicit_constructor) store.SetValues(iter, "<tt><b><span foreground=\"#770000\">"+NiceTypeName(t)+"</span></b></tt><small>" + Inherits(t)+"</small>", t.ToString()+" : "+t.BaseType.ToString(), t.Name); else if(no_constructor) store.SetValues(iter, "<tt><b><span foreground=\"#999999\">"+NiceTypeName(t)+"</span></b></tt><small>" + Inherits(t)+"</small>", t.ToString()+" : "+t.BaseType.ToString(), t.Name); } }
/// <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; } }
private void BeginWithType(System.Type type) { if (type.IsEnum) { if (Elements [type.FullName] == null && ImportEnumerations) { AssemblyEnumeration enm = new AssemblyEnumeration (this, type); enm.Begin (); } } else if (type.IsInterface) { if (Elements [type.FullName] == null && ImportInterfaces) { AssemblyInterface intrface = new AssemblyInterface (this, type); intrface.Begin (); } } else if (type.IsClass) { if (Elements [type.FullName] == null && ImportClasses) { AssemblyClass cls = new AssemblyClass (this, type); cls.Begin (); } } else if (type.IsPrimitive) { if (Elements [type.FullName] == null) { AssemblyDataType dataType = new AssemblyDataType (this, type); dataType.Begin (); } } else if (type.IsValueType) { if (Elements [type.FullName] == null) { if (type.GetMembers (AssemblyHelper.BINDING_FLAGS).Length == 1) { AssemblyDataType dataType = new AssemblyDataType (this, type); dataType.Begin (); } else if (ImportStructs) { AssemblyStruct structure = new AssemblyStruct (this, type); structure.Begin (); } } } }