C# IMethodReference类代码示例

 // Put return type after the signature
 public override string GetMethodSignature(IMethodReference method, NameFormattingOptions formattingOptions)
 {
     string baseSig = base.GetMethodSignature(method, (formattingOptions & ~NameFormattingOptions.ReturnType));
     StringBuilder sb = new StringBuilder(baseSig);
     AppendReturnTypeSignature(method, (formattingOptions | NameFormattingOptions.ReturnType), sb);
     return sb.ToString();
 }

 public CustomAttribute(
     IMethodReference constructor,
     ITypeReference type,
     ReadOnlyArray<MetadataConstant> positionalArguments) :
     this(constructor, type, positionalArguments, ReadOnlyArray<IMetadataNamedArgument>.Empty)
 {
 }

 /// <summary>
 /// Returns the unspecialized version of the given method reference.
 /// </summary>
 public static IMethodReference Unspecialize(IMethodReference method) {
   var smr = method as ISpecializedMethodReference;
   if (smr != null) return smr.UnspecializedVersion;
   var gmir = method as IGenericMethodInstanceReference;
   if (gmir != null) return gmir.GenericMethod;
   return method;
 }

 private static IMethodDefinition ResolveUnspecializedMethodOrThrow(IMethodReference methodReference) {
   var resolvedMethod = Sink.Unspecialize(methodReference).ResolvedMethod;
   if (resolvedMethod == Dummy.Method) { // avoid downstream errors, fail early
     throw new TranslationException(ExceptionType.UnresolvedMethod, MemberHelper.GetMethodSignature(methodReference, NameFormattingOptions.None));
   }
   return resolvedMethod;
 }

 public bool Matches(IMethodReference method)
 {
     var sig = CreateIdentifier(method);
     _log.Debug("matching: "+sig);
     //AKB to rethink
     return sig.MethodNameWithoutParams == _identifier.MethodNameWithoutParams;
 }

        private void AddAlternativeInvocation(BlockStatement block,
            IMethodDefinition fakeMethod, IMethodReference originalCall)
        {
            var context = new ReplacementMethodConstructionContext(host, originalCall, fakeMethod, block, log, null);
            var methodBuilder = context.GetMethodBuilder();

            methodBuilder.BuildMethod();
        }

 public static MethodIdentifier CreateIdentifier(IMethodReference method)
 {
     method = MemberHelper.UninstantiateAndUnspecialize(method);
     return new MethodIdentifier(MemberHelper.GetMethodSignature(method,
             NameFormattingOptions.Signature |
             NameFormattingOptions.TypeParameters |
             NameFormattingOptions.ParameterModifiers));
 }

        public ReplacementMethodConstructionContext(IMetadataHost host, IMethodReference originalCall, IMethodDefinition fakeMethod, BlockStatement block, ILogger log, IReplaceableReference originalReference)
        {
            this.host = host;
            this.block = block;
            this.log = log;
            this.originalReference = originalReference;
            this.originalCall = originalCall;

            fakeMethodParameters = fakeMethod.Parameters;
            returnType = fakeMethod.Type;
        }

        public static IMethodDefinition ResolveMethodThrowing(IMethodReference method)
        {
            IMethodDefinition result = method.ResolvedMethod;
            if (result == Dummy.Method ||
                result == null)
            {
                throw new Exception(String.Format("Cannot resolve member '{0}'. Are all dependent assemblies loaded?", method.ToString()));
            }

            Debug.Assert(!result.GetType().Name.Contains("Dummy"));
            return result;
        }

    /// <summary>
    /// Creates the normalize method definition.
    /// </summary>
    /// <param name="methodReference">The method reference.</param>
    /// <returns>A new NormalizeMethodDefinition instance, based on the input.</returns>
    internal static NormalizeMethodDefinition CreateNormalizeMethodDefinition(IMethodReference methodReference)
    {
      if (methodReference == null)
      {
        throw new ArgumentNullException("methodReference");
      }

      ITypeReference typeReference = methodReference.DeclaringType as ITypeReference;

      return new NormalizeMethodDefinition(
        typeReference.Name,
        typeReference.Namespace,
        methodReference.Name,
        BuildParameterList(methodReference.Parameters),
        methodReference.ReturnType.Type.ToString(),
        string.Empty);
    }

    internal string Mangle(IMethodReference method) {
      Contract.Requires(method != null);

      method.ResolvedMethod.Dispatch(this); //compute the hash
      var sb = new StringBuilder();
      sb.Append('_');
      sb.Append((uint)this.hash);
      sb.Append('_');
      this.AppendSanitizedName(sb, TypeHelper.GetTypeName(method.ContainingType));
      sb.Append('_');
      this.AppendSanitizedName(sb, method.Name.Value);
      foreach (var par in method.Parameters) {
        sb.Append('_');
        this.AppendSanitizedName(sb, TypeHelper.GetTypeName(par.Type, NameFormattingOptions.OmitContainingType));
      }
      return sb.ToString();
    }

        private static bool TryGetCompatibileModifier(IMethodDefinition resolvedMethod, out IMethodReference accessor)
        {
            var result = resolvedMethod.ContainingTypeDefinition.Properties
                .FirstOrDefault(p => p.Setter != null && p.Setter.Name.UniqueKey != resolvedMethod.Name.UniqueKey
                && TypeHelper.ParameterListsAreEquivalent(p.Setter.Parameters, resolvedMethod.Parameters));
            if (result == null)
            {
                accessor = null;
                return false;
            }
            else
            {
                accessor = result.Setter;
                return true;
            }

        }

        private void AddDependencyForCalledMethod(IMethodReference method)
        {
            AddDependency(method.ContainingType, false);

            this._methodDependents.Add(method);
        }

 internal SecurityCustomAttribute(SecurityAttribute containingSecurityAttribute, IMethodReference constructorReference, IMetadataNamedArgument[]/*?*/ namedArguments) {
   this.ContainingSecurityAttribute = containingSecurityAttribute;
   this.ConstructorReference = constructorReference;
   this.NamedArguments = namedArguments;
 }

 internal CustomAttribute(PEFileToObjectModel peFileToObjectModel, uint attributeRowId, IMethodReference constructor,
   IMetadataExpression[]/*?*/ arguments, IMetadataNamedArgument[]/*?*/ namedArguments)
   : base(peFileToObjectModel) {
   this.AttributeRowId = attributeRowId;
   this.Constructor = constructor;
   this.Arguments = arguments;
   this.NamedArguments = namedArguments;
 }