C++/CLI包装器如何安全追踪非托管SRWindow对象指针？

以下是针对你的场景的几种高效解决方案，按推荐优先级排序：

方案1：使用SafeHandle派生类包装非托管指针 #

SafeHandle是.NET官方提供的用于安全管理非托管资源的抽象类，内置线程安全的引用计数机制，会在最后一个持有该句柄的托管对象被回收时自动释放非托管资源。多个SEWindow实例可以共享同一个SafeHandle，从根本上避免重复销毁问题。

实现代码 #

// 非托管SRWindow类（示例定义）
class SRWindow {
public:
    SRWindow() = default;
    ~SRWindow() = default;
    // 其他成员方法
};

// C++/CLI安全句柄类，负责SRWindow*的生命周期管理
public ref class SRWindowSafeHandle : public System::Runtime::InteropServices::SafeHandleZeroOrMinusOneIsInvalid
{
public:
    // 创建新的SRWindow并包装
    SRWindowSafeHandle() : SafeHandleZeroOrMinusOneIsInvalid(true)
    {
        SetHandle(IntPtr(new SRWindow()));
    }

    // 包装已有的SRWindow*（需确保外部不再自行销毁该对象）
    SRWindowSafeHandle(SRWindow* existingWindow) : SafeHandleZeroOrMinusOneIsInvalid(true)
    {
        SetHandle(IntPtr(existingWindow));
    }

protected:
    // 重写资源释放逻辑
    virtual bool ReleaseHandle() override
    {
        SRWindow* window = static_cast<SRWindow*>(Handle.ToPointer());
        delete window;
        SetHandle(IntPtr::Zero);
        return true;
    }
};

// 修改后的SEWindow包装类
public ref class SEWindow
{
private:
    SRWindowSafeHandle^ _safeHandle;

public:
    // 创建新的SRWindow实例
    SEWindow() : _safeHandle(gcnew SRWindowSafeHandle()) {}

    // 包装已有的SRWindow*
    SEWindow(SRWindow* existingWindow)
    {
        // 可选：添加线程安全的缓存，避免为同一指针重复创建SafeHandle
        static System::Collections::Concurrent::ConcurrentDictionary<IntPtr, SRWindowSafeHandle^>^ _handleCache = 
            gcnew System::Collections::Concurrent::ConcurrentDictionary<IntPtr, SRWindowSafeHandle^>();
        
        IntPtr ptr = IntPtr(existingWindow);
        _safeHandle = _handleCache->GetOrAdd(ptr, gcnew SRWindowSafeHandle(existingWindow));
    }

    // 获取非托管指针（仅供信任的内部逻辑使用）
    SRWindow* GetNativeWindow()
    {
        return static_cast<SRWindow*>(_safeHandle->Handle.ToPointer());
    }

    // 无需手动编写终结器，SafeHandle会自动处理资源释放
};

优势 #

• 完全遵循.NET资源管理规范，与GC深度集成
• 内置线程安全的引用计数，无需手动实现锁逻辑
• 代码简洁，不易出现内存泄漏或重复销毁问题

方案2：基于ConcurrentDictionary的轻量引用计数 #

如果无法使用SafeHandle（比如非托管对象的销毁逻辑复杂），可以用ConcurrentDictionary维护非托管指针的引用计数，这比自定义全局映射表更高效且线程安全。

实现代码 #

