O que é uma DLL?

Traduções deste artigo Traduções deste artigo
ID do artigo: 815065 - Exibir os produtos aos quais esse artigo se aplica.
Expandir tudo | Recolher tudo

Neste artigo

Sumário

Este artigo descreve o que é uma biblioteca de vínculo dinâmico (DLL) e os diversos problemas que podem ocorrer quando você usar DLLs.

Em seguida, este artigo descreve alguns problemas avançados que você deve considerar ao desenvolver suas próprias DLLs. Descrevendo o que uma DLL é, este artigo descreve métodos de vinculação dinâmicos, dependências DLL, pontos de entrada DLL, exportando funções DLL e ferramentas de solução de problemas de DLL.

Este artigo termina com uma comparação de alto nível das DLLs para os assemblies do Microsoft.NET Framework.

INTRODUÇÃO

Para os sistemas operacionais Microsoft Windows que estão listados na seção "Aplica-se a" grande parte da funcionalidade do sistema operacional é fornecida pelas bibliotecas de vínculo dinâmico (DLL). Além disso, quando você executa um programa em um desses sistemas operacionais do Windows, grande parte da funcionalidade do o programa pode ser prestado por DLLs. Por exemplo, alguns programas podem conter muitos módulos diferentes e cada módulo do programa está contido e distribuído em DLLs.

O uso de DLLs ajuda a promover a modularização das código, reutilização de código, uso eficiente da memória e espaço reduzido. Portanto, o sistema operacional e os programas carregam mais rápido, executadas com maior rapidez e menor espaço em disco no computador.

Quando um programa usa uma DLL, um problema que é chamado de dependência pode fazer com que o programa não seja executado. Quando um programa usa uma DLL, uma dependência é criada. Se outro programa sobrescreve e divide esse dependência, o programa original pode não executar com êxito.

Com o Introdução do Microsoft.NET Framework, a maioria dos problemas de dependência têm foram eliminados por meio de módulos (assemblies).

Mais Informações

O que é uma DLL?

Uma DLL é uma biblioteca que contém código e dados que podem ser usados por mais de um programa ao mesmo tempo. Por exemplo, no sistema operacional Windows sistemas, caixa de diálogo comum de DLL Comdlg32 executa funções relacionadas à caixa. Portanto, cada programa pode usar a funcionalidade que está contida nessa DLL para implementar um Abrir caixa de diálogo. Isso ajuda a promover a reutilização de código e uso eficiente da memória.

Usando uma DLL, um programa pode ser modularizado em componentes separados. Por exemplo, um programa de contabilidade pode ser vendido por módulo. Cada módulo pode ser carregado para o programa principal em tempo de execução se Esse módulo está instalado. Porque os módulos são separados, o tempo de carregamento do o programa é mais rápido e um módulo é carregado somente quando essa funcionalidade é solicitada.

Além disso, as atualizações são mais fáceis aplicar a cada módulo sem afetar outras partes do programa. Por exemplo, você pode ter um programa de folha de pagamento, os taxas e impostos altera cada ano. Quando essas alterações são isolado em uma DLL, você pode aplicar uma atualização sem a necessidade de criar ou instalar todo o programa novamente.

A lista a seguir descreve alguns do arquivos que são implementados como DLLs em sistemas operacionais Windows:
  • Arquivos de controles ActiveX (. ocx)
    Um exemplo de um controle ActiveX é um calendário de controle que permite que você selecione uma data de um calendário.
  • Arquivos (. cpl) do painel de controle
    Um exemplo de um arquivo. cpl é um item que está localizado em Painel de controle. Cada item é uma DLL especializada.
  • Arquivos de driver (. drv)
    Um exemplo de um driver de dispositivo é um driver de impressora que Controla a impressão em uma impressora.

Vantagens DLL

