Partilhar via


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

Guia de Programação C#

Assemblies e o Cache de Assembly Global (C# e Visual Basic)

Criando uma classe para manter as funções DLL

Depuração de projetos DLL

Outros recursos

Guia de programação Visual Basic