public ref class SEWindow : System::IDisposable
{
private:
    SRWindow* _window;
    static System::Collections::Concurrent::ConcurrentDictionary<IntPtr, int>^ _refCounts = 
        gcnew System::Collections::Concurrent::ConcurrentDictionary<IntPtr, int>();
    bool _isDisposed = false;

    void Dispose(bool disposing)
    {
        if (!_isDisposed)
        {
            IntPtr ptr = IntPtr(_window);
            // 原子递减计数
            int newCount = _refCounts->AddOrUpdate(ptr, 0, 
                [](IntPtr key, int current) { return current - 1; });
            
            if (newCount == 0)
            {
                // 最后一个引用被释放，销毁非托管对象
                delete _window;
                _refCounts->TryRemove(ptr, nullptr);
            }

            _window = nullptr;
            _isDisposed = true;
        }
    }

public:
    // 创建新的SRWindow实例
    SEWindow()
    {
        _window = new SRWindow();
        IntPtr ptr = IntPtr(_window);
        _refCounts->AddOrUpdate(ptr, 1, 
            [](IntPtr key, int current) { return current + 1; });
    }

    // 包装已有的SRWindow*
    SEWindow(SRWindow* existingWindow)
    {
        _window = existingWindow;
        IntPtr ptr = IntPtr(_window);
        _refCounts->AddOrUpdate(ptr, 1, 
            [](IntPtr key, int current) { return current + 1; });
    }

    // 显式释放资源
    ~SEWindow()
    {
        Dispose(true);
    }

    // 终结器
    !SEWindow()
    {
        Dispose(false);
    }

    virtual void System::IDisposable::Dispose() sealed
    {
        Dispose(true);
        System::GC::SuppressFinalize(this);
    }

    // 获取非托管指针
    SRWindow* GetNativeWindow()
    {
        return _window;
    }
};

优势 #

• 线程安全，无需手动加锁
• 相比自定义映射表，ConcurrentDictionary的原子操作性能更优
• 销毁时机明确，当最后一个引用释放时立即销毁非托管对象

方案3：弱引用结合延迟清理（适合低资源场景） #

如果非托管资源占用不大，且可以接受延迟销毁，可以用WeakReference追踪托管包装器，在GC触发时清理无引用的非托管对象。

实现代码 #

public ref class SEWindow
{
private:
    SRWindow* _window;
    static System::Collections::Generic::List<System::WeakReference^>^ _trackedWindows = 
        gcnew System::Collections::Generic::List<System::WeakReference^>();
    static System::Object^ _lockObj = gcnew System::Object();

    // GC触发时清理无引用的非托管对象
    [System::Runtime::CompilerServices::MethodImpl(System::Runtime::CompilerServices::MethodImplOptions::Synchronized)]
    static void CleanupUnusedWindows()
    {
        System::Collections::Generic::List<System::WeakReference^>^ toRemove = 
            gcnew System::Collections::Generic::List<System::WeakReference^>();
        
        for each (auto wr in _trackedWindows)
        {
            SEWindow^ wrapper = dynamic_cast<SEWindow^>(wr->Target);
            if (!wrapper)
            {
                // 托管包装器已被回收，销毁对应的非托管对象
                SRWindow* nativeWindow = wrapper->_window;
                delete nativeWindow;
                toRemove->Add(wr);
            }
        }

        for each (auto wr in toRemove)
        {
            _trackedWindows->Remove(wr);
        }
    }

public:
    SEWindow()
    {
        _window = new SRWindow();
        System::Threading::Monitor::Enter(_lockObj);
        _trackedWindows->Add(gcnew System::WeakReference(this));
        System::Threading::Monitor::Exit(_lockObj);

        // 注册GC通知，触发清理（可选）
        System::GC::RegisterForFullGCNotification(10, 10);
        // 可启动后台线程监听GC通知并调用CleanupUnusedWindows
    }

    SEWindow(SRWindow* existingWindow)
    {
        _window = existingWindow;
        System::Threading::Monitor::Enter(_lockObj);
        _trackedWindows->Add(gcnew System::WeakReference(this));
        System::Threading::Monitor::Exit(_lockObj);
    }

    // 终结器无需手动销毁资源，等待清理逻辑处理
    !SEWindow() {}
};

优势 #

• 无需维护引用计数，代码逻辑简单
• 适合非托管资源占用小、对销毁时机不敏感的场景

总结 #

优先选择方案1（SafeHandle），它是.NET官方推荐的标准解决方案，兼顾安全性、性能和代码简洁性。如果受限于非托管对象的特殊逻辑，方案2的轻量引用计数是次优选择。方案3仅适合低资源、对销毁延迟容忍的场景。

内容的提问来源于stack exchange，提问作者BSP0