O processo de compilação de arquivos .cs em .dll usando o comando csc
Muitas vezes, precisamos compilar separadamente o arquivo .cs em um arquivo .dll. A operação é a seguinte:
Abra a janela de comando-> insira cmd no console-> cd C:WINDOWSMicrosoft.NETFrameworkv1.1.4322
Vá até o diretório onde o vs.net está instalado -> execute o comando csc csc /target:library File.cs -> gere um arquivo .dll com o nome correspondente no diretório (pré-requisito: coloque o arquivo .cs em C: diretório WINDOWSMicrosoft.NETFrameworkv1.1.4322)
Há muitas maneiras de usar o comando csc, consulte o seguinte
Traduzir File.cs para produzir File.exe
csc File.cs compila File.cs para gerar File.dll
csc /target:library File.cs Compile File.cs e crie My.exe
csc /out:My.exe File.cs Compila todos os arquivos C# no diretório atual usando otimização e definição de símbolos DEBUG. A saída é Arquivo2.exe
csc /define:DEBUG /optimize /out:File2.exe *.cs Compila todos os arquivos C# no diretório atual para gerar uma versão de depuração de File2.dll. Não exiba nenhum logotipo ou aviso
csc /target:library /out:File2.dll /warn:0 /nologo /debug *.cs Compile todos os arquivos C# no diretório atual em Something.xyz (uma DLL)
csc /target:library /out:Something.xyz *.cs Compile File.cs para gerar File.dll
csc /target:library File.cs é o comando mais comumente usado. Na verdade, ele pode ser simplesmente escrito como csc /t:library File.cs. Outra maneira de escrevê-lo é csc /out:mycodebehind.dll /t:library. mycodebehind.cs , você mesmo pode especificar o nome do arquivo de saída.
csc /out:mycodebehind.dll /t:library mycodebehind.cs mycodebehind2.cs, a função disso é instalar dois arquivos cs em um arquivo .dll
Exemplo (retirado da Internet)
1. Biblioteca de link dinâmico
O que é uma biblioteca de link dinâmico? As três letras DLL devem ser familiares para você. É a abreviatura de Dynamic Link Library (DLL) é um arquivo executável que é uma biblioteca de funções compartilhadas. A vinculação dinâmica fornece uma maneira para um processo chamar funções que não fazem parte de seu código executável. O código executável de uma função está localizado em uma DLL que contém uma ou mais funções que foram compiladas, vinculadas e armazenadas separadamente do processo que as utiliza. DLLs também ajudam no compartilhamento de dados e recursos. Vários aplicativos podem acessar o conteúdo de uma única cópia de uma DLL na memória simultaneamente.
Como a maioria dos programadores, você deve ter usado DLLs com frequência. Você já sentiu que isso traz bons erros de programação e codificação. Hoje quero discutir um tópico com você: como criar e chamar DLL (biblioteca de vínculo dinâmico) em C# Na verdade, em um sentido amplo, DLL Ele permite. para organizar e escrever nossos aplicativos com mais flexibilidade. Como designer de software, posso obter um alto efeito de reutilização de código com base nele. Deixe-me apresentar como criar e chamar DLL em C#.
2. Trabalho de preparação
Precisamos dar uma breve introdução ao que faremos a seguir. Neste artigo, usaremos a linguagem C# para criar uma biblioteca de vínculo dinâmico chamada MyDLL.DLL. Neste arquivo de biblioteca de vínculo dinâmico, forneceremos duas funções. Trocar os valores de dois parâmetros Outra função é encontrar o máximo divisor comum de dois parâmetros. Em seguida, crie um aplicativo para usar esta DLL. Execute e produza os resultados.
3. Crie DLL
Vamos criar os três arquivos de código C# a seguir:
1. MeuSwap.cs
}
usando o sistema;
namespace Meus Métodos
{
classe pública SwapClass
{
troca de bool estático público (ref longo i, ref longo j)
{
eu = eu+j;
j = ij;
eu = ij;
retornar verdadeiro;
}
}
}
2.MeuMaxCD.cs
usando o sistema;
namespace Meus Métodos
{
classe pública MaxCDClass
{
público estático longo MaxCD (longo i, longo j)
{
longo a,b,temperatura;
se(eu>j)
{
uma = eu;
b = j;
}
outro
{
b = eu;
uma = j;
}
temperatura = a% b;
enquanto(temperatura!=0)
{
uma =b;
b = temperatura;
temperatura = a% b;
}
retornarb;
}
}
}
Deve-se destacar que ao criarmos esses dois arquivos, podemos utilizar o Visual Studio.NET ou outros editores de texto, até mesmo o Bloco de Notas. Embora esses dois arquivos não estejam no mesmo arquivo, eles pertencem ao mesmo namespace, o que tornará conveniente o uso desses dois métodos no futuro. É claro que eles também podem pertencer a namespaces diferentes, o que é perfeitamente aceitável, mas só precisamos fazer referência a dois namespaces diferentes quando os aplicamos, portanto, o autor recomenda que seja melhor escrevê-los em um namespace.
A próxima tarefa é transformar esses dois arquivos cs nos arquivos DLL que precisamos. O método é este: Em um sistema operacional com Microsoft.NET Framework instalado, podemos encontrar o diretório Microsoft.NET no diretório onde o Windows está localizado. Um compilador C# é fornecido neste diretório. Execute CSC.EXE: csc /target:library /out:MyDLL.DLL MySwap.cs MyMaxCD.cs Após a conclusão, você pode encontrar o arquivo MyDLL.DLL que acabamos de gerar neste diretório. A opção do compilador /target:library informa ao compilador para gerar arquivos DLL em vez de arquivos EXE. A opção do compilador /out seguida pelo nome do arquivo especifica o nome do arquivo DLL. Se /out não for seguido por um nome de arquivo, o compilador usará o primeiro arquivo (MySwap.cs) como o nome do arquivo DLL. O arquivo gerado é o arquivo MySwap.DLL.
OK! Nossa tarefa de criar o arquivo de biblioteca de link dinâmico está concluída. Agora é hora de aproveitarmos os frutos do nosso trabalho. A seguir apresentarei como usar o arquivo de biblioteca de link dinâmico que criamos. 4. Usando DLL Simplesmente escrevemos um pequeno programa para testar se os dois métodos que acabamos de escrever estão corretos. Ok, siga-me:
MeuCliente.cs
usando o sistema;
using MyMethods; //Aqui nos referimos ao namespace que acabamos de definir. Se escrevermos os dois arquivos agora em dois namespaces diferentes.
classe MeuCliente
{
public static void Principal(string[] args)
{
se (args.Comprimento! = 2)
{
Console.WriteLine("Uso: MeuCliente <num1> <num2>");
retornar;
}
longo num1 = longo.Parse(args[0]);
longo num2 = longo.Parse(args[1]);
SwapClass.Swap(ref num1,ref num2);
// Observe que a diretiva using no início do arquivo permite que você use nomes de classes não qualificados para referenciar métodos DLL em tempo de compilação
Console.WriteLine("O resultado da troca é num1 = {0} e num2 ={1}",num1, num2);
maxcd longo = MaxCDClass.MaxCD(num1,num2);
Console.WriteLine("O MaxCD de {0} e {1} é {2}",num1, num2, maxcd);
}
}
Para gerar o executável MyClient.exe, use a seguinte linha de comando:
csc /out:MyClient.exe /reference:MyDLL.DLL MyClient.cs
A opção do compilador /out informa ao compilador para gerar um arquivo EXE e especifica o nome do arquivo de saída (MyClient.exe). A opção do compilador /reference especifica o arquivo DLL ao qual o programa faz referência.
5. Execução
Para executar o programa, digite o nome do arquivo EXE seguido de dois números, por exemplo: MyClient 123 456
6. Saída
O resultado da troca é num1 = 456 e num2 = 123
O CD máximo de 456 e 123 é 3
7. Resumo
Os links dinâmicos têm as seguintes vantagens:
1. Economize memória e reduza as operações de troca. Muitos processos podem usar uma DLL simultaneamente, compartilhando uma cópia da DLL na memória. Em vez disso, para cada aplicativo criado com uma biblioteca vinculada estaticamente, o Windows deve carregar uma cópia do código da biblioteca na memória.
2. Economize espaço em disco. Muitos aplicativos podem compartilhar uma cópia da DLL no disco. Em vez disso, cada aplicativo criado com uma biblioteca vinculada estaticamente tem o código da biblioteca vinculado à sua imagem executável como uma cópia separada. 3. É mais fácil atualizar para DLL. Quando as funções em uma DLL são alteradas, os aplicativos que as utilizam não precisam ser recompilados ou vinculados novamente, desde que os parâmetros da função e os valores de retorno não sejam alterados. Por outro lado, o código-objeto vinculado estaticamente exige que o aplicativo seja vinculado novamente quando as funções mudam.
4. Fornece suporte pós-venda. Por exemplo, uma DLL de driver de monitor pode ser modificada para suportar monitores que não estão disponíveis quando o aplicativo é enviado originalmente.
5. Suporte a programas multilíngues. Programas escritos em diferentes linguagens de programação podem chamar a mesma função DLL, desde que o programa siga a convenção de chamada da função. Os programas e funções DLL devem ser compatíveis na ordem em que a função espera que seus argumentos sejam colocados na pilha, se a função ou o aplicativo é responsável por limpar a pilha e se algum argumento é passado nos registros.
6. Fornece um mecanismo para estender as classes da biblioteca MFC. Você pode derivar classes de classes MFC existentes e colocá-las em DLLs de extensão MFC para uso por aplicativos MFC.
7. Facilite a criação de versões internacionais. Ao colocar recursos em uma DLL, fica muito mais fácil criar versões internacionais da sua aplicação. Você pode colocar as strings para cada versão de idioma do seu aplicativo em um arquivo de recursos DLL separado e fazer com que versões de idiomas diferentes carreguem os recursos apropriados.
Uma desvantagem potencial do uso de uma DLL é que o aplicativo não é independente e depende da presença de um módulo DLL separado;