• C#時常需要調用C++DLL問題詳解

    時間:2011年12月22日 點擊:3566

     

    本文轉載至CSDN..

     

    在合作開發時,C#時常需要調用C++DLL,當傳遞參數時時常遇到問題,尤其是傳遞和返回字符串是,現總結一下,分享給大家:

    VC++中主要字符串類型為:LPSTR,LPCSTR, LPCTSTR, string, CString, LPCWSTR, LPWSTR等
    但轉為C#類型卻不完全相同。

    主要有如下幾種轉換:


    將string轉為IntPtr:IntPtr System.Runtime.InteropServices.Marshal.StringToCoTaskMemAuto(string)

    將IntPtr轉為string:string System.Runtime.InteropServices.MarshalPtrToStringAuto(IntPtr)

    類型對照:

    BSTR ---------  StringBuilder

    LPCTSTR --------- StringBuilder

    LPCWSTR ---------  IntPtr

    handle---------IntPtr

    hwnd-----------IntPtr

    char *----------string

    int * -----------ref int

    int &-----------ref int

    void *----------IntPtr

    unsigned char *-----ref byte

    Struct需要在C#里重新定義一個Struct

    CallBack回調函數需要封裝在一個委托里,delegate static extern int FunCallBack(string str);

    注意在每個函數的前面加上public static extern +返回的數據類型,如果不加public ,函數默認為私有函數,調用就會出錯。


    在C#調用C++ DLL封裝庫時會出現兩個問題:


    1. 數據類型轉換問題
    2. 指針或地址參數傳送問題

        首先是數據類型轉換問題。因為C#是.NET語言,利用的是.NET的基本數據類型,所以實際上是將C++的數據類型與.NET的基本數據類型進行對應。

        例如C++的原有函數是:

    int __stdcall FunctionName(unsigned char param1, unsigned short param2)

        其中的參數數據類型在C#中,必須轉為對應的數據類型。如:

    [DllImport(“ COM DLL path/file ”)]
    extern static int FunctionName(byte param1, ushort param2)

        因為調用的是__stdcall函數,所以使用了P/Invoke的調用方法。其中的方法FunctionName必須聲明為靜態外部函數,即加上extern static聲明頭。我們可以看到,在調用的過程中,unsigned char變為了byte,unsigned short變為了ushort。變換后,參數的數據類型不變,只是聲明方式必須改為.NET語言的規范。

        我們可以通過下表來進行這種轉換:

    Win32 Types
    CLR Type

    char, INT8, SBYTE, CHAR
    System.SByte

    short, short int, INT16, SHORT
    System.Int16

    int, long, long int, INT32, LONG32, BOOL , INT
    System.Int32

    __int64, INT64, LONGLONG
    System.Int64

    unsigned char, UINT8, UCHAR , BYTE
    System.Byte

    unsigned short, UINT16, USHORT, WORD, ATOM, WCHAR , __wchar_t
    System.UInt16

    unsigned, unsigned int, UINT32, ULONG32, DWORD32, ULONG, DWORD, UINT
    System.UInt32

    unsigned __int64, UINT64, DWORDLONG, ULONGLONG
    System.UInt64

    float, FLOAT
    System.Single

    double, long double, DOUBLE
    System.Double


        之后再將CLR的數據類型表示方式轉換為C#的表示方式。這樣一來,函數的參數類型問題就可以解決了。

        現在,我們再來考慮下一個問題,如果要調用的函數參數是指針或是地址變量,怎么辦?

        對于這種情況可以使用C#提供的非安全代碼來進行解決,但是,畢竟是非托管代碼,垃圾資源處理不好的話對應用程序是很不利的。所以還是使用C#提供的ref以及out修飾字比較好。

        同上面一樣,我們也舉一個例子:

    int __stdcall FunctionName(unsigned char &param1, unsigned char *param2)

        在C#中對其進行調用的方法是:

    [DllImport(“ file ”)]
    extern static int FunctionName(ref byte param1, ref byte param2)

        看到這,可能有人會問,&是取地址,*是傳送指針,為何都只用ref就可以了呢?一種可能的解釋是ref是一個具有重載特性的修飾符,會自動識別是取地址還是傳送指針。

        在實際的情況中,我們利用參數傳遞地址更多還是用在傳送數組首地址上。
    如:byte[] param1 = new param1(6);

        在這里我們聲明了一個數組,現在要將其的首地址傳送過去,只要將param1數組的第一個元素用ref修飾。具體如下:

    [DllImport(“ file ”)]
    extern static int FunctionName(ref byte param1[1], ref byte param2)
     
    文章出處:DIY部落(http://www.diybl.com/course/3_program/c++/cppjs/200886/134816.html)

    C# 中調用DLL
    為了能用上原來的C++代碼,只好研究下從C# 中調用DLL
    首先必須要有一個聲明,使用的是DllImport關鍵字:
    包含DllImport所在的名字空間
    using System.Runtime.InteropServices;
    public class XXXX{

    [DllImport(“MyDLL.dll")]
    public static extern int mySum (int a,int b);
    }


    [DllImport(“MyDLL.dll")]
    public static extern int mySum (int a,int b);
    代碼中DllImport關鍵字作用是告訴編譯器入口點在哪里,并將打包函數捆綁在這個類中
    在調用的時候
    在類中的時候 直接   mySum(a,b);就可以了
    在其他類中調用: XXXX. mySum(a,b);
     
    [DllImport(“MyDLL.dll”)]在申明的時候還可以添加幾個屬性
    [DllImport(“MyDLL.dll", EntryPoint=" mySum ",CharSet=CharSet.Auto,CallingConvention=CallingConvention.StdCall)
    ]
    EntryPoint: 指定要調用的 DLL 入口點。默認入口點名稱是托管方法的名稱 。
    CharSet: 控制名稱重整和封送 String 參數的方式 (默認是UNICODE)
    CallingConvention指示入口點的函數調用約定(默認WINAPI)(上次報告講過的)
    SetLastError 指示被調用方在從屬性化方法返回之前是否調用 SetLastError Win32 API 函數 (C#中默認false )


    int 類型
    [DllImport(“MyDLL.dll")]
    //返回個int 類型
    public static extern int mySum (int a1,int b1);
    //DLL中申明
    extern “C” __declspec(dllexport)  int WINAPI mySum(int a2,int b2)
    {
    //a2 b2不能改變a1 b1
    //a2=..
    //b2=...
     return a+b;
    }

    //參數傳遞int 類型
    public static extern int mySum (ref int a1,ref int b1);
    //DLL中申明
    extern “C” __declspec(dllexport)  int WINAPI mySum(int *a2,int *b2)
    {
    //可以改變 a1, b1
    *a2=...
    *b2=...
     return a+b;
    }


    DLL 需傳入char *類型
    [DllImport(“MyDLL.dll")]
    //傳入值
    public static extern int mySum (string  astr1,string bstr1);
    //DLL中申明
    extern “C” __declspec(dllexport)  int WINAPI mySum(char * astr2,char * bstr2)
    {
    //改變astr2 bstr 2  ,astr1 bstr1不會被改變
     return a+b;
    }


    DLL 需傳出char *類型
    [DllImport(“MyDLL.dll")]
    // 傳出值
    public static extern int mySum (StringBuilder abuf, StringBuilder bbuf );
    //DLL中申明
    extern “C” __declspec(dllexport)  int WINAPI mySum(char * astr,char * bstr)
    {
    //傳出char * 改變astr bstr -->abuf, bbuf可以被改變
     return a+b;
    }
     
    DLL 回調函數

    BOOL EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam)

     

    using System;
    using System.Runtime.InteropServices;
    public delegate bool CallBack(int hwnd, int lParam); //定義委托函數類型
    public class EnumReportApp
    {
    [DllImport("user32")]
    public static extern int EnumWindows(CallBack x, int y);
    public static void Main() {
    CallBack myCallBack = new CallBack(EnumReportApp.Report); EnumWindows(myCallBack, 0);
    }
    public static bool Report(int hwnd, int lParam)
    {
    Console.Write("Window handle is ");
    Console.WriteLine(hwnd); return true;
    }
    }

     

    DLL  傳遞結構
    BOOL PtInRect(const RECT *lprc, POINT pt);

    using System.Runtime.InteropServices;
    [StructLayout(LayoutKind.Sequential)]
    public struct Point {
     public int x;
    public int y;
     }
    [StructLayout(LayoutKind.Explicit)]
     public struct Rect
     {
    [FieldOffset(0)] public int left;
    [FieldOffset(4)] public int top;
    [FieldOffset(8)] public int right;
    [FieldOffset(12)] public int bottom;
     }
    Class XXXX {
     [DllImport("User32.dll")]
    public static extern bool PtInRect(ref  Rect r, Point p);
     }

    DLL 回調函數,傳遞結構 想看的msdn里面都有專題介紹,看的我都是暈暈的:)

    其他參考請搜索:

    在C#程序設計中使用Win32類庫
    C#中調用C++托管Dll
    如何在C#中加載自己編寫的動態鏈接庫

    相關文章:Creating a P/Invoke Library


    能用上DLL以后感覺還是很好的,原來的C++代碼只要修改編譯通過就可以了,
    高興沒多久,發現.net2005居然可以用VB,VC開發智能設備項目,可以創建MFC智能設備項目
    暈暈,難道可以直接用MFC來開發smartphone的程序了,趕緊看看,,,

    Visual C++ 使用 __declspec(dllexport) 從 DLL 導出 (到C#)
    由于各種的原因, 如何把unmanaged 的 c++ DLL 轉換成 managed C# 是一個問題。

    方法有3個.

    Ø 使用.def文件

    Ø 可以不用.def文件, 使用__declspec(dllexport)關鍵字, 特別是針對Visual C++編譯器的時候

    Ø 直接用MC++寫

    什么時候用.def文件?

    .def的意思是module-definition, 這個純文本的文件定義了模塊的信息。 對于編譯器來說, 一個方法在編譯之后的DLL文件里, 存在的形式名字可能不是作者當時起的那個,例如好好的函數名字function() 變成了?function2@@YAXXZ; 可以用undname查看這個被編譯器修飾掉的名字, 原型是"void __cdecl function2(void)". 大概使用的時候就會遇到類似”鏈接錯誤,未決的外部符號…” 的錯誤.

    .def文件主要的作用, 就是”標注” 出這個函數原來的樣子, 這樣編譯器在編譯的時候, 規則上就會以C編譯器的規則來處理, 修飾被去掉了, 另外同時可以把導出函數的序號值手動的改高一點; 還有一個優點(也是缺點) 就是可以用NONAME來修飾函數, 這樣導出函數的序號值就變成了1~N, 即第N個函數. 所以調用GetProcAddress() 的時候, 可以直接用定義的序號值, 而不用寫函數的名字(但是名字就完全不可用了), 更好的是, 導出函數的這個DLL會變得比較小, 當然, MSDN強調了一點: 僅你可以并有權更改這個.def文件內容的時候, 你才可以用這個辦法.

    那么, 什么時候考慮用.def文件呢? 因為編譯器不同, 而產生的修飾名不同的話, 這個文件就是必須的.

    注意如果文件沒有導出函數的話, 這個文件可能降低運行效率。

    .def文件的格式

    LIBRARY FileNameWithoutExtension

    EXPORTS

    Function1 @1

    Function3 @2

    Function2 @3 NONAME

    啟用 Enable it: Property pages-> Configuration Properties->C/C++ -> Linker -> input -> Module Definition File

    那不用.def呢? __declspec(dllexport)的作用

    這個東西, 可以給函數用, 也可以給類用. 聲明大概這樣子:

    view source
    < id="highlighter_930381_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 __declspec(dllexport) int __stdcall GetMid(vector<type> ve); 

    2 class __declspec(dllexport) TestClass{ 

    3 public : 

    4 TestClass(); 

    5 }

    這牽扯到了一個東西就是__stdcall和__cdecl (還有__fastcall, 不過很少用), 其中__cdecl一般是C或者C++的缺省調用規范, 但是最大的一個區別就是__stdcall在返回前自身清除堆棧, 而__cdecl是調用方來做這個事情(可參考COM中的某些機制), 另一個區別就是__stdcall對于可變參數的函數, 玩不轉.

    反正今時今日, 大家都在用__stdcall, 所以這么寫也沒什么問題, 但不是沒有. VB里調用標記著__cdecl的方法, 可能會得到一個異常Bad DLL Calling Convention. 解決方法也很簡單:

    原來的函數

    view source
    < id="highlighter_718220_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 long _cdecl PassStr(LPSTR pStr) 

    2 {       return 1;      }

    新的函數

    view source
    < id="highlighter_515163_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 long _stdcall PassStrStdCall(LPSTR pStr) 

    2 {       return PassStr(pStr);      }

    問題是, 如果這個函數原型, 參數是可變的, 那又怎么弄呢?

    調用的時候, C#都是這么寫的:

    view source
    < id="highlighter_120154_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 [DllImport("", EntryPoint = @" ?GetMid@@YAXXZ", CharSet = CharSet.Auto)] 

    2 private static extern void GetMid(...);

    這個入口點名字還真別扭, 看來去掉這個修飾還是蠻需要的, 除了用.def文件, 另一個辦法就是用 extern “C”.

    Extern “C”

    一句話總結:這個東西可以去掉修飾名。在不用.def文件的前提下, 這個可以保證你的函數function() 還是這個名字.

    但是,這個東西對類不太起作用!

    這個東西是這么用的: 放到函數聲明的最前面。 就類似這樣 extern “C” void __declspec(dllexport) function(void);

    對于類, 一般的做法是, 把它的內部方法(特別是實例方法,或變量),wrap出一個方法來。 見下面的實例.

    還要做什么?

    當一個DLL被初始化的時候, 它需要一個入口點, 一般對于非MFC DLL來說, 這樣寫就行了:

    view source
    < id="highlighter_702691_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    01 BOOL APIENTRY DllMain(HANDLE hModule,  

    02                       DWORD  ul_reason_for_call,  

    03                       LPVOID lpReserved 

    04                       ) 

    05 { 

    06     switch( ul_reason_for_call ) 

    07     { 

    08     case DLL_PROCESS_ATTACH: 

    09     case DLL_THREAD_ATTACH: 

    10     case DLL_THREAD_DETACH: 

    11     case DLL_PROCESS_DETACH: 

    12         break; 

    13     } 

    14     return TRUE; 

    15 }

    要注意的是這個入口點的名字必須是DllMain, 如果不是需要修改linker的/entry 選項. 否則對于C的話可能會初始化失敗.

    ************************************************************************

    開始用導出函數 PInvoke

    為了好看一點, 先約定一下:

    view source
    < id="highlighter_95255_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 #define EXT_C extern "C"  

    2 #define DLLEXPORT __declspec(dllexport) 

    3 #define EXT_C_DLLEXPORT EXT_C DLLEXPORT 

    4 #define CALLBACK    __stdcall 

    5 #define WINAPI      __stdcall 

    6 #define APIENTRY    WINAPI

    1. 普通的函數

    view source
    < id="highlighter_171056_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 EXT_C_DLLEXPORT void WINAPI Function(); 

    2   

    3 [DllImport("filename.dll", EntryPoint = " Function")] 

    4 private static extern void Func();

    2. ref或者out

    view source
    < id="highlighter_733498_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 EXT_C_DLLEXPORT void WINAPI Function(Type** ty); 

    2   

    3 [DllImport("filename.dll", EntryPoint = " Function")] 

    4 private static extern void Func(out Type ty);

    3. 指針函數和委托

    view source
    < id="highlighter_987259_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 Typedef void (CALLBACK *pFunc)(int); 

    2 EXT_C_DLLEXPORT void WINAPI Compare(int a, int b, pFunc p); 

    3 private delegate int CompareCallback(int a, int b); 

    4 [DllImport("filename.dll",EntryPoint=”Compare”)] 

    5 private static extern int Compare(int a, int b, CompareCallback call);

    4. 類的處理. 其實不是說不可以把類標記為 DLLEXPORT, 如果可以的話, 當然是wrap比較好

    C++里的原型

    view source
    < id="highlighter_909839_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 class DLLEXPORT Test 

    2 { 

    3 public : 

    4     Test(); 

    5     ~Test(); 

    6     BOOL function(int par) 

    7 };

    類被export, 函數調用時候注意用CallingConvention.ThisCall.

    view source
    < id="highlighter_447728_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 [DllImport("filename.dll", EntryPoint = @"??4Test@@QEAAAEAV0@AEBV0@@Z", CallingConvention = CallingConvention.ThisCall)] 

    2   private static extern int TestFunc(IntPtr hwnd, int par);

    采用了”迂回”策略, C++里先這樣定義,同理, 添加構造函數等, 函數就變成了這個樣子:

    view source
    < id="highlighter_371353_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    01 EXT_C_DLLEXPORT BOOL WINAPI function_wrap(Test* t, int par) 

    02 { 

    03     return t->function(par); 

    04 } 

    05 EXT_C_DLLEXPORT Test* Test_ctor() 

    06 { 

    07     Test* t = new Test(); 

    08     return t; 

    09 } 

    10 EXT_C_DLLEXPORT void Test_dector(Test* t) 

    11 { 

    12     if(NULL == t) 

    13     { 

    14         delete t; 

    15         t = NULL; 

    16     } 

    17 }

    在C#里這樣寫, 那么就和平時用沒什么區別了.

    view source
    < id="highlighter_413990_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    01 public class Test : IDisposable 

    02         { 

    03             private IntPtr instance; 

    04             public Test() 

    05             { 

    06                 instance = CreateInstance(); 

    07             } 

    08   

    09              ~Test() 

    10             { 

    11                 Dispose(false); 

    12             } 

    13   

    14             #region pinvoke 

    15             [DllImport("filename.dll", EntryPoint = @"Test_ctor")] 

    16             private static extern IntPtr CreateInstance(); 

    17             [DllImport("filename.dll", EntryPoint = @"Test_dector")] 

    18             private static extern void DestroyInstance(IntPtr hwnd); 

    19             [return: MarshalAs(UnmanagedType.Bool)] 

    20             [DllImport("filename.dll", EntryPoint = @"function_wrap")] 

    21             private static extern bool function_wrap(int par); 

    22             #endregion 

    23   

    24             #region IDisposable Members 

    25   

    26             public void Dispose() 

    27             { 

    28                 Dispose(true); 

    29             } 

    30   

    31             private void Dispose(bool bDisposing) 

    32             { 

    33                 if (instance != IntPtr.Zero) 

    34                 { 

    35                     DestroyInstance(instance); 

    36                 } 

    37   

    38                 if (bDisposing) 

    39                 { 

    40                     GC.SuppressFinalize(this); 

    41                 } 

    42             } 

    43   

    44             #endregion 

    45         }

    5. Struct操作.

    view source
    < id="highlighter_777150_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 typedef struct Object_HANDLE { 

    2   unsigned long      dbch_size; 

    3   HANDLE     dbch_handle; 

    4   GUID       dbch_eventguid; 

    5   BOOL res_flag; 

    6 } Object_Native_HANDLE ;

    首先在C#里嚴格定義這個,LayoutKind.Sequential 用來保證內存分配的正常。

    view source
    < id="highlighter_876084_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 [StructLayout(LayoutKind.Sequential)] 

    2 public struct Object_Native_HANDLE 

    3 { 

    4     public ulong dbch_size; 

    5     public IntPtr dbch_handle; 

    6     public Guid dbch_eventGuid; 

    7     public bool res_flag; 

    8 }

    Marshal的使用如下:

    view source
    < id="highlighter_487393_clipboard" title="copy to clipboard" classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="16" height="16" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0" type="application/x-shockwave-flash">
    print?
    1 Object_Native_HANDLE obj = new Object_Native_HANDLE(); //初始化 

    2 int amountToAllocate = Marshal.SizeOf(obj);//獲取大小 

    3 IntPtr objPtr = Marshal.AllocHGlobal(amountToAllocate); //分配并獲取空的空間地址 

    4 Marshal.StructureToPtr(obj, objPtr, false); // 值寫入分配的空間 

    5 //操作... 

    6 Marshal.FreeHGlobal(objPtr);//釋放空間

    最后提一句, unmaged code中的錯誤, 到managed 以后, 極大可能是捕捉不到的。 所以錯誤需要分別處理。

    花了不少時間, MC++平時用的不多, 不寫了。

     

     

     

     

     

    贊助商鏈接

    熱門內容

    相關內容

    聯系我們

    聯系方式
    亚洲AV口工动漫在线观看无码