结构和析构函数

Question

我创建的类型IntPtr<T>表现得像一个普通指针的C/C++有：

public struct IntPtr<T> : IDisposable where T : struct 
{ 
    private static Dictionary<IntPtr, GCHandle> handles = new Dictionary<IntPtr, GCHandle>(); 

    private IntPtr ptr; 

    public IntPtr(ref T value) 
    { 
     GCHandle gc = GCHandle.Alloc(value, GCHandleType.Pinned); 

     ptr = gc.AddrOfPinnedObject(); 
     handles.Add(ptr, gc); 
    } 

    public IntPtr(ref T[] value) 
    { 
     GCHandle gc = GCHandle.Alloc(value, GCHandleType.Pinned); 

     ptr = gc.AddrOfPinnedObject(); 
     handles.Add(ptr, gc); 
    } 

    public IntPtr(IntPtr value) 
    { ptr = value; } 

    public IntPtr(IntPtr<T> value) 
    { ptr = value.ptr; } 

    public void Dispose() 
    { 
     if (handles.ContainsKey(ptr)) 
     { 
      GCHandle gc = handles[ptr]; 
      gc.Free(); 
      handles.Remove(ptr); 
      ptr = IntPtr.Zero; 
     } 
    } 

    public T? this[int index] 
    { 
     get 
     { 
      if (ptr == IntPtr.Zero) return null; 
      if (index < 0) throw new IndexOutOfRangeException(); 

      if (handles.ContainsKey(ptr)) 
      { 
       GCHandle gc = handles[ptr]; 

       if (gc.Target is Array) return ((T[])gc.Target)[index]; 

       return (T)gc.Target; 
      } 

      return null; 

     } 
     set 
     { 
      if (index < 0) throw new IndexOutOfRangeException(); 
      // not yet implemented 
     } 
    } 

    private T[] getArray() 
    { 
     if (handles.ContainsKey(ptr)) return (T[])handles[ptr].Target; 

     return null; 
    } 

    public int Count 
    { 
     get 
     { 
      if(handles.ContainsKey(ptr)) 
      { 
       GCHandle gc = handles[ptr]; 
       if (gc.Target is Array) return ((T[])gc.Target).Length; 

       return 1; 
      } 

      return 0; 
     } 
    } 

    public static implicit operator IntPtr(IntPtr<T> value) { return value.ptr; } 

    public static implicit operator T(IntPtr<T> value) { return (T)value[0]; } 

    public static implicit operator T[](IntPtr<T> value) { return value.getArray(); ; } 

    public static implicit operator T?(IntPtr<T> value) { return value[0]; } 

} 

它尚未完成，但现在它的工作原理，问题是我通过存储保持GCHandle跟踪他们handles现在我需要释放GCHandle一旦没有更多的需要的，所以我必须声明一个destrcutor但是C＃不允许struct有destrcutor或重写“终结”的方法，如果IntPtr<T>类型的这种变量超出破坏发生的范围，但GCHandle将不会免费。

UPDATE

由于这类用途的例子，假设我们打算从COM interpo COAUTHIDENTITY和COAUTHINFO，这里将是什么样子：

[StructLayout(LayoutKind.Sequential)] 
struct COAUTHIDENTITY 
{ 
    [MarshalAs(UnmanagedType.LPWStr)] string User; 
    uint UserLength; 
    [MarshalAs(UnmanagedType.LPWStr)] string Domain; 
    uint DomainLength; 
    [MarshalAs(UnmanagedType.LPWStr)] string Password; 
    uint PasswordLength; 
    uint Flags; 
} 

[StructLayout(LayoutKind.Sequential)] 
struct COAUTHINFO 
{ 
    uint dwAuthnSvc; 
    uint dwAuthzSvc; 
    [MarshalAs(UnmanagedType.LPWStr)] string pwszServerPrincName; 
    uint dwAuthnLevel; 
    uint dwImpersonationLevel; 
    IntPtr<COAUTHIDENTITY> pAuthIdentityData; 
    uint dwCapabilities; 
} 

反而使pAuthIdentityData的IntPtr并使用Marshal成员函数来获取COAUTHIDENTITY类型的对象，IntPtr<T>将使其更简单。

现在的问题是：我应该在IntPtr<T>发布时，在哪里写代码以释放GCHandle？

Answer 1

您正在重新发明轮子。看看SafeHandle课程。使用现有的后代或创建自己的后代。