公共语言运行库(CLR)开发系列课程(2)：Pinvoke 进阶 学习笔记

• 上一章地址

• API版本

  • 具有字符串参数的API通常有两种版本

    • GetWindowText
      • GetWindowTextA
      • GetWindowTextW

  • 缺省情况下CLR会自动寻找合适的匹配

    • CharSet=Ansi时寻找A版本
    • CharSet=Unicode寻找W版本
    • CharSet=Auto和平台相关

  • DLLImportAttribute（ExactSpelling=true）会关掉这种行为

• Ref/Out参数 （C#关键字）

  • out=[Out]&

    • C#:out int a
    • IL:[Out] int &a
    • C++:int *pa;

  • ref=[In,Out]&

    • C#:ref int a
    • IL:[In,Out] int &a
    • C++:int *pa;

  • 个人感觉 使用Ref/Out 参数P/Invoke CRL会对根据对应关键字添加对应IL特性 System.Runtime.InteropServices下面的InAttribute、OutAttribute 　　

• 引用类型和值类型

  • 非托管C/C++　代码：struct A{int a;}　

    托管代码:struct A{int a;}　 class A{int a;}

  • 非托管C/C++代码	A	A*	A**
    A为值类型	A	ref A	IntPtr  a
    A为引用类型	N/A	A	ref A

• 自定义参数转换

  • 托管类型和非托管类型之间是一对多关系

    • String
      • char */wchar_t *　　
      • char[N]/wchar_t[N] 固定长度的字符串
      • BSTR, Ansi BSTR
  • MarshalAsAttribute(UnmanagedType)　
  • UnmanagedType 枚举指定对应非托管类型
  • [MarshalAsAttribute(UnmanagedType.LPWSTR)] string A
  • 非托管函数：void Func(wchar_t *)
  • 托管函数：Public static extern void  Func([MarshalAs(UnmanagdType.LPWSTR)] string);

• 内存管理

  • 在数据转换中需要进行内存分配

  • 举例：

    • C#调用Func(string)      Marshal.StringToHGlobalAnsi("balabala")
    • C#调用Func(ref string)
    • C#调用string Func()

  • CoTaskMemAlloc / CoTaskMemFree　(分配/释放 内存)　内存交换才使用　

• 实例分析CreateProcess

  • API原型

    BOOL WINAPI CreateProcess(
      _In_opt_    LPCTSTR               lpApplicationName,
      _Inout_opt_ LPTSTR                lpCommandLine,
      _In_opt_    LPSECURITY_ATTRIBUTES lpProcessAttributes,
      _In_opt_    LPSECURITY_ATTRIBUTES lpThreadAttributes,
      _In_        BOOL                  bInheritHandles,
      _In_        DWORD                 dwCreationFlags,
      _In_opt_    LPVOID                lpEnvironment,
      _In_opt_    LPCTSTR               lpCurrentDirectory,
      _In_        LPSTARTUPINFO         lpStartupInfo,
      _Out_       LPPROCESS_INFORMATION lpProcessInformation
    );

  　　     （opt 可选的输入参数）

  • C#　　

    Public static extern bool CreateProcess(
         [In] string applicationName,
         [In,Out] StringBuilder commandName,
         [In] ref SECURITY_ATTRIBUTES processAttributes,
         [In] ref SECURITY_ATTRIBUTES threadAttributes,
         [In] bool inheritHandles,
         [In] uint creationFlags,
         [In] IntPtr lpEnvironment,
         [In] string currentDirectory,
         [In] ref STARTUP_INFO startupInfo,
         [Out] out PROCESS_INFORMATION processInformation
    );　

• DLL生命周期

  • Dll在第一次调用的时候自动加载，不会自动被释放，加载不到或者找不到函数就会抛出异常

  • Dll不会自动被卸载,建议做法生命一个外部调用类 DLL会伴随外部调用类一起被清理卸载

  • 如果需要手段管理DLL生命周期，只能手动调用LoadLibrary/GetProcAddress

• 逆向P/Invoke

  非托管代码到托管代码这种叫逆向P/Invoke

  • 部分API接收函数指针作为参数

  • EnumWindows(WNDENUMPROC IpEnumFunc,LPARAM lPararm)　

  • .NET 程序可以通过P/Invoke调用　EnumWindows API

  • CLR能够将Delegate 转换为函数指针，EnumWindows 来回调这个函数指针

  • [UnmanagedFunctionPointer(CallingConvention.Winapi)]
    delegate bool EnumWindowProc(IntPtr hwnd, IntPtr lParam);
    EnumWindow(new EnumWindowProc(MyEnumWindow), IntPtr.Zero);

