Procedura: creare e utilizzare assembly dalla riga di comando (C# e Visual Basic)

Articolo
06/10/2015

Un assembly, o una libreria a collegamento dinamico (DLL), viene collegato al programma in fase di esecuzione. Per dimostrare la compilazione e l'uso di una DLL, si consideri il seguente scenario:

MathLibrary.DLL: il file di libreria che contiene i metodi da chiamare in fase di esecuzione. In questo esempio, la DLL contiene due metodi, Add e Multiply.
Add: il file di origine che contiene il metodo Add. Restituisce la somma dei propri parametri. La classe AddClass che contiene il metodo Add è un membro dello spazio dei nomi UtilityMethods.
Mult: il codice sorgente che contiene il metodo Multiply. Restituisce il prodotto dei propri parametri. La classe MultiplyClass che contiene il metodo Multiply è anche un membro dello spazio dei nomi UtilityMethods.
TestCode: il file che contiene il metodo Main. Utilizza i metodi nel file DLL per calcolare la somma e il prodotto degli argomenti in fase di esecuzione.

Esempio

' 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        
*/

Questo file contiene l'algoritmo che utilizza i metodi della DLL Add e Multiply. Inizia con l'analisi degli argomenti immessi dalla riga di comando, num1 e num2. Calcola quindi la somma utilizzando il metodo Add sulla classe AddClass e il prodotto utilizzando il metodo Multiply sulla classe MultiplyClass.

Si noti che la direttiva using (Imports in Visual Basic) all'inizio del file consente di utilizzare i nomi di classe non qualificati per fare riferimento ai metodi della DLL in fase di compilazione, ad esempio:

MultiplyClass.Multiply(num1, num2)

MultiplyClass.Multiply(num1, num2);

In caso contrario, è necessario utilizzare i nomi completi, ad esempio:

UtilityMethods.MultiplyClass.Multiply(num1, num2)

UtilityMethods.MultiplyClass.Multiply(num1, num2);

Esecuzione

Per eseguire il programma, immettere il nome del file EXE seguito da due numeri, ad esempio:

TestCode 1234 5678

Compilazione del codice

Per compilare il file MathLibrary.DLL, compilare i due file Add e Mult utilizzando la seguente riga di comando:

vbc /target:library /out:MathLibrary.DLL Add.vb Mult.vb

csc /target:library /out:MathLibrary.DLL Add.cs Mult.cs

L'opzione /target:library indica al compilatore di generare un file DLL e non un file EXE. L'opzione /out seguita da un nome di file è utilizzata per specificare il nome del file DLL. In sua assenza, il compilatore utilizza il primo file (Add.cs) come nome della DLL.

Per compilare il file eseguibile, TestCode.exe, utilizzare la seguente riga di comando:

vbc /out:TestCode.exe /reference:MathLibrary.DLL TestCode.vb

csc /out:TestCode.exe /reference:MathLibrary.DLL TestCode.cs

L'opzione /out indica al compilatore di generare un file EXE e specifica il nome del file di output (TestCode.exe). Questa opzione del compilatore è facoltativa. L'opzione del compilatore /reference specifica i file DLL utilizzati dal programma. Per ulteriori informazioni, vedere /reference per C# e /reference (Visual Basic) per Visual Basic.

Per ulteriori informazioni sulla compilazione dalla riga di comando, vedere Compilazione dalla riga di comando con csc.exe e Compilazione dalla riga di comando (Visual Basic).