Actually, as a general principle I don't believe you should ever try to
enter an apartment in a DLL unless you're doing it in a thread that your DLL
"owns" (creates and managed the lifetime of).   Perhaps there's something
unique about your situation that requires it, but I'd try to get rid of the
requirement rather than tilting at windmills trying to find a way to honor
it.

-cd

No, you should never call a method from DllMain which has managed code in it
or calls another method with managed code. You can easily get into a loader
lock problem.

The  recommended way to move code out of DllMain is to declare a global
managed object. In the constructor of that object you should call the code
which you were initially calling in DllMain. The module constructor will
initialize see this global and call the constructor.
Note: A managed object here is not a ref/value class object. You cannot
have global ref objects. Here managed object means a native class compiled
with /clr or under #pragma managed.

The reason is this works is because in mixed assemblies, the initializations
are done by the module constructor. It is very important to remember that the
module constructor for an assembly  is called only if some managed code is
first executed either in the host assembly or in your Dll itself. If you dont
"use" that managed object you will never invoke the module constructor, thus
your constructor will never be called and data will be uninitialized.

Let me give you an example,
///////////////////////
cl /clr /LD /Zi 1.cpp
cl /clr /EHa t.cpp /Zi /link 1.lib
/////////////////////

/////////////////
//1.cpp

#pragma once
#include <stdio.h>
#include <windows.h>
class __declspec(dllexport) A
{
public:
                A()
    {
    System::Console::WriteLine("Module constructor doing initialization based
on the global instance of the class A\n");
    System::Console::WriteLine("Code from DllMain, now in constructor
executed\n");
    }
    void foo()
    {
    printf("foo called so that the linker knows not to throw away an unuse
object in t.cpp \n");
    }
};

#pragma unmanaged
// Global instance of object
A obj;

extern "C"
    BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
    {
        // REMOVE ALL MANAGED CODE FROM DLLMAIN.
        return true;
    }

///////////////////////////////
//t.cpp

#include <windows.h>
using namespace System;
#include <stdio.h>
#using "1.dll"
class __declspec(dllimport) A
{
    public:
        void foo();
};
int main()
{
    LoadLibrary("1.dll");
    A obj;
    obj.foo();
}