A lista a seguir descreve algumas das vantagens que são fornecidas quando um programa usa uma DLL:
  • Usa menos recursos
    Quando vários programas usam a mesma biblioteca de funções, um DLL pode reduzir a duplicação de código que é carregado no disco e em memória física. Isso pode influenciar bastante o desempenho de não apenas o programa que está sendo executado em primeiro plano, mas também outros programas que são em execução no sistema operacional Windows.
  • Promove a arquitetura modular
    Uma DLL ajuda a promover a desenvolver programas modulares. Isso ajuda a desenvolver programas grandes que necessitam de várias versões de idioma ou um programa que requer a arquitetura modular. Um exemplo de um programa modular é um programa de contabilidade que possui muitos módulos que podem ser carregados dinamicamente em execução tempo.
  • Facilita implantação e instalação
    Quando uma função dentro de uma DLL precisa de uma atualização ou uma correção, o implantação e instalação da DLL não requer o programa a ser vincular novamente com a DLL. Além disso, se vários programas usam a mesma DLL, o vários programas todos serão beneficiados com a atualização ou correção. Esse problema pode ocorrem com mais freqüência quando você usa uma DLL de terceiros é atualizada regularmente ou fixo.

Dependências de DLL

Quando um programa ou uma DLL usa uma função de DLL na DLL de outro, um dependência é criada. Portanto, o programa não está mais independente, e o programa poderá ter problemas se a dependência é quebrada. Por exemplo, o programa não pode ser executado se uma das seguintes ações ocorrem:
  • Uma DLL dependente é atualizada para uma nova versão.
  • Uma DLL dependente é fixa.
  • Uma DLL dependente é substituída com o anterior versão.
  • Uma DLL dependente é removida do computador.
Geralmente, essas ações são conhecidas como conflitos de DLL. Se para trás compatibilidade não é aplicada, o programa pode não conseguir Execute.

A lista a seguir descreve as alterações que foram introduzido no Microsoft Windows 2000 e posteriores sistemas operacionais Windows ajuda a minimizar problemas de dependência:
  • Proteção de arquivo do Windows
    Em proteção de arquivo do Windows impede que o sistema operacional sistema DLLs de sendo atualizados ou excluídos por um agente não autorizado. Portanto, Quando uma instalação de programa tenta remover ou atualizar uma DLL que é definida como um sistema DLL, proteção de arquivo do Windows irá procurar por um digital válida assinatura.
  • DLLs particular
    DLLs particular permitem isolar um programa a partir de alterações feitas para compartilhada DLLs. Private DLLs usar informações específicas de versão ou um vazio arquivo. local para impor a versão da DLL que é usado pelo programa. Para usar DLLs particulares, localize as DLLs na pasta raiz do programa. Em seguida, para o novo programas, adicione informações específicas de versão para a DLL. Para programas antigos, use um arquivo. local vazia. Cada método informa o sistema operacional a usar a privada DLLs estão localizadas na pasta raiz do programa.

Ferramentas de solução de problemas de DLL

Várias ferramentas estão disponíveis para ajudá-lo a solucionar problemas DLL. As ferramentas a seguir são algumas dessas ferramentas.

Dependency Walker

O Dependency Walker ferramenta pode recursivamente procurar todos os dependentes DLLs que são usadas por um programa. Quando você abre um programa no Dependency Walker, Dependency Walker executa as seguintes verificações:
  • Dependency Walker verifica faltando DLLs.
  • Dependency Walker verifica arquivos de programa ou DLLs que são não é válido.
  • Dependency Walker verifica que funções de importação e exportação funções correspondem.
  • Dependency Walker verifica a existência de dependência circular erros.
  • Dependency Walker procura por módulos que não são válidos como os módulos são para um sistema operacional diferente.
Usando o Dependency Walker, você pode documentar todas as DLLs que um usa o programa. Isso pode ajudar a evitar e corrigir problemas DLL que podem ocorrer em o futuro. Dependency Walker está localizado no seguinte diretório quando você Instale o Microsoft Visual Studio 6.0:
unidade\Program Files\Microsoft visual Studio\Common\Tools

DLL Universal problema Solver

