MFC-extension DLL : initialization function

If I create a MFC-extension DLL and create an explicit initialize function as
follows:

static void MyWork_Release();

static AFX_EXTENSION_MODULE MyWorkDLL = { NULL, NULL };

extern "C" int APIENTRY
DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
{
    // Remove this if you use lpReserved
    UNREFERENCED_PARAMETER(lpReserved);

    if (dwReason == DLL_PROCESS_ATTACH)
    {
        TRACE0("MyWork.DLL Initializing!\n");

        // Extension DLL one-time initialization
        if (!AfxInitExtensionModule(MyWorkDLL, hInstance))
            return 0;

        //new CDynLinkLibrary(MyWorkDLL); // moved to MyWork_Initialize()

        //if (!AfxSocketInit())
        //{
        // return FALSE;
        //}

    }
    else if (dwReason == DLL_PROCESS_DETACH)
    {
        TRACE0("MyWork.DLL Terminating!\n");

        MyWork_Release();

        // Terminate the library before destructors are called
        AfxTermExtensionModule(MyWorkDLL);
    }
    return 1; // ok
}

static BOOL sg_bMyLL_Inited = FALSE;

// this function is entered into .def as follows:
// MyWork_Initialize @1
//
extern "C" BOOL MyWork_Initialize()
{
    static BOOL bInitedMFCResources = FALSE;
    if (!bInitedMFCResources) {
        new CDynLinkLibrary(MyWorkDLL);
        if (!AfxSocketInit()) { ASSERT(FALSE); return FALSE; }
        bInitedMFCResources = TRUE;
    }

    // other DLL-internal initializations ...

    sg_bMyLL_Inited = TRUE;
    return TRUE;
}

// this version is declared in MyWorkDLL.h (see bwlow)
//
MYWORK_DLL BOOL EXP_MyWork_Initialize()
{
    return MyWork_Initialize();
}

static void MyWork_Release()
{
    // DLL-internal clean-up ...

    sg_bMyLL_Inited = FALSE;
}

// MyWorkDLL.h:

#ifdef MYWORK_EXPORTS
#define MYWORK_DLL __declspec(dllexport)
#else
#define MYWORK_DLL __declspec(dllimport)
#endif

MYWORK_DLL BOOL EXP_MyWork_Initialize();

This DLL, MyWork.dll, will be used by other bigger DLLs in the following ways:

(1) some DLLs (regular MFC-dlls or MFC-extension dlls, same for below) will
explicitly link to

MyWork.dll by linking to MyWork.lib, and call EXP_MyWork_Initialize() during
its own DLL-initialization steps.

(2) some DLLs will, during any time at runtime, call
AfxLoadLibrary("MyWork.dll"), then GetProcAddress("MyWork_Initialize") and
invoke this function, do the work, and call AfxFreeLibrary() on MyWork.dll.

(3) a few numbers of DLLs described in (1) and (2) will uses MyWork.dll
within the same process, and can happen in different threads.

(4) the main app could also link/load MyWork.dll using either method (1) or
(2), depending on design.

My question is: is my current implementation on how to initialize MyWork.dll
the correct way (i.e. won't crash, all resources working correctly, all
windows messages will be dispatched correctly in normal circumstances, MFC
sockets/threads will work completely fine within MyWork.dll), no matter how
the dll is linked/loaded, and no matter how many time the initialization is
called by different types of dlls?

Because I wasn't too certain after reading that chunk of comments inside the
generated DllMain(). I need some confirmation.

Any feedback will be much appreciated.