C# RuntimeMethod.ToString方法代码示例

        /// <summary>
        /// Issues a linker request for the given runtime method.
        /// </summary>
        /// <param name="linkType">The type of link required.</param>
        /// <param name="method">The method the patched code belongs to.</param>
        /// <param name="methodOffset">The offset inside the method where the patch is placed.</param>
        /// <param name="methodRelativeBase">The base virtualAddress, if a relative link is required.</param>
        /// <param name="targetSymbolName">The linker symbol to link against.</param>
        /// <param name="offset">The offset to apply to the symbol to link against.</param>
        /// <returns>
        /// The return value is the preliminary virtualAddress to place in the generated machine
        /// code. On 32-bit systems, only the lower 32 bits are valid. The above are not used. An implementation of
        /// IAssemblyLinker may not rely on 64-bits being stored in the memory defined by position.
        /// </returns>
        public virtual long Link(LinkType linkType, RuntimeMethod method, int methodOffset, int methodRelativeBase, string targetSymbolName, IntPtr offset)
        {
            Debug.Assert(null != targetSymbolName, @"Symbol can't be null.");
            if (null == targetSymbolName)
                throw new ArgumentNullException(@"symbol");

            string symbolName = method.ToString();
            return this.Link(linkType, symbolName, methodOffset, methodRelativeBase, targetSymbolName, offset);
        }

        private void CompileMethod(RuntimeMethod method)
        {
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.Write(@"[Compiling]  ");
            Console.ForegroundColor = ConsoleColor.White;
            Console.WriteLine(method.ToString());
            Debug.WriteLine(@"Compiling " + method.ToString());
            using (IMethodCompiler mc = compiler.CreateMethodCompiler(this, method.DeclaringType, method))
            {
                mc.Compile();

                //try
                //{
                //    mc.Compile();
                //}
                //catch (Exception e)
                //{
                //    HandleCompilationException(e);
                //    throw;
                //}
            }
        }

        /// <summary>
        /// Creates a symbol operand for the given method.
        /// </summary>
        /// <param name="method">The method to create a symbol operand for.</param>
        /// <returns>The created symbol operand.</returns>
        public static SymbolOperand FromMethod(RuntimeMethod method)
        {
            string symbolName = method.ToString();

            return new SymbolOperand(BuiltInSigType.IntPtr, symbolName);
        }

        private string CreateSymbolName(RuntimeMethod symbol)
        {
            //if (symbol == null)
            //    throw new ArgumentNullException("symbol");

            //// TODO: If it is a generic method instance, then the symbol name needs to be carefully constructed. ~BMarkham,2/18/09
            //if (symbol.IsGeneric)
            //    throw new NotImplementedException();

            //StringBuilder sb = new StringBuilder();
            //sb.Append(CreateSymbolName(symbol.DeclaringType));
            //sb.Append('.');
            //sb.Append(symbol.Name);
            //sb.Append('(');
            //bool hasEmittedSignaturePart = false;
            //foreach (SigType parameterSignatureType in symbol.Signature.Parameters) {
            //    if (hasEmittedSignaturePart)
            //        sb.Append(',');
            //    sb.Append(parameterSignatureType.ToSymbolPart()); // FIXME : This obviously doesn't work! We need to emit class names.
            //    hasEmittedSignaturePart = true;
            //}
            //sb.Append(')');
            //return sb.ToString();

            string symbolName = symbol.ToString();
            return symbolName;
        }