A ferramenta de DLL Universal problema Solver (DUPS) é usada para fazer a auditoria, Comparar, documento e exibir informações de DLL. A lista a seguir descreve os utilitários que compõem a ferramenta DUPS:
  • Dlister.exe
    Este utilitário enumera todas as DLLs no computador e logs as informações para um arquivo de texto ou para um arquivo de banco de dados.
  • Dcomp.exe
    Este utilitário compara as DLLs que são listadas no texto dois arquivos e produz um terceiro arquivo de texto que contém as diferenças.
  • Dtxt2DB.exe
    Este utilitário carrega os arquivos de texto são criados usando o utilitário de Dlister.exe e o utilitário Dcomp.exe para o dllHell banco de dados.
  • DlgDtxt2DB.exe
    Esse utilitário fornece uma interface gráfica do usuário (GUI) versão do utilitário Dtxt2DB.exe.
Para Para obter mais informações sobre a ferramenta DUPS, clique no número de artigo que se segue para ler o artigo na Base de dados de Conhecimento da Microsoft:
247957Usando DUPS.exe para resolver problemas de compatibilidade DLL

Desenvolvimento de DLL

Esta seção descreve os problemas e os requisitos que você deve considerar ao desenvolver suas próprias DLLs.

Tipos de DLLs

Quando você carrega uma DLL em um aplicativo, dois métodos de vinculação let você chama as funções DLL exportadas. Os dois métodos de vinculação são o tempo de carregamento vinculação dinâmica e a vinculação dinâmica do tempo de execução.
A vinculação dinâmica do tempo de carregamento
Em tempo de carregamento dinâmico vinculando, um aplicativo faz chamadas explícitas Para exportar funções DLL como funções locais. Para usar o tempo de carregamento dinâmico vinculando, fornecer um cabeçalho (. h) de arquivos e uma biblioteca de importação (. lib) do arquivo quando você compilar e vincular o aplicativo. Quando você fizer isso, o vinculador fornecerá o sistema com as informações necessárias para carregar a DLL e resolver o locais de função DLL exportados em tempo de carregamento.
A vinculação dinâmica do tempo de execução
No tempo de execução dinâmico vinculando, um aplicativo chama a função LoadLibrary ou a função LoadLibraryEx carregar a DLL em tempo de execução. Após a DLL carregado com êxito, use a função de GetProcAddress para obter o endereço do arquivo DLL função que você deseja chamar. Quando você usar a vinculação dinâmica do tempo de execução, não é necessário um arquivo de biblioteca de importação.

A lista a seguir descreve o aplicativo critérios de quando usar a vinculação dinâmica do tempo de carregamento e quando usar o tempo de execução vinculação dinâmica:
  • Desempenho de inicialização
    Se o desempenho de inicialização do aplicativo importante, você deve usar a vinculação dinâmica do tempo de execução.
  • Facilidade de uso
    No tempo de carregamento dinâmico vinculando, são as funções DLL exportadas como funções locais. Isso torna mais fácil para você chamar esses funções.
  • Lógica do aplicativo
    Em tempo de execução dinâmico vinculando, um aplicativo pode ramificar para carregar diferentes módulos conforme necessário. Isso é importante ao desenvolver versões de vários idiomas.

O ponto de entrada DLL

Quando você cria uma DLL, opcionalmente, você pode especificar um ponto de entrada função. A função de ponto de entrada é chamada quando processos ou threads anexar Se a DLL ou desanexado próprios da DLL. Você pode usar o função de ponto de entrada para inicializar estruturas de dados ou destruir dados estruturas conforme exigido pela DLL. Além disso, se o aplicativo for com vários segmentos, você pode usar o armazenamento local de thread (TLS) para alocar a memória que é particular para cada segmento na função de ponto de entrada. O código a seguir é um exemplo da função de ponto de entrada DLL.
BOOL APIENTRY DllMain(
HANDLE hModule,	// Handle to DLL module
	DWORD ul_reason_for_call,	// Reason for calling function
	LPVOID lpReserved ) // Reserved
{
	switch ( ul_reason_for_call )
	{
		case DLL_PROCESS_ATTACHED:
		// A process is loading the DLL.
		break;
		case DLL_THREAD_ATTACHED:
		// A process is creating a new thread.
		break;
		case DLL_THREAD_DETACH:
		// A thread exits normally.
		break;
		case DLL_PROCESS_DETACH:
		// A process unloads the DLL.
		break;
	}
	return TRUE;
}
Quando a função de ponto de entrada retorna um valor FALSE , o aplicativo não será iniciado se você estiver usando o tempo de carregamento vinculação dinâmica. Se você estiver usando vinculação dinâmica tempo de execução, somente a pessoa DLL não será carregado.

