GCHandle, Marshal, bộ nhớ được quản lý và không được quản lý: Để ghim hoặc không ghim

Question

Là Hans Passantwishes đây là kịch bản của tôi. Tôi có một ứng dụng chế độ hỗn hợp trong đó mã gốc thực hiện tất cả công việc khó khăn trong khi tôn trọng hiệu suất và mã được quản lý chỉ chịu trách nhiệm đối với GUI. Ngoài ra, người dùng sẽ tham gia bằng cách viết mã C# độc quyền của họ. Tôi có C++ cho các lớp bản địa, C# cho GUI và mã người dùng và C++/Cli cho các lớp bao bọc ở giữa. Trong số tất cả các lớp C++ của tôi có một trong đó có% 90 của các phép tính và được tạo ra một tham số khác nhau mỗi lần. Hãy gọi nó là NativeClass. Có apprx. 2000 phiên bản của lớp NativeClass này và tôi phải tìm đúng cá thể liên quan đến một số tham số trước khi nó tính toán. Vì vậy, tôi nghĩ ra một hash_map, với các tham số là mã băm, cho mục đích này. Khi tôi nhận được một tham số, tôi tìm kiếm một thể hiện đúng trong hash_map, tôi tìm thấy nó và gọi một số phương thức của nó.
Khi người dùng contrubute để tính toán bằng cách viết mã C# và lớp này thực thi các mã này bằng callbacks. Điều này là tầm thường nhưng đôi khi tôi cần một số thông tin về các lớp .Net mà người dùng xây dựng. Vì vậy, tôi cần phải đính kèm cụ thể ManagedClass để NativeClass bằng cách nào đó. Giải pháp đầu tiên của tôi là sử dụng GChandle.Alloc() và chuyển địa chỉ xử lý. Nhưng có một số concerns về GC rằng nó sẽ không được thực hiện công việc của mình đúng cách. Hans đã đề xuất Marshal.AllocCoTaskMem() và Marshal.StructureToPtr() để phân bổ các đối tượng được quản lý trong bộ nhớ không được quản lý, tuy nhiên tôi tin rằng điều này là hợp lệ đối với các lớp hoặc cấu trúc kiểu giá trị. Làm thế nào về các lớp học ref? Làm thế nào tôi có thể vượt qua một tham chiếu đến NativeClass trong khi ngăn chặn chúng được GC thu thập và làm cho GC hoạt động đúng vào thời điểm này?

Dưới đây là một số mẫu mã:

class NativeClass 
{ 
private: 
    int AddressOfManagedHandle; 
public: 
    static NativeClass * GetNativeClassFromHashMap(int SomeParameter) 
    { 
// return NativeClass associated with SomeParameter from NativeClassHashMap; 
    } 
    NativeClass(int addr, int SomeParameter) : AddressOfManagedHandle(addr) 
    { 

    } 
    int GetAddress(){return AddressOfManagedHandle;} 
void DoCalculation(){ 
// CALCULATIONS 
} 
}; 


public ref class ManagedClass : MarshalByRefObject 
{ 
private: 
    NativeClass* _nc; 
//GCHandle handle; 
    void FreeManagedClass() 
    { 
     Marshal::FreeHGlobal(IntPtr(_nc->GetAddress())); 
//if(handle.IsAllocated) 
//handle.Free(); 
     delete _nc; 
    } 
public: 
    ManagedClass() 
    { 
     IntPtr addr = (Marshal::AllocHGlobal(Marshal::Sizeof(this))); // Error 
     Marshal::StructureToPtr(this,addr,true); 
//handle = GCHandle.Alloc(this); 
//IntPtr addr = handle.ToIntPtr(); 
     _nc = new NativeClass(addr.ToInt32()); 
    } 
    ~ManagedClass() {FreeManagedClass();} 
    !ManagedClass() {FreeManagedClass();} 
    int GetAddress() {return _nc->GetAddress();}; 
    static ManagedClass^ GetManagedClass(int SomeParameter) 
    { 
int addr = NativeClass::GetNativeClassFromHashMap(SomeParameter)->GetAddress(); 
//Object^obj = GCHandle::FromIntPtr(IntPtr(addr)).Target; 
Object^ obj = Marshal::PtrToStructure(IntPtr(addr), ManagedClass::typeid); 
    return dynamic_cast<ManagedClass^>(obj); 

    } 
}; 

Tôi xin lỗi rằng nó là toooooo dài và vẫn chưa rõ ràng.

Answer 1

tôi đã dành nhiều thời gian chiến đấu với một vấn đề tương tự và đây là phác thảo của các giải pháp mà làm việc cho tôi ....

1. Store xử lý đến lớp quản lý như một cửa hàng void *
2. một con trỏ đến lớp không được quản lý trong lớp quản lý (như bạn đã làm)
3. Sử dụng đồng bằng cũ new và delete chứ không phải là bất cứ điều gì như AllocHGlobal
4. Chuyển đổi GCHandle giữa voi d * và quản lý tài liệu tham khảo đối tượng
5. Đừng lo lắng về việc suy luận từ MarshalByRefObject - bạn không cần nó như là bạn đang làm marshalling của riêng bạn
6. Ghi mã hóa phòng thủ khi giải phóng lớp quản lý

tôi mất mã trên của bạn và tấn công vào mã đó để nhận được:

class NativeClass 
{ 
private: 
    void * managedHandle; 
public: 
    static NativeClass * GetNativeClassFromHashMap(int SomeParameter) 
    { 
     // return NativeClass associated with SomeParameter from NativeClassHashMap; 
    } 
    NativeClass(void *handle, int SomeParameter) 
     : managedHandle(handle) 
    { 
    } 
    void * ManagedHandle() 
    { 
     return managedHandle; 
    } 
    void DoCalculation() 
    { 
     // CALCULATIONS 
    } 
}; 

public ref class ManagedClass 
{ 
private: 
    NativeClass* _nc; 
    void FreeManagedClass() 
    { 
     if (_nc) 
     { 
      // Free the handle to the managed object 
      static_cast<GCHandle>(IntPtr(_nc->ManagedHandle)).Free(); 
      // Delete the native object 
      delete _nc; 
      _nc = 0; 
     } 
    } 
public: 
    ManagedClass() 
    { 
     // Allocate GCHandle of type 'Normal' (see doco for Normal, Weak, Pinned) 
     GCHandle gch = GCHandle::Alloc(this, GCHandleType::Normal); 
     // Convert to void* 
     void *handle = static_cast<IntPtr>(gch).ToPointer(); 
     // Initialise native object, storing handle to native object as void* 
     _nc = new NativeClass(handle); 
    } 
    ~ManagedClass() {FreeManagedClass();} 
    !ManagedClass() {FreeManagedClass();} 
    static ManagedClass^ GetManagedClass(int SomeParameter) 
    { 
     // Native class is retrieved from hash map 
     NativeClass *nc = NativeClass::GetNativeClassFromHashMap(SomeParameter); 
     // Extract GCHandle from handle stored in native class 
     // This is the reverse of the process used in the ManagedClass constructor 
     GCHandle gch = static_cast<GCHandle>(IntPtr(nc->ManagedHandle())); 
     // Cast the target of the GCHandle to the managed object 
     return dynamic_cast<ManagedClass^>(gch.Target); 
    } 
}; 

Điều này sẽ giúp bạn đi đúng hướng.

Answer 2

gcroot<ManagedClass^> makes this a whole lot easier

Answer 3

Hmmm.

GCHandle là cấu trúc.

Trong một số trường hợp, việc chuyển giao một GCHandle được bỏ ghim sẽ làm những gì bạn muốn.