[Question] Any method to create a event like DLL_PROCESS_DETACH?

[marcussacana]

I wanna stop a memory leak, no ideia to do this without a event while end the process.

[3F]

• Some questions regarding DllExport #45 (comment)
• Can i export a method just called 'DllMain'? #5

Therefore, the easy way to aggregate control of this manually via Observer pattern etc. (unmanaged / managed side)
Also if you have logic from unmanaged code that will be executed with managed env, try to use Conari.

[marcussacana]

Thank you, this Conari looks interesting, should I close the issue or keep it open for future reference?

--Edit, I used the AppDomain.ProcessExit event, he is called but he have a "timeout" to free the memory... if the event exceed this, he is interrupted... (3 secs in my target process, i don't know if this can change)

[3F]

Leave it open if your problem still is actual.

• Opened issues may be reconsidered later again by me or anyone else.
• After closing it still may be referenced & commented without any problems.

[3F]

@marcussacana just noticed your new edit (please note, github will never send notification for edit)

I do not recommend to use AppDomain.ProcessExit event because it doesn't give guarantee for this operation.

Also, the timeout settings available only for unmanaged api, e.g.:

ICLRPolicyManager* clrpm;
if(FAILED(pControl->GetCLRManager(__uuidof(ICLRPolicyManager), (void**)&clrpm))) {
    return -1;
}

// https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/hosting/eclroperation-enumeration
clrpm->SetTimeout(OPR_ProcessExit, 30000); //30sec

Thus, try to implement any your custom manager. I don't know what you do, but for example:

• Extract a common interface like IUnmanagedResource which will contain methods for allocation and release, like Alloc(), Free() etc.
• Implement a common manager that will aggregate all IUnmanagedResource and provide a common methods through pointer to struct for other side.

Define a Host side that will manage resources: if clr side is unstable (domain may be destructed in any time without notice the unmanaged side) you should share it from unmanaged for managed side (but it can be implemented vice versa) for any allocation of resources.

The managed module can request allocation of resources from unmanaged side and access to this data via pointer to structures etc. Conari also may help to work with this data even without declaration of this structures at all, for example:

unmanaged C++

    struct TSpecB
    {
        bool d;
        TSpecA* s;
    };

    struct TSpecA
    {
        int a;
        int b;
    };

    A->a = 4;
    A->b = -8;
    B->d = true;
    B->s = TSpecA*;

Conari (illustration of native raw accessing without declaration):

[DllExport]
public static void mypoint(IntPtr ptr)
{
    var TSpecBPtr = NativeData
                        ._(ptr)
                        .t<bool>("d")
                        .t<IntPtr>("s")
                        .AlignSizeByMax;


    ...
    dynamic dlr = TSpecBPtr.Raw.Type;

    IntPtr addrA = dlr.s;
    Assert.AreEqual(true, dlr.d);

    // B->A

    var TSpecAPtr = NativeData
                        ._(addrA)
                        .align<Int32>(2, "a", "b");

    dynamic s = TSpecAPtr.Raw.Type;

    Assert.AreEqual(4, s.a);  // B->s->a
    Assert.AreEqual(-8, s.b); // B->s->b

...

Therefore, even if domain of some this loaded module will be destroyed (unexpectedly for unmanaged side) you can still release it via known IUnmanagedResource methods.

[3F]

I closed this issue. Please reopen if this still is actual.

About:

I wanna stop a memory leak,

You can also look #78