Comment : créer et utiliser des assemblys à l'aide de la ligne de commande (C# et Visual Basic)

Article
06/10/2015

Un assembly, ou une bibliothèque de liens dynamiques (DLL), est liée à votre programme au moment de l'exécution. Pour illustrer la génération et l'utilisation d'une DLL, considérez le scénario suivant :

MathLibrary.DLL : Le fichier bibliothèque qui contient les méthodes à appeler au moment de l'exécution. Dans cet exemple, la DLL contient deux méthodes, Add et Multiply.
Add : Le fichier source qui contient la méthode Add. Il retourne la somme de ses paramètres. La classe AddClass qui contient la méthode Add est membre de l'espace de noms UtilityMethods.
Mult : Le code source qui contient la méthode Multiply. Il retourne le produit de ses paramètres. La classe MultiplyClass qui contient la méthode Multiply est également membre de l'espace de noms UtilityMethods.
TestCode : Le fichier qui contient la méthode Main. Il utilise les méthodes du fichier DLL pour calculer la somme et le produit des arguments d'exécution.

Exemple

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

Ce fichier contient l'algorithme qui utilise les méthodes de la DLL, Add et Multiply. Il commence par analyser les arguments entrés à partir de la ligne de commande, num1 et num2. Il calcule ensuite la somme en utilisant la méthode Add sur la classe AddClass, et le produit en utilisant la méthode Multiply sur la classe MultiplyClass.

Notez que la directive using (Imports en Visual Basic) placée au début du fichier vous permet d'utiliser comme suit les noms de classes non qualifiés pour référencer les méthodes de la DLL au moment de la compilation :

MultiplyClass.Multiply(num1, num2)

MultiplyClass.Multiply(num1, num2);

Sinon, vous devez utiliser les noms qualifiés complets, de la manière suivante :

UtilityMethods.MultiplyClass.Multiply(num1, num2)

UtilityMethods.MultiplyClass.Multiply(num1, num2);

Exécution

Pour exécuter le programme, entrez le nom du fichier EXE, suivi de deux nombres, par exemple :

TestCode 1234 5678

Compilation du code

Pour générer le fichier MathLibrary.DLL, compilez les deux fichiers Add et Mult à l'aide de la ligne de commande suivante.

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

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

L'option du compilateur /target:library indique au compilateur de générer une DLL à la place d'un fichier EXE. L'option du compilateur /out suivie d'un nom de fichier est utilisée pour spécifier le nom du fichier DLL. Sinon, le compilateur utilise le premier fichier (Add.cs) comme nom du fichier DLL.

Pour générer le fichier exécutable, TestCode.exe, utilisez la ligne de commande suivante :

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

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

L'option du compilateur /out indique au compilateur de générer en sortie un fichier EXE et spécifie le nom du fichier de sortie (TestCode.exe). Cette option du compilateur est facultative. L'option /reference du compilateur spécifie les fichiers DLL que ce programme utilise. Pour plus d'informations, consultez /reference pour C# et /reference (Visual Basic) pour Visual Basic.

Pour plus d'informations sur la génération à partir de la ligne de commande, consultez Génération à partir de la ligne de commande avec csc.exe et Génération à partir de la ligne de commande (Visual Basic).