C# CallingConvention类代码示例

		internal static string ToString(CallingConvention flags) {
			var sb = new StringBuilder();

			switch (flags & CallingConvention.Mask) {
			case CallingConvention.Default: sb.Append("Default"); break;
			case CallingConvention.C: sb.Append("C"); break;
			case CallingConvention.StdCall: sb.Append("StdCall"); break;
			case CallingConvention.ThisCall: sb.Append("ThisCall"); break;
			case CallingConvention.FastCall: sb.Append("FastCall"); break;
			case CallingConvention.VarArg: sb.Append("VarArg"); break;
			case CallingConvention.Field: sb.Append("Field"); break;
			case CallingConvention.LocalSig: sb.Append("LocalSig"); break;
			case CallingConvention.Property: sb.Append("Property"); break;
			case CallingConvention.Unmanaged: sb.Append("Unmanaged"); break;
			case CallingConvention.GenericInst: sb.Append("GenericInst"); break;
			case CallingConvention.NativeVarArg: sb.Append("NativeVarArg"); break;
			default: sb.Append(string.Format("CC_UNKNOWN_0x{0:X}", (int)(flags & CallingConvention.Mask))); break;
			}

			if ((flags & CallingConvention.Generic) != 0)
				sb.Append(" | Generic");

			if ((flags & CallingConvention.HasThis) != 0)
				sb.Append(" | HasThis");

			if ((flags & CallingConvention.ExplicitThis) != 0)
				sb.Append(" | ExplicitThis");

			if ((flags & CallingConvention.ReservedByCLR) != 0)
				sb.Append(" | ReservedByCLR");

			return sb.ToString();
		}

 public JitAction(
     CallingConvention callingConvention = CallingConvention.Default,
     FunctionHints hints = FunctionHints.None,
     CodeGenerator codeGenerator = null)
     : base(callingConvention, hints, codeGenerator)
 {
 }

 internal UnmanagedCalliDescriptor(CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes)
     : base()
 {
     this.Value = string.Format(CultureInfo.CurrentCulture, "unmanaged {0} {1}({2})",
         unmanagedCallConv.ToString().ToLower(CultureInfo.CurrentCulture),
         new TypeDescriptor(returnType).Value,
         string.Join(", ", CalliDescriptor.GetArguments(parameterTypes).ToArray()));
 }

		internal __StandAloneMethodSig(bool unmanaged, CallingConvention unmanagedCallingConvention, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes)
		{
			this.unmanaged = unmanaged;
			this.unmanagedCallingConvention = unmanagedCallingConvention;
			this.callingConvention = callingConvention;
			this.returnType = returnType;
			this.parameterTypes = parameterTypes;
			this.optionalParameterTypes = optionalParameterTypes;
		}

	private SignatureHelper(Module mod, IntPtr context, IntPtr sig)
			{
				this.mod = mod;
				this.context = context;
				this.sig = sig;
				this.numArgs = 0;
				this.callConv = (CallingConvention)0;
				this.field = false;
				this.bytesOffset = -1;
				((ModuleBuilder)mod).assembly.AddDetach(this);
			}

        public CompilerFunctionCall(Compiler compiler, CompilerFunction caller, Operand target, CallingConvention callingConvention, VariableType[] arguments, VariableType returnValue)
            : base(compiler)
        {
            Contract.Requires(arguments != null);

            _caller = caller;
            _target = target;

            _functionPrototype = new FunctionDeclaration(callingConvention, arguments, returnValue);
            if (arguments != null && arguments.Length > 0)
                _args = new Operand[arguments.Length];
        }

        internal FunctionDeclaration(CallingConvention callingConvention, VariableType[] arguments, VariableType returnValue)
        {
            Contract.Requires(arguments != null);

            if (callingConvention == CallingConvention.Default)
                callingConvention = CallingConventionInfo.DefaultCallingConvention;

            _callingConvention = callingConvention;
            if (arguments.Length > 32)
                throw new ArgumentException();

            SetPrototype(arguments, returnValue);
        }

        public static object DynamicDllFunctionInvoke(
            string dllPath,
            string entryPoint,
            MethodAttributes methodAttr,
            CallingConvention nativeCallConv,
            CharSet nativeCharSet,
            Type returnType,
            Type[] parameterTypes,
            object[] parameterValues
            )
        {
            string dllName = Path.GetFileNameWithoutExtension(dllPath);
            // ����һ����̬����(assembly)��ģ��(module)
            AssemblyName assemblyName = new AssemblyName();
            assemblyName.Name = string.Format("A{0}{1}",
                dllName,
                Guid.NewGuid().ToString( "N" )
                );
            AssemblyBuilder dynamicAssembly =
              AppDomain.CurrentDomain.DefineDynamicAssembly(
              assemblyName, AssemblyBuilderAccess.Run);
            ModuleBuilder dynamicModule =
              dynamicAssembly.DefineDynamicModule(
              string.Format("M{0}{1}",
              dllName,
              Guid.NewGuid().ToString("N"))
              );

            // ʹ��ָ������Ϣ����ƽ̨����ǩ��
            MethodBuilder dynamicMethod =
                dynamicModule.DefinePInvokeMethod(
                entryPoint,
                dllPath,
                methodAttr,
                CallingConventions.Standard,
                returnType,
                parameterTypes,
                nativeCallConv,
                nativeCharSet
                );

            // ��������
            dynamicModule.CreateGlobalFunctions();

            // ���ƽ̨���õķ���
            MethodInfo methodInfo =
                dynamicModule.GetMethod(entryPoint, parameterTypes);
            // ���÷��йܺ�������÷��صĽ��
            object result = methodInfo.Invoke(null, parameterValues);
            return result;
        }

        public unsafe MethodDesc(string name, string dll, string entryPoint, FUNCDESC funcdesc, string[] argumentNames, Func<uint, TypeDesc> typeFactory)
        {
            string tmpl = "___overloaded000";
            if ((name.Length > tmpl.Length) && (name.IndexOf("___overloaded") == (name.Length - tmpl.Length)))
                name = name.Substring(0, name.Length - tmpl.Length);

            Name = EscapMethodName(name);
            Dll = dll;
            EntryPoint = entryPoint;

            Offset = funcdesc.oVft;

            ReturnValue = new ParameterDesc(funcdesc.elemdescFunc, string.Empty, typeFactory, 0, false, null);
            List<ParameterDesc> parameters = new List<ParameterDesc>();
            for (int i = 0; i < funcdesc.cParams; i++)
                parameters.Add(new ParameterDesc(funcdesc.lprgelemdescParam[i], (i < argumentNames.Length) ? argumentNames[i] : "__arg" + i, typeFactory, 0, false, null));
            Parameters = parameters.AsReadOnly();

            //if (funcdesc.cParamsOpt != 0)
            //    throw new Exception("Variable number of optional parameters is not supported");
            //if (funcdesc.invkind != INVOKEKIND.INVOKE_FUNC)
            //    throw new Exception("Only functions are currently supported");
            if (funcdesc.cScodes >= 1)
                throw new Exception("Only one return value is supported");

            switch (funcdesc.callconv)
            {
                case System.Runtime.InteropServices.ComTypes.CALLCONV.CC_CDECL:
                    Convention = CallingConvention.Cdecl;
                    break;
                case System.Runtime.InteropServices.ComTypes.CALLCONV.CC_STDCALL:
                    Convention = CallingConvention.StdCall;
                    break;
                default:
                    throw new Exception("Calling convention " + funcdesc.callconv + " is not supported");
            }

            switch (funcdesc.funckind)
            {
                case FUNCKIND.FUNC_DISPATCH:
                case FUNCKIND.FUNC_VIRTUAL:
                case FUNCKIND.FUNC_PUREVIRTUAL:
                case FUNCKIND.FUNC_NONVIRTUAL:
                case FUNCKIND.FUNC_STATIC:
                    break;
                default:
                    throw new Exception("Function kind " + funcdesc.funckind + " is not supported");
            }
        }

 public MethodSignature(
     bool hasThis,
     bool explicitThis,
     CallingConvention callingConvention,
     int genericParamCount,
     IReadOnlyList<Parameter> parameters,
     Type retType
     )
 {
     m_hasThis = hasThis;
     m_explicitThis = explicitThis;
     m_callingConvention = callingConvention.CheckDefined("callingConvention");
     m_genericParamCount = genericParamCount.CheckGTE(0, "genericParamCount");
     m_parameters = parameters.CheckNotNull("parameters");
     m_retType = retType.CheckNotNull("retType");
 }

        public DLLExportAttribute(string exportName,CallingConvention callingConvention)
        {
            ExportName = exportName;
            switch(callingConvention)
            {
                case CallingConvention.Winapi:
                case CallingConvention.StdCall:
                    Convention	= typeof(CallConvStdcall).FullName;
                    break;
                case CallingConvention.FastCall:
                    Convention	= typeof(CallConvFastcall).FullName;
                    break;
                case CallingConvention.ThisCall:
                    Convention	= typeof(CallConvThiscall).FullName;
                    break;
                case CallingConvention.Cdecl:
                    Convention	= typeof(CallConvCdecl).FullName;
                    break;

                default:
                    throw new NotImplementedException();
            }
        }

 /// <summary>
 /// Only constructor.
 /// </summary>
 /// <param name="ChanKind"></param>
 /// <param name="ObjType"></param>
 /// <param name="CallConv"></param>
 /// <param name="InvKind"></param>
 public Client(ChannelKind ChanKind, 
               Type ObjType, 
               CallingConvention CallConv, 
               InvokeKind InvKind,
               string Host)
 {
   m_ChanKind = ChanKind;
   m_ObjType = ObjType;
   m_CallConv = CallConv;
   m_InvKind = InvKind;
   m_Host = Host;
 }//constructor

    }//Usage()
    
    /// <summary>
    /// Gets user options.
    /// </summary>
    private static void GetOptions()
    {
 GetChannel:
      Console.Write("\nHttp (h), TCP (t) or both (b) using threads? ");
      string Reply = Console.ReadLine();
      switch (Reply.ToLower())
      {
        case "b":
          m_ChanKind = ChannelKind.Both;
          break;
        case "h":
          m_ChanKind = ChannelKind.Http;
          break;
        case "t":
          m_ChanKind = ChannelKind.TCP;
          break;
        default:
          Console.WriteLine("Invalid option, please try again.");
          goto GetChannel;
      }//switch

GetConvention:
      Console.Write("\nBy ref (r) or by val (v)? ");
      Reply = Console.ReadLine();
      switch (Reply.ToLower())
      {
        case "r":
          m_CallConv = CallingConvention.ByRef;
          break;
        case "v":
          m_CallConv = CallingConvention.ByVal;
          break;
        default:
          Console.WriteLine("Invalid option, please try again.");
          goto GetConvention;
      }//switch

GetInvoke:
      Console.Write("\nSerial (s) or async (a)? ");
      Reply = Console.ReadLine();
      switch (Reply.ToLower())
      {
        case "a":
          m_InvKind = InvokeKind.Async;
          break;
        case "s":
          m_InvKind = InvokeKind.Sequential;
          break;
        default:
          Console.WriteLine("Invalid option, please try again.");
          goto GetInvoke;
    }//switch

      //Setup the correct Type object to pass to the Client object for object creation.
      switch (m_CallConv)
      {
        case CallingConvention.ByRef:
          m_ObjType = Type.GetType("RemotingSamples.HelloServerByRef,remotingshared");
          break;
        case CallingConvention.ByVal:
          m_ObjType = Type.GetType("RemotingSamples.HelloServerByVal,remotingshared");
          break;
        default:
          throw new System.InvalidOperationException("Invalid Calling Convention in Main()");
      }//switch
      Console.WriteLine();
      return;
    }//GetOptions()

 public UnmanagedFunctionPointerAttribute(CallingConvention callingConvention)
 {
     this.call_conv = callingConvention;
 }

 public UnmanagedFunctionPointerAttribute(CallingConvention callingConvention)
 {
     _callingConvention = callingConvention;
 }