Como: Criar e usar Assemblies usando a linha de comando (C# e Visual Basic)
Um assembly, ou uma biblioteca de vínculo dinâmica (DLL) está vinculada ao seu programa em tempo de execução. Para demonstrar a criação e uso de uma DLL, considere o seguinte cenário:
MathLibrary.DLL: O arquivo de biblioteca que contém os métodos sejam chamados em tempo de execução. Neste exemplo, a DLL contém dois métodos, Add e Multiply.
Add: O arquivo de origem que contém o método Add. Ela retorna a soma de seus parâmetros. A classe AddClass que contém o método Add é um membro do namespace UtilityMethods.
Mult: O código-fonte que contém o método Multiply. Ele retorna o produto de seus parâmetros. A classe MultiplyClass que contém o método Multiply é também um membro do namespace UtilityMethods.
TestCode: O arquivo que contém o Main método. Ele usa os métodos no arquivo DLL para calcular a soma e o produto dos argumentos de tempo de execução.
Exemplo
' File: Add.vb
Namespace UtilityMethods
Public Class AddClass
Public Shared Function Add(ByVal i As Long, ByVal j As Long) As Long
Return i + j
End Function
End Class
End Namespace
...
' File: Mult.vb
Namespace UtilityMethods
Public Class MultiplyClass
Public Shared Function Multiply(ByVal x As Long, ByVal y As Long) As Long
Return x * y
End Function
End Class
End Namespace
...
' File: TestCode.vb
Imports UtilityMethods
Module Test
Sub Main(ByVal args As String())
System.Console.WriteLine("Calling methods from MathLibrary.DLL:")
If args.Length <> 2 Then
System.Console.WriteLine("Usage: TestCode <num1> <num2>")
Return
End If
Dim num1 As Long = Long.Parse(args(0))
Dim num2 As Long = Long.Parse(args(1))
Dim sum As Long = AddClass.Add(num1, num2)
Dim product As Long = MultiplyClass.Multiply(num1, num2)
System.Console.WriteLine("{0} + {1} = {2}", num1, num2, sum)
System.Console.WriteLine("{0} * {1} = {2}", num1, num2, product)
End Sub
End Module
' Output (assuming 1234 and 5678 are entered as command-line arguments):
' Calling methods from MathLibrary.DLL:
' 1234 + 5678 = 6912
' 1234 * 5678 = 7006652
// File: Add.cs
namespace UtilityMethods
{
public class AddClass
{
public static long Add(long i, long j)
{
return (i + j);
}
}
}
...
// File: Mult.cs
namespace UtilityMethods
{
public class MultiplyClass
{
public static long Multiply(long x, long y)
{
return (x * y);
}
}
}
...
// File: TestCode.cs
using UtilityMethods;
class TestCode
{
static void Main(string[] args)
{
System.Console.WriteLine("Calling methods from MathLibrary.DLL:");
if (args.Length != 2)
{
System.Console.WriteLine("Usage: TestCode <num1> <num2>");
return;
}
long num1 = long.Parse(args[0]);
long num2 = long.Parse(args[1]);
long sum = AddClass.Add(num1, num2);
long product = MultiplyClass.Multiply(num1, num2);
System.Console.WriteLine("{0} + {1} = {2}", num1, num2, sum);
System.Console.WriteLine("{0} * {1} = {2}", num1, num2, product);
}
}
/* Output (assuming 1234 and 5678 are entered as command-line arguments):
Calling methods from MathLibrary.DLL:
1234 + 5678 = 6912
1234 * 5678 = 7006652
*/
Este arquivo contém o algoritmo que usa os métodos DLL, Add e Multiply. Ele começa com a analisar os argumentos digitados na linha de comando, num1 e num2. E em seguida, ele calcula a soma usando o Add método na AddClass classe e o produto usando o Multiply método na MultiplyClass classe.
Observe que o using diretiva (Imports em Visual Basic) no início do arquivo permite que você use os nomes de classe não qualificado para fazer referência os métodos DLL em tempo de compilação, da seguinte maneira:
MultiplyClass.Multiply(num1, num2)
MultiplyClass.Multiply(num1, num2);
Caso contrário, você deve usar nomes totalmente qualificados, como segue:
UtilityMethods.MultiplyClass.Multiply(num1, num2)
UtilityMethods.MultiplyClass.Multiply(num1, num2);
Execução
Para executar o programa, digite o nome do arquivo EXE, seguido de dois números, como segue:
TestCode 1234 5678
Compilando o código
Para criar o arquivo MathLibrary.DLL, compilar os dois arquivos Add e Mult usando a seguinte linha de comando.
vbc /target:library /out:MathLibrary.DLL Add.vb Mult.vb
csc /target:library /out:MathLibrary.DLL Add.cs Mult.cs
O /target:library opção de compilador informa o compilador para a saída de uma DLL em vez de um arquivo EXE. O /out opção de compilador, seguida por um nome de arquivo é usada para especificar o nome do arquivo DLL. Caso contrário, o compilador usa o primeiro arquivo (Add.cs) como o nome da DLL.
Para criar o arquivo executável, TestCode.exe, use a seguinte linha de comando:
vbc /out:TestCode.exe /reference:MathLibrary.DLL TestCode.vb
csc /out:TestCode.exe /reference:MathLibrary.DLL TestCode.cs
O /out opção de compilador informa o compilador para a saída de um arquivo EXE e especifica o nome do arquivo de saída (TestCode.exe). Esta opção de compilador é opcional. O /reference opção de compilador Especifica o arquivo DLL ou arquivos que esse programa usa. Para obter mais informações, consulte /reference para C# e /reference (Visual Basic) para Visual Basic.
Para obter mais informações sobre a construção da linha de comando, consulte Comando -<>>linha criando com CSC. exe e Compilando a partir da linha de comando (Visual Basic).
Consulte também
Tarefas
Como: Especificar um endereço Base para uma DLL.
Conceitos
Assemblies e o Cache de Assembly Global (C# e Visual Basic)
Criando uma classe para manter as funções DLL