C#调用C++DLL中的回调函数（异步的情况，DLL中会在事件触发时调用函数）

怼烎@ 2022-02-20 11:59 1307阅读 0赞

我们在使用c\#托管代码时，内存地址和GC回收那不是我们关心的，CLR已经给我们暗箱操作。  
但是如果我们在c\#中调用了一个非托管代码，比如vc的DLL,而且他有个回调函数，需要引用c\#中的某个对象并操作，  
这时候你就得要小心了。  
要是非托管代码中用到得托管代码那个对象被GC给回收了，这时候就会报内存错误。  
所以我们就要把那个对象“钉”住(pin)，让它的内存地址固定，而不被垃圾回收掉，然后最后我们自己管理，自己释放内存,这时候就需要GCHandle,来看个msdn上的例子:

![ExpandedBlockStart.gif][]   
 public delegate bool CallBack(int handle, IntPtr param);  
         public class LibWrap  
         \{  
             \[DllImport("user32.dll")\]  
          public static extern bool EnumWindows(CallBack cb, IntPtr param);  
      \}  
    
  class Program  
      \{  
          static void Main(string\[\] args)  
          \{  
    
  TextWriter tw = System.Console.Out;  
              GCHandle gch = GCHandle.Alloc(tw);  
              CallBack cewp = new CallBack(CaptureEnumWindowsProc);  
              LibWrap.EnumWindows(cewp, (IntPtr)gch);  
              gch.Free();  
              Console.Read();  
    
  \}  
  private static bool CaptureEnumWindowsProc(int handle, IntPtr param)  
          \{  
              GCHandle gch = (GCHandle)param;  
              TextWriter tw = (TextWriter)gch.Target;  
    
  tw.WriteLine(handle);  
              return true;  
          \}  
    
  \}

对上面的代码，略加解释：gch 会钉住(pin)tw这个对象，使其不受GC管理，告诉它，以后你崩管我，我也不用给你上税,其实管理权已经给gch，通过free来释放内存。  
这种情况主要用在托管和非托管代码交互的时候，防止内存泄露来使用GCHandle。

另也可以使用GC.KeepAlive 方法(引用msdn)  
KeepAlive 方法的目的是确保对对象的引用存在，该对象有被垃圾回收器过早回收的危险。这种现象可能发生的一种常见情形是，当在托管代码或数据中已没有对该对象的引用，但该对象仍然在非托管代码（如 Win32 API、非托管 DLL 或使用 COM 的方法）中使用。  
下面是例子:

![ExpandedBlockStart.gif][]   
using System;  
  using System.Threading;  
  using System.Runtime.InteropServices;  
    
  // A simple class that exposes two static Win32 functions.  
  // One is a delegate type and the other is an enumerated type.  
  public class MyWin32  
  \{  
      // Declare the SetConsoleCtrlHandler function   
      // as external and receiving a delegate.     
      \[DllImport("Kernel32")\]  
      public static extern Boolean SetConsoleCtrlHandler(HandlerRoutine Handler,  
          Boolean Add);  
    
      // A delegate type to be used as the handler routine   
      // for SetConsoleCtrlHandler.  
      public delegate Boolean HandlerRoutine(CtrlTypes CtrlType);  
    
      // An enumerated type for the control messages   
      // sent to the handler routine.  
      public enum CtrlTypes  
      \{  
          CTRL\_C\_EVENT = 0,  
          CTRL\_BREAK\_EVENT,  
          CTRL\_CLOSE\_EVENT,  
          CTRL\_LOGOFF\_EVENT = 5,  
          CTRL\_SHUTDOWN\_EVENT  
      \}  
  \}  
    
  public class MyApp  
  \{  
      // A private static handler function in the MyApp class.  
      static Boolean Handler(MyWin32.CtrlTypes CtrlType)  
      \{  
          String message = "This message should never be seen!";  
    
          // A switch to handle the event type.  
          switch (CtrlType)  
          \{  
              case MyWin32.CtrlTypes.CTRL\_C\_EVENT:  
                  message = "A CTRL\_C\_EVENT was raised by the user.";  
                  break;  
              case MyWin32.CtrlTypes.CTRL\_BREAK\_EVENT:  
                  message = "A CTRL\_BREAK\_EVENT was raised by the user.";  
                  break;  
              case MyWin32.CtrlTypes.CTRL\_CLOSE\_EVENT:  
                  message = "A CTRL\_CLOSE\_EVENT was raised by the user.";  
                  break;  
              case MyWin32.CtrlTypes.CTRL\_LOGOFF\_EVENT:  
                  message = "A CTRL\_LOGOFF\_EVENT was raised by the user.";  
                  break;  
              case MyWin32.CtrlTypes.CTRL\_SHUTDOWN\_EVENT:  
                  message = "A CTRL\_SHUTDOWN\_EVENT was raised by the user.";  
                  break;  
          \}  
    
          // Use interop to display a message for the type of event.  
          Console.WriteLine(message);  
    
          return true;  
      \}  
    
      public static void Main()  
      \{  
    
          // Use interop to set a console control handler.  
          MyWin32.HandlerRoutine hr = new MyWin32.HandlerRoutine(Handler);  
          MyWin32.SetConsoleCtrlHandler(hr, true);  
    
          // Give the user some time to raise a few events.  
          Console.WriteLine("Waiting 30 seconds for console ctrl events![dot.gif][]");  
    
          // The object hr is not referred to again.  
          // The garbage collector can detect that the object has no  
          // more managed references and might clean it up here while  
          // the unmanaged SetConsoleCtrlHandler method is still using it.        
    
          // Force a garbage collection to demonstrate how the hr  
          // object will be handled.  
          GC.Collect();  
          GC.WaitForPendingFinalizers();  
          GC.Collect();  
    
          Thread.Sleep(10000);  
    
          // Display a message to the console when the unmanaged method  
          // has finished its work.  
          Console.WriteLine("Finished!");  
    
          // Call GC.KeepAlive(hr) at this point to maintain a reference to hr.   
          // This will prevent the garbage collector from collecting the   
          // object during the execution of the SetConsoleCtrlHandler method.  
          GC.KeepAlive(hr);  
          Console.Read();  
      \}  
  \}

[ExpandedBlockStart.gif]: /images/20220220/55e06f20a159498083135ff10f375b90.png
[dot.gif]: /images/20220220/441c31417f744ef5b7a4eedf2fe6c6a4.png