A função de ponto de entrada deve realizar apenas simples tarefas de inicialização e não deve chamar qualquer carregamento de DLL ou rescisão funções. Por exemplo, na função de ponto de entrada, você deve não diretamente ou indiretamente, chame a função LoadLibrary ou a função LoadLibraryEx . Além disso, você não deve chamar a função FreeLibrary quando o processo está sendo encerrado.

Observação Em aplicativos multissegmentados, certifique-se que o acesso para a DLL dados globais é sincronizada (segmento seguro) para evitar corrupção de dados possíveis. Para fazer isso, use o TLS para fornecer dados exclusivos para cada thread.

Exportando funções DLL

Para exportar funções DLL, você pode adicionar uma palavra-chave function para a DLL exportada funções ou criar um arquivo de definição (. def) do módulo que lista as funções DLL exportadas.

Para usar uma palavra-chave de função, você deve Declare cada função que você deseja exportar com a seguinte palavra-chave:
__declspec(dllexport)
Para usar as funções DLL exportadas no aplicativo, você deve declarar cada função que você deseja importar com a seguinte palavra-chave:
__declspec(DllImport)
Normalmente, você poderia usar um arquivo de cabeçalho com uma instrução Definir e uma instrução ifdef para separar a declaração de exportação e importação instrução.

Você também pode usar um arquivo de definição de módulo para declarar funções DLL exportadas. Quando você usa um arquivo de definição de módulo, você não tem Para adicionar a palavra-chave function para as funções DLL exportadas. No módulo arquivo de definição, você declara a declaração de biblioteca e a declaração de exportações para a DLL. O código a seguir é um exemplo de um arquivo de definição.
// SampleDLL.def
//
LIBRARY "sampleDLL"

EXPORTS
  HelloWorld

DLL de exemplo e aplicativos

No Microsoft Visual C++ 6.0, você pode criar uma DLL, selecionando tanto o Biblioteca de vínculo dinâmico do Win32 tipo de projeto ou a MFC AppWizard (dll) tipo de projeto.

O código a seguir é um exemplo de uma DLL que foi criado no Visual C++, usando o Biblioteca de vínculo dinâmico do Win32 tipo de projeto.
// SampleDLL.cpp
//

#include "stdafx.h"
#define EXPORTING_DLL
#include "sampleDLL.h"

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    return TRUE;
}

void HelloWorld()
{
	MessageBox( NULL, TEXT("Hello World"), TEXT("In a DLL"), MB_OK);
}
// File: SampleDLL.h
//
#ifndef INDLL_H
#define INDLL_H

#ifdef EXPORTING_DLL
extern __declspec(dllexport) void HelloWorld() ;
#else
extern __declspec(dllimport) void HelloWorld() ;
#endif

#endif
O código a seguir é um exemplo de um Win32 Aplicação projeto que chama a função DLL exportada na DLL SampleDLL.
// SampleApp.cpp 
//

#include "stdafx.h"
#include "sampleDLL.h"

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{ 	
	HelloWorld();
	return 0;
}
Observação Em tempo de carregamento dinâmico vinculação, você deve vincular o SampleDLL.lib biblioteca de importação é criada quando você cria o SampleDLL projeto.

Em tempo de execução dinâmico vinculação, você pode usar código semelhante a o código a seguir para chamar o SampleDLL.dll exportados função de DLL.
...
typedef VOID (*DLLPROC) (LPTSTR);
...
HINSTANCE hinstDLL;
DLLPROC HelloWorld;
BOOL fFreeDLL;

