Compartilhar via

DLLs MFC regulares vinculadas dinamicamente ao MFC

  • Artigo

Uma DLL do MFC regular vinculada dinamicamente ao MFC é uma DLL que usa o MFC internamente e as funções exportadas na DLL podem ser chamadas por executáveis MFC ou não MFC. Como o nome descreve, esse tipo de DLL é criado usando a versão da biblioteca de vínculo dinâmico do MFC (também conhecida como versão compartilhada do MFC). As funções geralmente são exportadas de uma DLL do MFC regular usando a interface padrão do C.

É necessário adicionar a macro AFX_MANAGE_STATE no início de todas as funções exportadas em DLLs do MFC regulares que vinculam dinamicamente ao MFC para definir o estado do módulo atual ao da DLL. Isso é feito adicionando a seguinte linha de código ao início das funções exportadas da DLL:

AFX_MANAGE_STATE(AfxGetStaticModuleState( ))

Uma DLL MFC regular, vinculada dinamicamente ao MFC, possui os seguintes recursos:

  • Esse é um novo tipo de DLL introduzido pelo Visual C++ 4.0.

  • O executável do cliente pode ser escrito em qualquer linguagem que dê suporte ao uso de DLLs (C, C++, Pascal, Visual Basic e assim por diante); ele não precisa ser um aplicativo do MFC.

  • Ao contrário da DLL do MFC regular vinculada estaticamente, esse tipo de DLL é vinculado dinamicamente à DLL do MFC (também conhecida como DLL do MFC compartilhada).

  • A biblioteca de importação do MFC vinculada a esse tipo de DLL é a mesma usada para DLLs de extensão do MFC ou aplicativos usando a DLL do MFC: MFCxx(D).lib.

Uma DLL do MFC regular, vinculada dinamicamente ao MFC, tem os seguintes requisitos:

  • Essas DLLs são compiladas com _AFXDLL definido, assim como um executável que está vinculado dinamicamente à DLL do MFC. Mas _USRDLL também é definido, assim como uma DLL do MFC regular que está vinculada estaticamente ao MFC.

  • Esse tipo de DLL deve instanciar uma classe derivada de CWinApp.

  • Esse tipo de DLL usa o DllMain fornecido pelo MFC. Coloque todo o código de inicialização específico da DLL na função membro InitInstance e no código de encerramento ExitInstance como em um aplicativo normal do MFC.

Como esse tipo de DLL usa a versão de biblioteca de vínculo dinâmico do MFC, será necessário definir explicitamente o estado do módulo atual para o da DLL. Para fazer isso, use a macro AFX_MANAGE_STATE no início de cada função exportada da DLL.

DLLs do MFC regulares devem ter uma classe derivada de CWinApp e um único objeto dessa classe de aplicativo, assim como em um aplicativo do MFC. No entanto, o objeto CWinApp da DLL não tem uma bomba de mensagens principal, assim como o objeto CWinApp de um aplicativo.

Observe que o mecanismo CWinApp::Run não se aplica a uma DLL, pois o aplicativo é proprietário da bomba de mensagens principal. Se a DLL abrir diálogos sem janela restrita ou tiver uma janela de quadro principal própria, a bomba de mensagens principal do aplicativo deverá chamar uma rotina exportada por DLL que chama CWinApp::PreTranslateMessage.

Coloque todas as inicializações específicas de DLL na função membro CWinApp::InitInstance como em um aplicativo MFC normal. A função membro CWinApp::ExitInstance da classe derivada CWinApp será chamada da função DllMain fornecida pelo MFC antes que a DLL seja descarregada.

É necessário distribuir as DLLs compartilhadas MFCx0.dll e Msvcr*0.dll (ou arquivos semelhantes) com o aplicativo.

Uma DLL vinculada dinamicamente ao MFC também não pode vincular estaticamente ao MFC. Os aplicativos vinculam DLLs do MFC regulares vinculadas dinamicamente ao MFC, como qualquer outra DLL.

Os símbolos geralmente são exportados de uma DLL do MFC regular usando a interface padrão do C. A declaração de uma função exportada de uma DLL do MFC normal é semelhante a:

extern "C" __declspec(dllexport) MyExportedFunction( );

Todas as alocações de memória em uma DLL do MFC regular devem permanecer dentro da DLL; a DLL não deve passar nem receber do executável da chamada qualquer um dos seguintes itens:

  • ponteiros para objetos do MFC.

  • ponteiros para a memória alocados pelo MFC.

Se for necessário fazer qualquer um dos procedimentos acima ou se precisar passar objetos derivados do MFC entre o executável de chamada e a DLL, será necessário criar uma DLL de extensão do MFC.

É seguro passar para a memória ponteiros que foram alocados pelas bibliotecas de tempo de execução do C entre um aplicativo e uma DLL somente se você fizer uma cópia dos dados. Você não deve excluir nem redimensionar esses ponteiros nem usá-los sem fazer uma cópia da memória.

Ao criar uma DLL MFC regular que vincula dinamicamente ao MFC, será necessário usar a macro AFX_MANAGE_STATE para alternar o estado do módulo MFC corretamente. Isso é feito adicionando a seguinte linha de código ao início das funções exportadas da DLL:

AFX_MANAGE_STATE(AfxGetStaticModuleState( ))

A macro AFX_MANAGE_STATE não deve ser usada em DLLs do MFC regulares que vinculam estaticamente ao MFC ou em DLLs de extensão MFC. Para mais informações, consulte Gerenciar dados de estado dos módulos MFC.

Para obter um exemplo de como escrever, compilar e usar uma DLL do MFC regular, veja o exemplo DLLScreenCap. Para obter mais informações sobre DLLs do MFC regulares que vinculam dinamicamente ao MFC, consulte a seção intitulada "Converter DLLScreenCap para vincular dinamicamente com a DLL do MFC" no resumo do exemplo.

O que você deseja fazer?

Que mais você deseja saber?

Confira também

Tipos de DLLs