Comment : créer et utiliser des assemblys à l’aide de la ligne de commande
Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez aussi afficher la version anglaise dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte.
Traduction
Anglais

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

 

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.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);

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

UtilityMethods.MultiplyClass.Multiply(num1, num2);

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.

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 :

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 Command-line Building With csc.exe et Génération à partir de la ligne de commande (Visual Basic).

Afficher:
© 2016 Microsoft