hinstDLL = LoadLibrary("sampleDLL.dll");
if (hinstDLL != NULL)
{
    HelloWorld = (DLLPROC) GetProcAddress(hinstDLL, "HelloWorld");
    if (HelloWorld != NULL)
        (HelloWorld);

    fFreeDLL = FreeLibrary(hinstDLL);
}
...
Quando você compilar e vincular o aplicativo SampleDLL, o Windows sistema operacional procura a DLL SampleDLL nos seguintes locais nesta ordem:
  1. A pasta de aplicativo
  2. A pasta atual
  3. A pasta de sistema do Windows

    Observação A função GetSystemDirectory retorna o caminho do sistema Windows pasta.
  4. A pasta do Windows

    Observação A função GetWindowsDirectory retorna o caminho da pasta do Windows.

O assembly do.NET Framework

Com a introdução do Microsoft .NET e.NET Framework, a maioria dos problemas que estão associados com DLLs foram eliminada pelo usando assemblies. Um assembly é uma unidade lógica de funcionalidade que é executado sob o controle do .NET common language runtime (CLR). Um assembly fisicamente existe como um arquivo. dll ou como um arquivo .exe. No entanto, internamente um assembly é muito diferente de uma DLL do Microsoft Win32.

Um assembly arquivo contém um manifesto do assembly, metadados de tipo, Microsoft intermediário código do idioma (MSIL) e outros recursos. O manifesto do assembly contém o metadados do assembly que fornecem todas as informações necessárias para um assembly para ser autodescritivos. As informações a seguir estão incluídas na manifesto do assembly:
  • Nome do assembly
  • Informações de versão
  • Informações de cultura
  • Informações de nome de alta segurança
  • A lista de assemblies de arquivos
  • Informações de referência de tipo
  • Informações de assembly referenciado e dependentes
O código MSIL contido no assembly não pode ser executados diretamente. Em vez disso, a execução de código MSIL é gerenciada através do CLR. Por padrão, quando você cria um assembly, o assembly é particular para o aplicativo. Para criar um assembly compartilhado requer que você atribua um nome forte para o assembly e, em seguida, publica o assembly no global assembly cache.

A lista a seguir descreve alguns dos recursos de assemblies em comparação com os recursos do Win32 DLLs:
  • Autodescritivos
    Quando você cria um assembly, todas as informações que são necessário para o CLR para executar o assembly está contido no manifesto do assembly. O manifesto do assembly contém uma lista de assemblies dependentes. Portanto, o CLR pode manter um conjunto consistente de módulos (assemblies) que são usados na aplicativo. DLLs Win32, você não pode manter a consistência entre um conjunto de DLLs que são usadas em um aplicativo quando você usar DLLs compartilhadas.
  • Controle de versão
    Em um manifesto do assembly, informações de versão são registradas e impostas pelo CLR. Além disso, as políticas de versão permitem aplicar uso da versão específica. DLLs Win32, controle de versão não pode ser imposta pela sistema operacional. Em vez disso, certifique-se de que as DLLs estão com versões anteriores compatível.
  • Implantação de lado a lado
    Assemblies de dar suporte à implantação de lado a lado. Um aplicativo pode usar uma versão de um assembly e outro aplicativo pode usar um diferente versão de um assembly. A partir do Windows 2000, é de implantação de lado a lado suporte para localizar as DLLs na pasta do aplicativo. Além disso, o Windows Proteção de arquivo impede DLLs de sistema sobrescrito ou substituído por um agente não autorizado.
  • Isolamento e Self-containment
    Um aplicativo desenvolvido com o uso de um assembly pode ser autônomo e isolado de outros aplicativos que estão sendo executados na computador. Esse recurso ajuda a criar instalações de impacto zero.
  • Execução
    Um assembly é executado sob as permissões de segurança que são fornecidos no assembly manifesto e que são controlados pela CLR.
  • Independente de linguagem
    Um assembly pode ser desenvolvido usando qualquer um do suporte para linguagens .NET. Por exemplo, você pode desenvolver um assembly no Microsoft O Visual C# e, em seguida, use o assembly em um Microsoft Visual Basic .NET projeto.

Referências

