private static IEnumerable<string> CollectErrorsOnMemberAndDescendents(Module module, IEnumerable<Exemption> exemptions, Func<ICustomAttributeProvider, string, string, IEnumerable<Exemption>, IEnumerable<string>> coreChecker) { var types = module.GetTypes().Where(type => !IsGeneratedCode(type)); return Enumerable.Concat( coreChecker(module, module.Name, "module", exemptions), types.SelectMany(type => CollectErrorsOnMemberAndDescendents(type, exemptions, coreChecker))); }
private static IEnumerable<ICommand> HandleModule(Module module) { IList<Type> types = module.GetTypes() .Where(t => t.IsPublic && !t.IsAbstract).ToList(); return types.Select(Activator.CreateInstance).OfType<ICommand>(); }
private void PrintModule(System.Reflection.Module module) { Console.WriteLine(); Console.WriteLine("Name: " + module.FullyQualifiedName); Console.WriteLine("Types:"); foreach (var type in module.GetTypes()) { Console.Write(" " + type.FullName); } Console.WriteLine(); }
/// <summary> /// 分析模块 /// </summary> public static void AnalyzeModule(Module module) { Console.WriteLine("模块名:" + module.Name); Console.WriteLine("模块的UUID:" + module.ModuleVersionId); Console.WriteLine("开始分析模块下的类型"); Type[] types = module.GetTypes(); foreach (Type type in types) { AnalyzeType(type); } }
public static void RegisterModule(Module module) { if (module == null) throw new ArgumentNullException("module"); foreach (Type type in module.GetTypes()) { RegisterType(type); } foreach (MethodInfo method in module.GetMethods()) { RegisterMethod(method); } }
public static IEnumerable <Type> FindConcreteImplementationsWithin(this Type type, System.Reflection.Module module) { // Must be an interface. if (type.IsInterface) { return (from t in module.GetTypes() where !t.IsAbstract from i in t.GetInterfaces() where i.Name == type.Name select t); } return(Enumerable.Empty <Type>()); }
public void Add(Module module) { ContractUtils.Requires(module != null); Type[] types; try { types = module.GetTypes(); } catch (Exception) { Console.WriteLine(module.Assembly.Location); return; } foreach (Type type in types) { if (type.Attributes.IsNested()) { continue; } string prefix = type.Namespace ?? ""; RNamespaceTreeNode ns = null; while (true) { RNamespaceTreeNode existing; if (_names.TryGetValue(prefix, out existing)) { if (ns == null) { existing.AddType(type); } else { existing.AddNamespace(ns); } break; } ContractUtils.Assert(prefix.Length > 0); int lastDot = prefix.LastIndexOf('.', prefix.Length - 1, prefix.Length); string name = (lastDot >= 0) ? prefix.Substring(lastDot + 1) : prefix; RNamespaceTreeNode newNs = new RNamespaceTreeNode(name); if (ns == null) { newNs.AddType(type); } else { newNs.AddNamespace(ns); } ns = newNs; _names.Add(prefix, ns); prefix = (lastDot >= 0) ? prefix.Substring(0, lastDot) : ""; } } }
private void LoadModule(TreeNode parent, Module md) { ModuleTreeNode tn = new ModuleTreeNode(md); parent.Nodes.Add(tn); foreach (Type t in md.GetTypes()) { if (!tn.Namespaces.ContainsKey((t.Namespace == null ? "-" : t.Namespace))) { TreeNode tnd = new NamespaceTreeNode((t.Namespace == null ? "-" : t.Namespace)); tn.Nodes.Add(tnd); tn.Namespaces.Add((t.Namespace == null ? "-" : t.Namespace), tnd); } LoadType(tn.Namespaces[(t.Namespace == null ? "-" : t.Namespace)], t); } }
public void AddModuleReference(Module m) { int top = modules != null ? modules.Length : 0; Module [] n = new Module [top + 1]; if (modules != null) modules.CopyTo (n, 0); n [top] = m; modules = n; if (m == RootContext.ToplevelTypes.Builder) return; foreach (var t in m.GetTypes ()) RegisterNamespace (t.Namespace); }
public MethodsModule(Module module) { var flags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic; foreach (var type in module.GetTypes()) { if (methods.Count >= MAX_METHODS) break; foreach (var method in type.GetMethods(flags)) { if (methods.Count >= MAX_METHODS) break; methods.Add(method); } } foreach (var method in module.GetMethods(flags)) { if (methods.Count >= MAX_METHODS) break; methods.Add(method); } }
public List<Type> getTypes(Module module) { return new List<Type>(module.GetTypes()); }
public void AddModuleReference (Module m) { int top = modules != null ? modules.Length : 0; Module [] n = new Module [top + 1]; if (modules != null) modules.CopyTo (n, 0); n [top] = m; modules = n; if (m == CodeGen.Module.Builder) return; foreach (Type t in m.GetTypes ()) RegisterNamespace (t.Namespace); }
private void ImportModule(Module module) { var type = module.GetTypes(); foreach (var t in type) { if (!t.IsPublic) { continue; } var ns = GetNameSpace(t.Namespace); if (typeof(void) == t) { continue; } ns.Append(ImportType(t)); } }
public static Type[] GetTypesPortable(Module module) { return module.GetTypes(); }
private void FindAllTypes(List<Type> newlyFoundObjects, Assembly assembly, Module module) { Type[] types; try { types = module.GetTypes(); } catch (ReflectionTypeLoadException ex) { //Since its possible that during enumeration, the GetTypes method can error, this will allow us //to enumerate the types that did not error. Log.Publish(MessageLevel.Error, "Reflection Load Error Occurred", assembly.GetName().Name, ex.ToString() + Environment.NewLine + String.Join(Environment.NewLine, ex.LoaderExceptions.Select(x => x.ToString())), ex); types = ex.Types; } foreach (Type assemblyType in types) { try { if ((object)assemblyType != null) { newlyFoundObjects.Add(assemblyType); } } catch (Exception ex) { Log.Publish(MessageLevel.Critical, MessageFlags.BugReport, "Static Constructor Error", null, null, ex); } } }
public ImportedModuleDefinition ImportModule (Module module, RootNamespace targetNamespace) { var module_definition = new ImportedModuleDefinition (module, this); module_definition.ReadAttributes (); Type[] all_types; try { all_types = module.GetTypes (); } catch (ReflectionTypeLoadException e) { all_types = e.Types; } ImportTypes (all_types, targetNamespace, false); return module_definition; }
private static TypeBuilder[] EmitSource(Module module, ModuleBuilder moduleB, Set replacedMethods, MetaDataMapper mapper) { ModuleEx moduleEx = new ModuleEx(module); ArrayList allMethods = new ArrayList(); ArrayList allCtors = new ArrayList(); ArrayList allTypes = new ArrayList(); Hashtable map = mapper.MapTable; //FieldInfo -> FieldBuilder, MethodInfo -> MethodBuilder... mapping //Type -> Type mapping is performed through moduleB.GetType(), because of array & ref types Type[] types = module.GetTypes(); Sort(types); foreach(Type type in types) { TypeBuilder typeB; if(type.DeclaringType != null) { typeB = (mapper.Map(type.DeclaringType) as TypeBuilder).DefineNestedType(type.Name, type.Attributes, mapper.Map(type.BaseType), mapper.Map(GetDeclaredInterfaces(type))); //Don't know how to declare nested enums :(( //Anyway, "nested-value-types BUG" affects them, too } else { typeB = moduleB.DefineType(type.FullName, type.Attributes, mapper.Map(type.BaseType), mapper.Map(GetDeclaredInterfaces(type))); } allTypes.Add(typeB); } //The end of type declarations... foreach(Type type in types) { TypeBuilder typeB = mapper.Map(type) as TypeBuilder; FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly); foreach(FieldInfo field in fields) { if(field.IsLiteral) continue; //Andrew: ZLP FieldAttributes attributes = AddInternalAttribute(field.Attributes); FieldBuilder fieldB = typeB.DefineField(field.Name, mapper.Map(field.FieldType), attributes); map[field] = fieldB; } PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly); foreach(PropertyInfo property in properties) { ParameterInfo[] parameters = property.GetIndexParameters(); Type[] paramTypes = new Type[parameters.Length]; for(int i=0; i<paramTypes.Length; i++) paramTypes[i] = mapper.Map( parameters[i].ParameterType); PropertyBuilder propertyB = typeB.DefineProperty(property.Name, property.Attributes, mapper.Map(property.PropertyType), paramTypes); map[property] = propertyB; } EventInfo[] events = type.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly); foreach(EventInfo Event in events) { EventBuilder eventB = typeB.DefineEvent(Event.Name, Event.Attributes, mapper.Map(Event.EventHandlerType)); map[Event] = eventB; } MethodInfo[] methods = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly); foreach(MethodInfo method in methods) { ParameterInfo[] parameters = method.GetParameters(); Type[] paramTypes = new Type[parameters.Length]; for(int i=0; i<paramTypes.Length; i++) paramTypes[i] = mapper.Map( parameters[i].ParameterType); MethodAttributes attributes = AddInternalAttribute(method.Attributes); MethodBuilder methodB = typeB.DefineMethod(method.Name, attributes, method.CallingConvention, mapper.Map(method.ReturnType), paramTypes); for(int i=0; i<paramTypes.Length; i++) methodB.DefineParameter(i+1, parameters[i].Attributes, parameters[i].Name); map[method] = methodB; if(!replacedMethods.Contains(method)) allMethods.Add(method); } ConstructorInfo[] ctors = type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly); foreach(ConstructorInfo ctor in ctors) { ParameterInfo[] parameters = ctor.GetParameters(); Type[] paramTypes = new Type[parameters.Length]; for(int i=0; i<paramTypes.Length; i++) paramTypes[i] = mapper.Map( parameters[i].ParameterType); MethodAttributes attributes = AddInternalAttribute(ctor.Attributes); ConstructorBuilder ctorB = typeB.DefineConstructor(attributes, ctor.CallingConvention, paramTypes); for(int i=0; i<paramTypes.Length; i++) ctorB.DefineParameter(i+1, parameters[i].Attributes, parameters[i].Name); map[ctor] = ctorB; if(!replacedMethods.Contains(ctor)) allCtors.Add(ctor); } if(type.IsValueType) typeB.DefineDefaultConstructor(MethodAttributes.Public); }//foreach type MethodInfo[] globalMethods = module.GetMethods(); foreach(MethodInfo method in globalMethods) { ParameterInfo[] parameters = method.GetParameters(); Type[] paramTypes = new Type[parameters.Length]; for(int i=0; i<paramTypes.Length; i++) paramTypes[i] = mapper.Map( parameters[i].ParameterType); MethodAttributes attributes = AddInternalAttribute(method.Attributes); MethodBuilder methodB = moduleB.DefineGlobalMethod(method.Name, attributes, method.CallingConvention, mapper.Map(method.ReturnType), paramTypes); for(int i=0; i<paramTypes.Length; i++) methodB.DefineParameter(i+1, parameters[i].Attributes, parameters[i].Name); map[method] = methodB; if(!replacedMethods.Contains(method)) allMethods.Add(method); } //The end of fields, methods, ctors declarations... foreach(MethodInfo method in allMethods) { ILGenerator generator = (mapper.Map(method) as MethodBuilder).GetILGenerator(); ProcessMethod(generator, moduleEx.GetMethodEx(method), method, mapper); } foreach(ConstructorInfo ctor in allCtors) { ILGenerator generator = (mapper.Map(ctor) as ConstructorBuilder).GetILGenerator(); ProcessMethod(generator, moduleEx.GetMethodEx(ctor), ctor, mapper); } TypeBuilder[] result = new TypeBuilder[allTypes.Count]; allTypes.CopyTo(result); return(result); }
public static void Refresh (Module module) { foreach (Type type in module.GetTypes()) Refresh (type); }
public ImportedModuleDefinition ImportModule (Module module, RootNamespace targetNamespace) { var module_definition = new ImportedModuleDefinition (module, this); module_definition.ReadAttributes (); Type extension_type = HasExtensionAttribute (CustomAttributeData.GetCustomAttributes (module)); Type[] all_types; try { all_types = module.GetTypes (); } catch (ReflectionTypeLoadException e) { all_types = e.Types; } ImportTypes (all_types, targetNamespace, extension_type); return module_definition; }
private void WriteNamespaces(XmlWriter writer, Module module) { Type[] types = module.GetTypes(); StringCollection namespaceNames = GetNamespaceNames(types); foreach (string namespaceName in namespaceNames) { string ourNamespaceName; if (namespaceName == null) { ourNamespaceName = "(global)"; } else { ourNamespaceName = namespaceName; } if (notEmptyNamespaces.ContainsKey(ourNamespaceName) || this.rep.DocumentEmptyNamespaces) { string namespaceSummary = null; if (this.rep.UseNamespaceDocSummaries) { if (namespaceName == null) namespaceSummary = assemblyDocCache.GetDoc("T:NamespaceDoc"); else namespaceSummary = assemblyDocCache.GetDoc("T:" + namespaceName + ".NamespaceDoc"); } bool isNamespaceDoc = false; if ((namespaceSummary == null) || (namespaceSummary.Length == 0)) namespaceSummary = this.rep.NamespaceSummaries[ourNamespaceName] as string; else isNamespaceDoc = true; if (this.rep.SkipNamespacesWithoutSummaries && (namespaceSummary == null || namespaceSummary.Length == 0)) { Trace.WriteLine(string.Format("Skipping namespace {0} because it has no summary...", namespaceName)); } else { Trace.WriteLine(string.Format("Writing namespace {0}...", namespaceName)); writer.WriteStartElement("namespace"); writer.WriteAttributeString("name", ourNamespaceName); if (namespaceSummary != null && namespaceSummary.Length > 0) { WriteStartDocumentation(writer); if (isNamespaceDoc) { writer.WriteRaw(namespaceSummary); } else { writer.WriteStartElement("summary"); writer.WriteRaw(namespaceSummary); writer.WriteEndElement(); } WriteEndDocumentation(writer); } else if (this.rep.ShowMissingSummaries) { WriteStartDocumentation(writer); WriteMissingDocumentation(writer, "summary", null, "Missing <summary> Documentation for " + namespaceName); WriteEndDocumentation(writer); } int classCount = WriteClasses(writer, types, namespaceName); Trace.WriteLine(string.Format("Wrote {0} classes.", classCount)); int interfaceCount = WriteInterfaces(writer, types, namespaceName); Trace.WriteLine(string.Format("Wrote {0} interfaces.", interfaceCount)); int structureCount = WriteStructures(writer, types, namespaceName); Trace.WriteLine(string.Format("Wrote {0} structures.", structureCount)); int delegateCount = WriteDelegates(writer, types, namespaceName); Trace.WriteLine(string.Format("Wrote {0} delegates.", delegateCount)); int enumCount = WriteEnumerations(writer, types, namespaceName); Trace.WriteLine(string.Format("Wrote {0} enumerations.", enumCount)); writer.WriteEndElement(); } } else { Trace.WriteLine(string.Format("Discarding namespace {0} because it does not contain any documented types.", ourNamespaceName)); } } }
public static void Refresh(Module module) { if(module != null) { foreach(Type type in module.GetTypes()) { Refresh(null, type); } } }