C# IMetadataHost类代码示例

 internal TypeInferencer(INamedTypeReference containingType, IMetadataHost host) {
   Contract.Requires(containingType != null);
   Contract.Requires(host != null);
   this.containingType = containingType;
   this.host = host;
   this.platformType = containingType.PlatformType;
 }

 public FieldAssignmentReplacementBuilder(FieldReference field, IMetadataHost host, ExpressionStatement assignment, ReplacementRegistry registry)
 {
     this.field = field;
     this.host = host;
     this.assignment = assignment;
     this.registry = registry;
 }

 /// <summary>
 /// For an iterator method, find the closure class' MoveNext method and return its body.
 /// </summary>
 /// <param name="host"></param>
 /// <param name="possibleIterator">The (potential) iterator method.</param>
 /// <returns>Dummy.MethodBody if <paramref name="possibleIterator"/> does not fit into the code pattern of an iterator method, 
 /// or the body of the MoveNext method of the corresponding closure class if it does.
 /// </returns>
 public static IMethodBody/*?*/ FindClosureMoveNext(IMetadataHost host, ISourceMethodBody/*!*/ possibleIterator) {
   if (possibleIterator is Dummy) return null;
   var nameTable = host.NameTable;
   var possibleIteratorBody = possibleIterator.Block;
   foreach (var statement in possibleIteratorBody.Statements) {
     var expressionStatement = statement as IExpressionStatement;
     if (expressionStatement != null)
       return FirstStatementIsIteratorCreation(host, possibleIterator, nameTable, statement);
     break;
   }
   foreach (var statement in possibleIteratorBody.Statements){
     //var lds = statement as ILocalDeclarationStatement;
     //if (lds != null) {
     //  if (lds.InitialValue != null)
     //    return null;
     //  else
     //    continue;
     //}
     var returnStatement = statement as IReturnStatement;
     if (returnStatement == null) return null;
     var blockExpression = returnStatement.Expression as IBlockExpression;
     if (blockExpression == null) return null;
     foreach (var s in blockExpression.BlockStatement.Statements) {
       return FirstStatementIsIteratorCreation(host, possibleIterator, nameTable, s);
     }
   }
   return null;
 }

 internal AnonymousDelegateCachingRemover(IMetadataHost host, Hashtable<IAnonymousDelegate>/*?*/ delegatesCachedInFields,
   Hashtable<LocalDefinition, AnonymousDelegate>/*?*/ delegatesCachedInLocals)
   : base(host) {
   Contract.Requires(host != null);
   this.delegatesCachedInFields = delegatesCachedInFields;
   this.delegatesCachedInLocals = delegatesCachedInLocals;
 }

 private static IMethodBody/*?*/ FirstStatementIsIteratorCreation(IMetadataHost host, ISourceMethodBody possibleIterator, INameTable nameTable, IStatement statement) {
   ICreateObjectInstance createObjectInstance = GetICreateObjectInstance(statement);
   if (createObjectInstance == null) {
     // If the first statement in the method body is not the creation of iterator closure, return a dummy.
     // Possible corner case not handled: a local is used to hold the constant value for the initial state of the closure.
     return null;
   }
   ITypeReference closureType/*?*/ = createObjectInstance.MethodToCall.ContainingType;
   ITypeReference unspecializedClosureType = ContractHelper.Unspecialized(closureType);
   if (!AttributeHelper.Contains(unspecializedClosureType.Attributes, host.PlatformType.SystemRuntimeCompilerServicesCompilerGeneratedAttribute))
     return null;
   INestedTypeReference closureTypeAsNestedTypeReference = unspecializedClosureType as INestedTypeReference;
   if (closureTypeAsNestedTypeReference == null) return null;
   ITypeReference unspecializedClosureContainingType = ContractHelper.Unspecialized(closureTypeAsNestedTypeReference.ContainingType);
   if (closureType != null && TypeHelper.TypesAreEquivalent(possibleIterator.MethodDefinition.ContainingTypeDefinition, unspecializedClosureContainingType)) {
     IName MoveNextName = nameTable.GetNameFor("MoveNext");
     foreach (ITypeDefinitionMember member in closureType.ResolvedType.GetMembersNamed(MoveNextName, false)) {
       IMethodDefinition moveNext = member as IMethodDefinition;
       if (moveNext != null) {
         ISpecializedMethodDefinition moveNextGeneric = moveNext as ISpecializedMethodDefinition;
         if (moveNextGeneric != null)
           moveNext = moveNextGeneric.UnspecializedVersion.ResolvedMethod;
         return moveNext.Body;
       }
     }
   }
   return null;
 }

 private static int CalculateCyclomaticComplexity(this IMethodDefinition method, PdbReader pdb, IMetadataHost host)
 {
     var methodBody = method.Decompile(pdb, host);
     var cyclomaticComplexityCalculator = new CyclomaticComplexityCalculator();
     cyclomaticComplexityCalculator.Traverse(methodBody.Statements());
     return cyclomaticComplexityCalculator.Result;
 }

 private static void AnalyzeFileInHost(string toAnalyse, IMetadataHost host)
 {
     AnalyzeFileWithPdb(toAnalyse, host, (pdb) =>
     {
         AnalyzeAssembly(host.LoadUnitFrom(toAnalyse) as IAssembly, pdb);
     });
 }

 private void AnalyzeAssemblyInHost(IMetadataHost host, IAssembly assembly, string pdbPath)
 {
     if (pdbPath != null)
         AnalyzeAssemblyInHostWithProgramDatabase(assembly, host, pdbPath);
     else
         AnalyzeTypes(assembly, null, host, Report);
 }

 public SpecifiedMethodCallRegistrar(IMetadataHost host, ILogger log, ReplacementRegistry registry)
 {
     this.host = host;
     this.log = log;
     this.registry = registry;
     reflector = new UnitReflector(host);
 }

 private TypeMetricsWithMethodMetrics TypeAndMethods(PdbReader pdb, IMetadataHost host, INamedTypeDefinition type)
 {
     var typeAndMethods = new TypeMetricsWithMethodMetrics();
     typeAndMethods.AddMethodReports(AnalyzeMethods(type, pdb, host));
     typeAndMethods.Type = AnalyzeType(type, pdb, typeAndMethods.Methods);
     return typeAndMethods;
 }

 public static SourceMethodBody Decompile(this IMethodDefinition method, PdbReader pdb, IMetadataHost host)
 {
     return new SourceMethodBody(method.Body, host, pdb, pdb,
                DecompilerOptions.Loops |
                DecompilerOptions.AnonymousDelegates |
                DecompilerOptions.Iterators);
 }

    internal static void Reachable(
      IMetadataHost host,
      ISlice<MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice,
      HashSet<object> thingsToKeep,
      HashSet<uint> methodsWhoseBodiesShouldBeKept,
      out Dictionary<IMethodDefinition, uint> contractOffsets
      ) {

      Contract.Requires(host != null);
      Contract.Requires(slice != null);
      Contract.Requires(thingsToKeep != null);
      Contract.Requires(methodsWhoseBodiesShouldBeKept != null);

      var traverser = new MetadataTraverser();
      var me = new FindReachable(host, traverser, slice, thingsToKeep, methodsWhoseBodiesShouldBeKept);
      traverser.TraverseIntoMethodBodies = true;
      traverser.PreorderVisitor = me;

      var methodsToTraverse = slice.Methods;
      foreach (var m in methodsToTraverse) {
        var methodDefinition = m.reference.ResolvedMethod;
        traverser.Traverse(methodDefinition);
      }

      foreach (var c in slice.Chains) {
        VisitChain(c, traverser);
      }
      contractOffsets = me.contractOffsets;
      return;
    }

        public static IModule RewriteModule(IMetadataHost host, ILocalScopeProvider localScopeProvider, ISourceLocationProvider sourceLocationProvider, IModule module)
        {
            var m = new PropertyChangedWeaver(host);
            m._rewriter = new ReferenceReplacementRewriter(host, localScopeProvider, sourceLocationProvider);

            return m.Rewrite(module);
        }

 public static int Of(IMethodDefinition method, PdbReader pdb, IMetadataHost host)
 {
     if (method.HasOperations())
         return method.CalculateStatements(pdb, host);
     else
         return 0;
 }

        public SharpMockTypes(IMetadataHost host)
        {
            var funcs = new Dictionary<int, INamedTypeReference>();
            var acts = new Dictionary<int, INamedTypeReference>();

            var sharpMockTypes =
                host.LoadUnitFrom(
                    System.Reflection.Assembly.GetExecutingAssembly().Location);
            var sharpMockDelegateTypes = sharpMockTypes as IAssembly;
            Unit = sharpMockTypes;

            foreach (var type in sharpMockDelegateTypes.GetAllTypes())
            {
                if (type.Name.Value == "VoidAction")
                {
                    acts.Add(type.GenericParameterCount, type);
                }

                if (type.Name.Value == "Function")
                {
                    funcs.Add(type.GenericParameterCount - 1, type);
                }
            }

            functions = new GenericMethodTypeDictionary(funcs, "Unable to find type Function<> with {0} input parameter arguments.");
            actions = new GenericMethodTypeDictionary(acts, "Unable to find type VoidAction<> with {0} parameter arguments.");
        }