Le processus de compilation des fichiers .cs en .dll à l'aide de la commande csc
Plusieurs fois, nous devons compiler séparément le fichier .cs en un fichier .dll. L'opération est la suivante :
Ouvrez la fenêtre de commande->entrez cmd dans la console->cd C:WINDOWSMicrosoft.NETFrameworkv1.1.4322
Allez dans le répertoire où est installé vs.net -> exécutez la commande csc csc /target:library File.cs -> générez un fichier .dll avec le nom correspondant dans le répertoire (prérequis : mettre le fichier .cs dans C: Répertoire WINDOWSMicrosoft.NETFrameworkv1.1.4322)
Il existe de nombreuses façons d'utiliser la commande csc, veuillez vous référer à ce qui suit
Traduire File.cs pour produire File.exe
csc File.cs compile File.cs pour générer File.dll
csc /target:library File.cs Compilez File.cs et créez My.exe
csc /out:My.exe File.cs Compile tous les fichiers C# du répertoire actuel à l'aide de l'optimisation et de la définition des symboles DEBUG. La sortie est File2.exe
csc /define:DEBUG /optimize /out:File2.exe *.cs Compile tous les fichiers C# du répertoire actuel pour générer une version de débogage de File2.dll. Ne pas afficher de logos ou d'avertissements
csc /target:library /out:File2.dll /warn:0 /nologo /debug *.cs Compile tous les fichiers C# du répertoire actuel dans Something.xyz (une DLL)
csc /target:library /out:Something.xyz *.cs Compile File.cs pour générer File.dll
csc /target:library File.cs est la commande la plus couramment utilisée. En fait, elle peut être simplement écrite sous la forme csc /t:library File.cs. Une autre façon de l'écrire est csc /out:mycodebehind.dll /t:library. mycodebehind.cs , vous pouvez spécifier vous-même le nom du fichier de sortie.
csc /out:mycodebehind.dll /t:library mycodebehind.cs mycodebehind2.cs, la fonction de ceci est d'installer deux fichiers cs dans un seul fichier .dll
Exemple (tiré d'Internet)
1. Bibliothèque de liens dynamiques
Qu'est-ce qu'une bibliothèque de liens dynamiques ? Les trois lettres DLL doivent vous être familières. C'est l'abréviation de Dynamic Link Library (DLL) est un fichier exécutable qui est une bibliothèque de fonctions partagée. La liaison dynamique permet à un processus d'appeler des fonctions qui ne font pas partie de son code exécutable. Le code exécutable d'une fonction se trouve dans une DLL contenant une ou plusieurs fonctions compilées, liées et stockées séparément du processus qui les utilise. Les DLL aident également au partage de données et de ressources. Plusieurs applications peuvent accéder simultanément au contenu d’une seule copie d’une DLL en mémoire.
Comme la plupart des programmeurs, vous devez avoir fréquemment utilisé des DLL. Avez-vous déjà senti que cela vous apportait de bonnes erreurs de programmation et de codage ? Aujourd'hui, je souhaite aborder un sujet avec vous : comment créer et appeler une DLL (bibliothèque de liens dynamiques) en C#. En fait, dans un sens large, la DLL permet. moi d'organiser et d'écrire nos applications de manière plus flexible. En tant que concepteur de logiciels, je peux obtenir un effet de réutilisation élevé du code sur cette base. Permettez-moi de vous présenter comment créer et appeler une DLL en C#.
2. Travaux de préparation
Nous devons donner une brève introduction à ce que nous allons faire ensuite. Dans cet article, nous utiliserons le langage C# pour créer une bibliothèque de liens dynamiques nommée MyDLL.DLL. Dans ce fichier de bibliothèque de liens dynamiques, nous fournirons deux fonctions. Échangez les valeurs de deux paramètres. Une autre fonction consiste à trouver le plus grand diviseur commun de deux paramètres. Créez ensuite une application pour utiliser cette DLL. Exécutez et affichez les résultats.
3. Créer une DLL
Créons les trois fichiers de code C# suivants :
1. MonSwap.cs
}
utiliser le système ;
espace de noms Mes méthodes
{
classe publique SwapClass
{
public static bool Swap (réf long i, réf long j)
{
je = je+j;
j = je;
je = je;
renvoie vrai ;
}
}
}
2. MonMaxCD.cs
utiliser le système ;
espace de noms Mes méthodes
{
classe publique MaxCDClass
{
public statique long MaxCD (long i, long j)
{
long a,b,temp;
si(i>j)
{
une = je;
b = j;
}
autre
{
b = je;
une = j;
}
température = un % b ;
pendant que(temp!=0)
{
une = b;
b = température ;
température = un % b ;
}
retourner b ;
}
}
}
A noter que lorsque l'on crée ces deux fichiers, on peut utiliser Visual Studio.NET ou d'autres éditeurs de texte, même le Bloc-notes. Bien que ces deux fichiers ne soient pas dans le même fichier, ils appartiennent au même espace de noms, ce qui nous permettra d'utiliser facilement ces deux méthodes à l'avenir. Bien sûr, ils peuvent également appartenir à des espaces de noms différents, ce qui est tout à fait correct, mais nous n'avons besoin de référencer que deux espaces de noms différents lorsque nous les appliquons, l'auteur recommande donc de mieux les écrire sous un seul espace de noms.
La tâche suivante consiste à transformer ces deux fichiers cs en fichiers DLL dont nous avons besoin. La méthode est la suivante : Sur un système d'exploitation sur lequel Microsoft.NET Framework est installé, nous pouvons trouver le répertoire Microsoft.NET dans le répertoire où se trouve Windows. Un compilateur C# est fourni dans ce répertoire. Exécutez CSC.EXE : csc /target:library /out:MyDLL.DLL MySwap.cs MyMaxCD.cs. Une fois terminé, vous pouvez trouver le fichier MyDLL.DLL que nous venons de générer dans ce répertoire. L'option du compilateur /target:library indique au compilateur de générer des fichiers DLL au lieu de fichiers EXE. L'option du compilateur /out suivie du nom de fichier spécifie le nom du fichier DLL. Si /out n'est pas suivi d'un nom de fichier, le compilateur utilise le premier fichier (MySwap.cs) comme nom de fichier DLL. Le fichier généré est le fichier MySwap.DLL.
OK ! Notre tâche de création du fichier de bibliothèque de liens dynamiques est terminée. Il est maintenant temps pour nous de profiter des fruits de notre travail. Ci-dessous, je vais vous présenter comment utiliser le fichier de bibliothèque de liens dynamiques que nous avons créé. 4. Utiliser la DLL Nous écrivons simplement un petit programme pour tester si les deux méthodes que nous venons d'écrire sont correctes. Bon, suivez-moi :
MonClient.cs
utiliser le système ;
using MyMethods; //Nous faisons ici référence à l'espace de noms que nous venons de définir Si nous écrivons les deux fichiers tout à l'heure dans deux espaces de noms différents.
classe MonClient
{
public static void Main (string[] arguments)
{
si (args.Length != 2)
{
Console.WriteLine("Utilisation : MonClient <num1> <num2>");
retour;
}
long num1 = long.Parse(args[0]);
long num2 = long.Parse(args[1]);
SwapClass.Swap (réf num1, réf num2);
// Notez que la directive using au début du fichier vous permet d'utiliser des noms de classe non qualifiés pour référencer les méthodes DLL au moment de la compilation
Console.WriteLine("Le résultat du swap est num1 = {0} et num2 ={1}",num1, num2);
long maxcd = MaxCDClass.MaxCD(num1,num2);
Console.WriteLine("Le MaxCD de {0} et {1} est {2}",num1, num2, maxcd);
}
}
Pour générer l'exécutable MyClient.exe, utilisez la ligne de commande suivante :
csc /out:MonClient.exe /référence:MaDLL.DLL MonClient.cs
L'option du compilateur /out indique au compilateur de générer un fichier EXE et spécifie le nom du fichier de sortie (MyClient.exe). L'option du compilateur /reference spécifie le fichier DLL auquel le programme fait référence.
5. Exécution
Pour exécuter le programme, saisissez le nom du fichier EXE suivi de deux chiffres, par exemple : MonClient 123 456
6. Sortie
Le résultat du swap est num1 = 456 et num2 = 123
Le CD Max de 456 et 123 est de 3
7. Résumé
Les liens dynamiques présentent les avantages suivants :
1. Économisez de la mémoire et réduisez les opérations d'échange. De nombreux processus peuvent utiliser une DLL simultanément, partageant une copie de la DLL en mémoire. Au lieu de cela, pour chaque application créée avec une bibliothèque liée statiquement, Windows doit charger une copie du code de la bibliothèque en mémoire.
2. Économisez de l'espace disque. De nombreuses applications peuvent partager une copie de la DLL sur le disque. Au lieu de cela, chaque application créée avec une bibliothèque liée statiquement a le code de la bibliothèque lié à son image exécutable en tant que copie distincte. 3. Il est plus facile de passer à la DLL. Lorsque les fonctions d'une DLL changent, les applications qui les utilisent n'ont pas besoin d'être recompilées ou liées tant que les paramètres et les valeurs de retour de la fonction ne changent pas. En revanche, le code objet lié statiquement nécessite que l'application soit à nouveau liée lorsque les fonctions changent.
4. Fournir un support après-vente. Par exemple, une DLL de pilote de moniteur peut être modifiée pour prendre en charge les moniteurs qui ne sont pas disponibles lors de la livraison initiale de l'application.
5. Prend en charge les programmes multilingues. Les programmes écrits dans différents langages de programmation peuvent appeler la même fonction DLL tant que le programme respecte la convention d'appel de la fonction. Les programmes et les fonctions DLL doivent être compatibles dans l'ordre dans lequel la fonction s'attend à ce que ses arguments soient poussés sur la pile, si la fonction ou l'application est responsable de l'effacement de la pile et si des arguments sont passés dans les registres.
6. Fournit un mécanisme pour étendre les classes de bibliothèque MFC. Vous pouvez dériver des classes à partir de classes MFC existantes et les placer dans des DLL d’extension MFC à utiliser par les applications MFC.
7. Facilitez la création de versions internationales. En plaçant des ressources dans une DLL, il devient beaucoup plus facile de créer des versions internationales de votre application. Vous pouvez placer les chaînes de chaque version linguistique de votre application dans un fichier de ressources DLL distinct et demander à différentes versions linguistiques de charger les ressources appropriées.
L’un des inconvénients potentiels de l’utilisation d’une DLL est que l’application n’est pas autonome ; elle dépend de la présence d’un module DLL distinct.