Para obter mais informações sobre DLLs e o.NET Framework assemblies, visite os seguintes sites da Microsoft:
Conflitos de DLL
http://msdn2.microsoft.com/en-us/library/ms811694.aspx

Implementação de compartilhamento em aplicativos de componentes lado a lado
http://msdn2.microsoft.com/en-us/library/ms811700.aspx

Como criar e serviço de aplicativos isolados e montagens lado a lado para o Windows XP
http://msdn2.microsoft.com/en-us/library/ms997620.aspx

Simplificando a implantação e solução de conflitos de DLL com o.NET Framework
http://msdn2.microsoft.com/en-US/netframework/aa497268.aspx

Guia do desenvolvedor do.NET Framework: Assemblies
. aspx de http://msdn2.microsoft.com/en-us/library/hk5f40ct (vs.71)

A vinculação dinâmica do tempo de execução
http://msdn2.microsoft.com/en-us/library/ms685090.aspx

Armazenamento local de thread
http://msdn2.microsoft.com/en-us/library/ms686749.aspx

Propriedades

ID do artigo: 815065 - Última revisão: domingo, 10 de março de 2013 - Revisão: 7.0
A informação contida neste artigo aplica-se a:
  • Microsoft Windows Server 2003, Datacenter Edition (32-bit x86)
  • Microsoft Windows Server 2003, Datacenter Edition for Itanium-Based Systems
  • Microsoft Windows Server 2003, Datacenter x64 Edition
  • Microsoft Windows Server 2003, Enterprise Edition (32-bit x86)
  • Microsoft Windows Server 2003, Enterprise Edition for Itanium-based Systems
  • Microsoft Windows Server 2003, Enterprise x64 Edition
  • Microsoft Windows Server 2003, Standard Edition (32-bit x86)
  • Microsoft Windows Server 2003, Standard x64 Edition
  • Microsoft Windows Server 2003, Web Edition
  • Microsoft Windows 2000 Advanced Server
  • Microsoft Windows 2000 Server
  • Microsoft Windows XP Professional
  • Microsoft Windows XP Home Edition
  • Microsoft Windows XP Media Center Edition 2005 Update Rollup 2
  • Microsoft Windows XP Tablet PC Edition
  • Microsoft Windows 2000 Professional Edition
  • Microsoft Windows NT Workstation 4.0 Developer Edition
  • Microsoft Windows NT Workstation 3.51
  • Microsoft Visual Studio .NET 2003 Professional Edition
  • Microsoft Visual Studio .NET 2003 Enterprise Architect
  • Microsoft Visual Studio .NET 2003 Enterprise Developer
  • Microsoft Visual Studio .NET 2003 Academic Edition
  • Microsoft Visual Studio .NET 2002 Professional Edition
  • Microsoft Visual Studio .NET 2002 Enterprise Architect
  • Microsoft Visual Studio .NET 2002 Enterprise Developer
  • Microsoft Visual Studio .NET 2002 Academic Edition
  • Microsoft Visual Basic 6.0 Professional Edition
  • Microsoft Visual Studio 6.0 Enterprise Edition
  • Microsoft Visual Studio 2005 Professional Edition
  • Microsoft Visual Studio 2005 Standard Edition
  • Microsoft Office XP Professional Edition
  • Microsoft Office XP Small Business Edition
  • Microsoft Office XP Standard Edition
  • Microsoft Office Professional Edition 2003
  • Microsoft Office Small Business Edition 2003
Palavras-chave: 
kbxplatform kbtshoot kbdebug kbdll kbinfo kbmt KB815065 KbMtpt
Tradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine Translation ou MT), não tendo sido portanto traduzido ou revisto por pessoas. A Microsoft possui artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais, com o objetivo de oferecer em português a totalidade dos artigos existentes na base de dados de suporte. No entanto, a tradução automática não é sempre perfeita, podendo conter erros de vocabulário, sintaxe ou gramática. A Microsoft não é responsável por incoerências, erros ou prejuízos ocorridos em decorrência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza atualizações freqüentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 815065

Submeter comentários

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com