C# IAssembly.GetAllTypes方法代码示例

        public override void Visit(IAssembly assembly)
        {
            AppendElementType(assembly);
            output.Append(assembly.Name.Value);

            Visit(assembly.GetAllTypes());
            System.Console.WriteLine(output);
        }

 public AssemblyBuilder Load(IAssembly assembly) {
   //first create (but do not initialize) all typeBuilder builders, since they are needed to create member builders.
   this.typeBuilderAllocator.Traverse(assembly);
   //next create (but do not initialize) builder for all other kinds of typeBuilder members, since there may be forward references during initialization
   this.memberBuilderAllocator.Traverse(assembly);
   //now initialize all the builders
   this.initializingTraverser.TraverseChildren(assembly);
   //create all of the types
   this.typeCreator.Traverse(assembly.GetAllTypes());
   //set entry point on assembly if defined
   if (!(assembly.EntryPoint is Dummy)) this.AssemblyBuilder.SetEntryPoint((MethodInfo)this.mapper.GetMethod(assembly.EntryPoint));
   //now the assembly is ready for action
   return this.AssemblyBuilder;
 }

            private ICustomAttribute CreateAttribute(string typeName, IAssembly seedCoreAssembly, string argument = null)
            {
                var type = seedCoreAssembly.GetAllTypes().FirstOrDefault(t => t.FullName() == typeName);
                if (type == null)
                {
                    throw new FacadeGenerationException(String.Format("Cannot find {0} type in seed core assembly.", typeName));
                }

                IEnumerable<IMethodDefinition> constructors = type.GetMembersNamed(_seedHost.NameTable.Ctor, false).OfType<IMethodDefinition>();

                IMethodDefinition constructor = null;
                if (argument != null)
                {
                    constructor = constructors.SingleOrDefault(m => m.ParameterCount == 1 && m.Parameters.First().Type.AreEquivalent("System.String"));
                }
                else
                {
                    constructor = constructors.SingleOrDefault(m => m.ParameterCount == 0);
                }

                if (constructor == null)
                {
                    throw new FacadeGenerationException(String.Format("Cannot find {0} constructor taking single string argument in seed core assembly.", typeName));
                }

                var attribute = new CustomAttribute();
                attribute.Constructor = constructor;

                if (argument != null)
                {
                    var argumentExpression = new MetadataConstant();
                    argumentExpression.Type = _seedHost.PlatformType.SystemString;
                    argumentExpression.Value = argument;

                    attribute.Arguments = new List<IMetadataExpression>(1);
                    attribute.Arguments.Add(argumentExpression);
                }

                return attribute;
            }

        private static IEnumerable<string> EnumerateDocIdsToForward(IAssembly contractAssembly)
        {
            // Make note that all type forwards (including nested) implement INamespaceAliasForType, so do
            // not be tempted to filter using it, instead, we look at the aliased type to them.
            var typeForwardsToForward = contractAssembly.ExportedTypes.Select(alias => alias.AliasedType)
                                                                      .OfType<INamespaceTypeReference>();

            var typesToForward = contractAssembly.GetAllTypes().Where(t => TypeHelper.IsVisibleOutsideAssembly(t))
                                                               .OfType<INamespaceTypeDefinition>();
            List<string> result = typeForwardsToForward.Concat(typesToForward)
                                        .Select(type => TypeHelper.GetTypeName(type, NameFormattingOptions.DocumentationId)).ToList();
            
            foreach(var type in typesToForward)
            {
                AddNestedTypeDocIds(result, type);
            }

            return result;
        }

        private static IEnumerable<string> EnumerateDocIdsToForward(IAssembly contractAssembly)
        {
            // Use INamedTypeReference instead of INamespaceTypeReference in order to also include nested
            // class type-forwards.
            var typeForwardsToForward = contractAssembly.ExportedTypes.Select(alias => alias.AliasedType)
                                                                      .OfType<INamedTypeReference>();

            var typesToForward = contractAssembly.GetAllTypes().Where(t => TypeHelper.IsVisibleOutsideAssembly(t))
                                                               .OfType<INamespaceTypeDefinition>();
            List<string> result = typeForwardsToForward.Concat(typesToForward)
                                        .Select(type => TypeHelper.GetTypeName(type, NameFormattingOptions.DocumentationId)).ToList();
            
            foreach(var type in typesToForward)
            {
                AddNestedTypeDocIds(result, type);
            }

            return result;
        }

 private IEnumerable<TypeMetricsWithMethodMetrics> AnalyzeTypes(IAssembly assembly, PdbReader pdb, IMetadataHost host)
 {
     return from type in assembly.GetAllTypes()
            where type.Name.ToString() != "<Module>"
            select TypeAndMethods(pdb, host, type);
 }

    void CheckSurface(IAssembly contractAssembly, IAssembly originalAssembly)
    {
      Contract.Requires(contractAssembly != null);

      // Check each type in contract Assembly
      foreach (var type in contractAssembly.GetAllTypes())
      {
        if (type is INestedTypeDefinition) continue; // visited during parent type
        CheckSurface(type, originalAssembly);
      }
    }

 private static IEnumerable<INamedTypeDefinition> getTypesNotGenerated(IAssembly assembly)
 {
     return from t in assembly.GetAllTypes()
            where !HasAnyGeneratedCodeAttributes(t)
            select t;
 }

 public override void TraverseChildren(IAssembly assembly) {
   foreach (var t in assembly.GetAllTypes()) this.Traverse(t);
 }