Como criar e usar assemblies usando a linha de comando (C# e Visual Basic)

Artigo
06/10/2015

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. Ele 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 é 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 os argumentos inseridos a partir da linha de comando de análise 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 os nomes totalmente qualificados, da seguinte maneira:

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, da seguinte maneira:

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 gerar 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 gerar a saída de um arquivo EXE e especifica o nome do arquivo de saída (TestCode.exe). Essa 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 Compilação pela linha de comando com csc.exe e Compilando a partir da linha de comando (Visual Basic).