• DEMO

   class Program
      {
          /// Return Type: BOOL->int
          ///hwnd: HWND->HWND__*
          ///lParam: LPARAM->LONG_PTR->int
          [UnmanagedFunctionPointerAttribute(CallingConvention.Winapi)]
          public delegate bool WNDENUMPROC(IntPtr hwnd, IntPtr lParam);
  
          class NativeMethods
          {
              [DllImport("User32.dll",CallingConvention=CallingConvention.Winapi)]
              public static extern int GetWindowText(IntPtr hwnd, StringBuilder text, int count);
  
              /// Return Type: BOOL->int
              ///lpEnumFunc: WNDENUMPROC
              ///lParam: LPARAM->LONG_PTR->int
              [DllImportAttribute("user32.dll", EntryPoint = "EnumWindows")]
              [return: MarshalAsAttribute(UnmanagedType.Bool)]
              public static extern bool EnumWindows(WNDENUMPROC lpEnumFunc, int lParam);
          }
  
          private static bool WNDENUMPROC_Callback(IntPtr hwnd, IntPtr lParam)
          {
              StringBuilder text = new StringBuilder();
              NativeMethods.GetWindowText(hwnd, text, );
              Console.WriteLine("窗口名：" + text + ",id=" + hwnd.ToInt32() + ",lParam=" + lParam);
              return true;
          }
          static void Main(string[] args)
          {
              WNDENUMPROC myWNDENUMPROC = new WNDENUMPROC(WNDENUMPROC_Callback);
              NativeMethods.EnumWindows(myWNDENUMPROC,);
              Console.Read();
          }
  
      }

• 常见问题

  • 抛出DllNotFoundException

    找不到DLL一般他会到当前目录去找 或者系统目录去找 DLL如果实在无法差错可以使用全路径+dll名不推荐最好是放相对路径

  • 抛出AccessViolationException

    访问违规，一般是内存不可以读不可以写或者一起读一起写造成的，通常原因参数转换错误，类型不对应，长度问题。

  • 抛出EntryPointNotFoundException

    API方法入口找不到一般都是方法名写错或者调用协定不对

  • MDA报错StackImbalanceMDA

    VS提示报错，参数错位调用协定不对

  • 返回数据错误

    参数是否正确，MarshalAs转换是否成功，开启非托管调试查看。

