C# MethodBase.GetType方法代码示例

 /// <summary>
 /// Initializes a new instance of the <see cref="axScript3.NetFunction"/> class.
 /// </summary>
 /// <param name='function'>
 /// Function.
 /// </param>
 /// <param name='target'>
 /// Owner of function, leave null if static function.
 /// </param>
 public NetFunction(MethodBase function, object target = null)
 {
     Method = function;
     Inputs = function.GetParameters();
     Output = function.GetType();
     Target = target;
     HasParamArray = Inputs.Length > 0 && Inputs[Inputs.Length - 1].GetCustomAttributes(typeof (ParamArrayAttribute), false).Length > 0;
 }

        private static Function EmitFunction(Module module, MethodBase method)
        {
            var methodInfo = method as MethodInfo;
            var methodConstructor = method as ConstructorInfo;
            var declaringType = method.DeclaringType;
            if (methodInfo == null && methodConstructor == null)
                throw new CudaSharpException("Unknown MethodBase type " + method.GetType().FullName);
            if (declaringType == null)
                throw new CudaSharpException("Could not find the declaring type of " + method.Name.StripNameToValidPtx());

            var parameters = method.GetParameters().Select(p => p.ParameterType);
            if (methodConstructor != null)
                parameters = new[] { declaringType.MakeByRefType() }.Concat(parameters);
            if (methodInfo != null && methodInfo.IsStatic == false)
            {
                if (declaringType.IsValueType == false)
                    throw new CudaSharpException("Cannot compile object instance methods (did you forget to mark the method as static?)");
                parameters = new[] { declaringType.MakeByRefType() }.Concat(parameters);
            }
            var llvmParameters =
                parameters.Select(t => ConvertType(module, t)).ToArray();
            var funcType = new FunctionType(ConvertType(module, methodInfo == null ? typeof(void) : methodInfo.ReturnType), llvmParameters);

            var intrinsic = method.GetCustomAttribute<Gpu.BuiltinAttribute>();
            if (intrinsic != null)
            {
                var name = intrinsic.Intrinsic;
                var preExisting = module.GetFunction(name);
                if (preExisting != null)
                    return preExisting;
                return module.CreateFunction(name, funcType);
            }

            var function = module.CreateFunction(methodConstructor == null ? method.Name.StripNameToValidPtx() : declaringType.Name.StripNameToValidPtx() + "_ctor", funcType);

            var block = new Block("entry", module.Context, function);
            var writer = new InstructionBuilder(module.Context, block);

            var opcodes = method.Disassemble().ToList();
            FindBranchTargets(opcodes, module.Context, function);

            var body = method.GetMethodBody();
            var efo = new EmitFuncObj(module, function, body, writer, null, new Stack<Value>(),
                body == null ? null : new Value[body.LocalVariables.Count], new Value[llvmParameters.Length]);

            PrintHeader(efo);
            foreach (var opcode in opcodes)
            {
                if (EmitFunctions.ContainsKey(opcode.Opcode) == false)
                    throw new CudaSharpException("Unsupported CIL instruction " + opcode.Opcode);
                var func = EmitFunctions[opcode.Opcode];
                efo.Argument = opcode.Parameter;
                func(efo);
            }

            return function;
        }

        public static bool IsInternalFrame(MethodBase mb) {
            //All the dynamic methods created for DLR rules have a special name.
            //We also check if the method has a different type than the known
            //non-static method. If it does, it is a dynamic method.
            //This could be improved if the CLR provides a way to attach some information
            //to the dynamic method we create, like CustomAttributes.
            if (mb.Name == "CallSite.Target" && mb.GetType() != _knownNonDynamicMethodType) {
                return true;
            }

            //Filter out the helper methods.
            if (mb.DeclaringType == typeof(System.Dynamic.UpdateDelegates)) {
                return true;
            }

            return false;
        }

        public static MethodBodyInfo Create(MethodBase method)
        {
            MethodBodyInfo mbi = new MethodBodyInfo();

            mbi.Identity = method.GetHashCode();
            mbi.TypeName = method.GetType().Name;
            mbi.MethodToString = ".method " + method.ToIL();

            ILReader reader = ILReaderFactory.Create(method);
            mbi.Exceptions = reader.ILProvider.GetExceptionInfos();

            ReadableILStringVisitor visitor = new ReadableILStringVisitor(
                new MethodBodyInfoBuilder(mbi),
                DefaultFormatProvider.Instance);

            reader.Accept(visitor);

            return mbi;
        }

 private void CreateMethod(Type aType, Classifier aCls, MethodBase aMethod, PdOOM.BasePackage aPckg, Operation anOper, InfluenceTable anInfTable)
 {
     Operation operation;
     if (anOper != null)
     {
         operation = anOper;
     }
     else
     {
         operation = (Operation) aCls.CreateObject(0x18112066, "", -1, true);
     }
     operation.Static = aMethod.IsStatic;
     operation.Visibility = GetMethodVisibility(aMethod);
     operation.Final = aMethod.IsFinal;
     if (aMethod.IsGenericMethod)
     {
         operation.Generic = true;
         foreach (TypeParameter parameter in operation.TypeParameters)
         {
             parameter.delete();
         }
         foreach (Type type in aMethod.GetGenericArguments())
         {
             TypeParameter parameter2 = (TypeParameter) operation.CreateObject(0x1811207d, "", -1, true);
             this.ProcessType(type, false);
             TypeMapping mapping = TypeMapping.Retrieve(type);
             parameter2.Name = parameter2.Code = mapping.Name;
             operation.TypeParameters.Add(parameter2);
         }
     }
     if (aMethod.IsVirtual)
     {
         if (LZ.Reverse.Info._bVBNet)
         {
             operation.SetExtendedAttribute("VB.NET.Overridable", "true");
         }
         else
         {
             operation.SetExtendedAttribute("C#.virtual", "true");
         }
     }
     if (aMethod.IsAbstract)
     {
         operation.Abstract = true;
     }
     new CustomHandlerMethod(aMethod, operation).Convert();
     if (anOper == null)
     {
         foreach (ParameterInfo info in aMethod.GetParameters())
         {
             this.AddParameter(operation, info, aPckg);
         }
     }
     bool flag = aMethod.IsConstructor || aMethod.GetType().IsSubclassOf(typeof(ConstructorInfo));
     if (!flag)
     {
         MethodInfo info2 = (MethodInfo) aMethod;
         Type returnType = info2.ReturnType;
         if (returnType.IsArray)
         {
             operation.Array = true;
             returnType = returnType.GetElementType();
         }
         this.ProcessType(returnType, false);
         TypeMapping mapping2 = TypeMapping.Retrieve(returnType);
         if (mapping2.HasClassifier())
         {
             PdOOM.BaseObject obj2 = ProperRef.Link(NamespaceMapping.Retrieve(aPckg), mapping2);
             operation.UseQualifiedDataType = false;
             operation.ReturnTypeObject = obj2;
         }
         else
         {
             operation.ReturnType = mapping2.Name;
         }
         if ((anInfTable != null) && anInfTable.Contains(info2))
         {
             anInfTable.Impact(info2, operation);
         }
         if (LZ.Reverse.Info._bVBNet)
         {
             new CustomHandlerReturn(info2, anOper).Convert();
         }
         bool flag2 = false;
         if (!info2.IsHideBySig && info2.GetBaseDefinition().Equals(info2))
         {
             string name = info2.Name;
             if (!aType.BaseType.Equals(aType))
             {
                 BindingFlags bindingAttr = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
                 bool flag3 = false;
                 foreach (MethodInfo info3 in aType.GetMethods(bindingAttr))
                 {
                     if (info3.Name == name)
                     {
                         flag3 = true;
                         break;
                     }
                 }
                 if (flag3)
//.........这里部分代码省略.........

 // Return the type of the returned value of the method:
 private static Type GetMethodReturnType(MethodBase method)
 {
     MethodInfo info = method as MethodInfo;
     if (info == null)
     {
         throw new ArgumentException("Unsupported MethodBase : " + method.GetType().Name, "method");
     }
     return info.ReturnType;
 }

		private void GetMethodBaseChildren (NodeInfoCollection c, NodeInfo parent, MethodBase mb)
		{
			AddSubnodes (c, parent, mb.GetType(), mb);
		}

 private static Type GetMethodReturnType(MethodBase method)
 {
     var methodInfo = method as MethodInfo;
     if (methodInfo == null)
     {
         // Constructor info.
         throw new ArgumentException("Unsupported MethodBase : " + method.GetType().Name, "method");
     }
     return methodInfo.ReturnType;
 }

        public List<IlInstruction> ReadInstructions(MethodBase method)
        {
            ilInstructions = new List<IlInstruction>();
            this.currentMethod = method;

            var body = method.GetMethodBody();
            parameters = method.GetParameters();
            if (body == null)
                return ilInstructions;
            locals = body.LocalVariables;
            instructions = method.GetMethodBody().GetILAsByteArray();
            var str = new ByteStream(instructions, instructions.Length);
            stream = new BinaryReader(str);

            if (!(typeof(ConstructorInfo).IsAssignableFrom(method.GetType())))
                methodArgs = method.GetGenericArguments();

            if (method.DeclaringType != null)
                typeArgs = method.DeclaringType.GetGenericArguments();

            IlInstruction instruction = null;

            while (stream.BaseStream.Position < stream.BaseStream.Length)
            {
                instruction = new IlInstruction();
                bool isDoubleByte = false;
                OpCode code = ReadOpCode(ref isDoubleByte);
                instruction.OpCode = code;
                instruction.Offset = stream.BaseStream.Position-1;
                if (isDoubleByte)
                {
                    instruction.Offset--;
                }
                instruction.Operand = ReadOperand(code, method.Module,ref instruction.LocalVariableIndex);
                ilInstructions.Add(instruction);
            }

            return ilInstructions;
        }

        private static void GetMethod(MethodDescription md,MethodBase mi, string NickName,string returnName)
        {
            md.Method = mi;
            md.InputArgs = new List<MethodFieldDescription>();
            md.Output = null;
            md.RawType = mi.GetType();
            md.TypeName = GeneratorHelper.GetTypeName(md.RawType);
            md.Name = mi.Name;
            md.NickName = string.IsNullOrEmpty(NickName) ? md.Name : NickName;
            md.IsStatic = mi.IsStatic;

            foreach (ParameterInfo pi in md.Method.GetParameters())
            {
                MethodFieldDescription mfd = new MethodFieldDescription();
                mfd.Name = pi.Name;
                mfd.RawType = pi.ParameterType;
                mfd.TypeName = GeneratorHelper.GetTypeName(mfd.RawType);
                mfd.IsStatic = false;
                mfd.Type = GetMessageFieldType(mfd.RawType);
                md.InputArgs.Add(mfd);
            }

            MethodInfo mii = md.Method as MethodInfo;
            if (null != mii)
            {
                if (!string.Equals(mii.ReturnType.FullName, "System.Void"))
                {
                    MethodFieldDescription mfd = new MethodFieldDescription();
                    mfd.Name = returnName;
                    mfd.RawType = mii.ReturnType;
                    mfd.TypeName = GeneratorHelper.GetTypeName(mfd.RawType);
                    mfd.IsStatic = false;
                    mfd.Type = GetMessageFieldType(mfd.RawType);
                    md.Output = mfd;
                }
            }
        }

 public static bool IsDynamicOrRTDynamicMethod(MethodBase method)
 {
     Type type = method.GetType();
     return rtDynamicMethodType.Equals(type) || dynamicMethodType.Equals(type);
 }

 public static bool IsRTDynamicMethod(MethodBase method)
 {
     return rtDynamicMethodType.Equals(method.GetType());
 }

            public ILReader(MethodBase method)
            {
                if (method == null)
                {
                    throw new ArgumentNullException("method");
                }

                Type rtType = method.GetType();
                if (rtType != s_runtimeMethodInfoType && rtType != s_runtimeConstructorInfoType)
                {
                    throw new ArgumentException("method must be RuntimeMethodInfo or RuntimeConstructorInfo for this constructor.");
                }

                m_ilProvider = new MethodBaseILProvider(method);
                m_resolver = new ModuleScopeTokenResolver(method);
                InstructionBytes = m_ilProvider.GetByteArray();
                m_position = 0;
            }

 public static MethodBodyInfo Create(MethodBase method)
 {
     MethodBodyInfo mbi = new MethodBodyInfo();
       mbi.Identity = method.GetHashCode();
       mbi.TypeName = method.GetType().Name;
       mbi.MethodToString = method.ToString();
       ReadableILStringVisitor readableIlStringVisitor = new ReadableILStringVisitor((IILStringCollector) new MethodBodyInfo.MethodBodyInfoBuilder(mbi), (IFormatProvider) DefaultFormatProvider.Instance);
       new ILReader(method).Accept((ILInstructionVisitor) readableIlStringVisitor);
       return mbi;
 }