• 进阶DEMO

  • c++

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <Windows.h>
    /*自定义*/
    typedef struct Mytype
    {
        int i;
        char *s;
        double d;
        struct Mytype *p;
    }Mytype;
    
    int TestInt(int a,int b)
    {
        return a + b;
    }
    void TestIntPtr(int *i)
    {
        *i = *i * -;
    }
    char * TestCharPtr(char *a,char *b)
    {
        return strcat(a, b);
    }
    void TestStructPtr(Mytype *p)
    {
        p->i++;
        p->d++;
    }
    void TestPtrPtr(int **a,int length)
    {
        *a = (int*)malloc(sizeof(int)*length);
        memset(*a, , sizeof(int)* length);
    }
    void TestArray(int *a, int length)
    {
        for (int i = ; i < length; i++)
        {
            a[i]++;
        }
    }
    
    void TestCallback(void(*pf)())
    {
        pf();
    }
    int TestCharWidth(char *s)
    {
        return strlen(s);
    }
    
    文件名 Source.cpp

    LIBRARY "PInvoke"
        EXPORTS
            TestInt
            TestIntPtr
            TestCharPtr
            TestStructPtr
            TestPtrPtr
            TestArray
            TestCallback
            TestCharWidth
    文件名 Source.def

  • C#

     class Program
        {
    
            [StructLayoutAttribute(LayoutKind.Sequential)]
            public struct Mytype
            {
    
                /// int
                public int i;
    
                /// char*
                [MarshalAsAttribute(UnmanagedType.LPStr)]
                public string s;
    
                /// double
                public double d;
    
                /// Mytype*
                public System.IntPtr p;
            }
    
            /// Return Type: void
            public delegate void Callback();
    
            static void CallbackFunction()
            {
                Console.WriteLine("callback invoked");
            }
            /// Return Type: int
            ///a: int
            ///b: int
            [DllImportAttribute("Pinvoke.dll", EntryPoint = "TestInt", CallingConvention = CallingConvention.Cdecl)]
            public static extern int TestInt(int a, int b);
    
            /// Return Type: void
            ///i: int*
            [DllImportAttribute("Pinvoke.dll", EntryPoint = "TestIntPtr", CallingConvention = CallingConvention.Cdecl)]
            public static extern void TestIntPtr(ref int i);
    
            /// Return Type: char*
            ///a: char*
            ///b: char*
            [DllImportAttribute("Pinvoke.dll", EntryPoint = "TestCharPtr", CallingConvention = CallingConvention.Cdecl)]
            public static extern System.IntPtr TestCharPtr(System.IntPtr a, System.IntPtr b);
    
            /// Return Type: void
            ///p: Mytype*
            [DllImportAttribute("Pinvoke.dll", EntryPoint = "TestStructPtr", CallingConvention = CallingConvention.Cdecl)]
            public static extern void TestStructPtr(ref Mytype p);
    
            /// Return Type: void
            ///a: int**
            ///length: int
            [DllImportAttribute("Pinvoke.dll", EntryPoint = "TestPtrPtr", CallingConvention = CallingConvention.Cdecl)]
            public static extern void TestPtrPtr(ref System.IntPtr a, int length);
    
            /// Return Type: void
            ///a: int*
            ///length: int
            [DllImportAttribute("Pinvoke.dll", EntryPoint = "TestArray", CallingConvention = CallingConvention.Cdecl)]
            public static extern void TestArray(int[] a, int length);
    
            /// Return Type: void
            ///pf: Anonymous_5afb5371_1680_4be9_99a9_ab5bd7ded029
            [DllImportAttribute("Pinvoke.dll", EntryPoint = "TestCallback", CallingConvention = CallingConvention.Cdecl )]
            public static extern void TestCallback(Callback pf);
    
            /// Return Type: int
            ///s: char*
            [DllImportAttribute("Pinvoke.dll", EntryPoint = "TestCharWidth", CallingConvention = CallingConvention.Cdecl)]
            public static extern int TestCharWidth( IntPtr s);
    
            static void Main(string[] args)
            {
    
                Console.WriteLine("TestInt:" + TestInt(, ));
    
                // TestIntPtr
                int i = ;
                TestIntPtr(ref i);
                Console.WriteLine("TestIntPtr:" + i);
    
                // TestCharPtr
                IntPtr helloPtr = Marshal.StringToHGlobalAnsi("啊阿斯达斯的阿萨德+");
                IntPtr worldPtr = Marshal.StringToHGlobalAnsi("+阿萨德阿萨德");
                IntPtr helloWorldPtr = TestCharPtr(helloPtr, worldPtr);
                string helloWorld = Marshal.PtrToStringAnsi(helloWorldPtr);
                Console.WriteLine("TestCharPtr:" + helloWorld);
    
                //helloPtr = Marshal.StringToHGlobalUni("啊阿斯蒂芬a");
                //worldPtr = Marshal.StringToHGlobalUni("阿萨德阿萨德");
                //helloWorldPtr = TestCharPtr(helloPtr, worldPtr);
                //helloWorld = Marshal.PtrToStringUni(helloWorldPtr);
                //Console.WriteLine("TestCharPtr01:" + helloWorld);
              //  Marshal.FreeCoTaskMem()
                Marshal.FreeHGlobal(helloPtr);
                Marshal.FreeHGlobal(worldPtr);
    
                // Marshal.FreeHGlobal(helloWorldPtr);  // 因为helloWorldPtr和helloPtr指向的是同一地址，所以再次释放会报错
    
                // TestCharWidth
                string a = "a的";
                IntPtr aPtr = Marshal.StringToHGlobalAnsi(a); // Ansi
                int len = TestCharWidth(aPtr);
                Console.WriteLine("TestCharWidth:" + len);
                a = Marshal.PtrToStringAnsi(aPtr);
                Marshal.FreeHGlobal(aPtr);
    
                aPtr = Marshal.StringToHGlobalUni(a); // Unicode
                len = TestCharWidth(aPtr); // 值是1，strlen没有正确处理unicode，所以不要使用strlen测量unicode字符串的长度
                Console.WriteLine("TestCharWidth:" + len);
                a = Marshal.PtrToStringUni(aPtr);
                Marshal.FreeHGlobal(aPtr);
    
                // TestStructPtr
                Mytype myType = new Mytype { i = , d = 1.1, s = a, p = IntPtr.Zero };
                TestStructPtr(ref myType);
                Console.WriteLine("Mytype->i:" + myType.i);
                Console.WriteLine("Mytype->d:" + myType.d);
    
                // TestArray
                int[] array = new int[] { , ,  };
                TestArray(array, array.Length);
    
                for (int z = ; z < array.Length; z++)
                {
                    Console.WriteLine("array[{0}]" + array[z], z);
                }
    
                // TestCallback
                TestCallback(CallbackFunction);
    
                Console.Read();
            }
    
        }