Der Prozess des Kompilierens von CS-Dateien in DLL mithilfe des Befehls csc
Oftmals müssen wir die CS-Datei separat in eine DLL-Datei kompilieren. Der Vorgang ist wie folgt:
Öffnen Sie das Befehlsfenster -> geben Sie cmd in die Konsole ein -> cd C:WINDOWSMicrosoft.NETFrameworkv1.1.4322
Gehen Sie in das Verzeichnis, in dem vs.net installiert ist -> führen Sie den csc-Befehl csc /target:library File.cs aus -> generieren Sie eine .dll-Datei mit dem entsprechenden Namen im Verzeichnis (Voraussetzung: legen Sie die .cs-Datei in C: ab). (Verzeichnis WINDOWS Microsoft.NETFrameworkv1.1.4322)
Es gibt viele Möglichkeiten, den Befehl csc zu verwenden. Weitere Informationen finden Sie im Folgenden
Übersetzen Sie File.cs, um File.exe zu erstellen
csc File.cs kompiliert File.cs, um File.dll zu generieren
csc /target:library File.cs Kompilieren Sie File.cs und erstellen Sie My.exe
csc /out:My.exe File.cs Kompiliert alle C#-Dateien im aktuellen Verzeichnis unter Verwendung von Optimierung und Definition von DEBUG-Symbolen. Die Ausgabe ist File2.exe
csc /define:DEBUG /optimize /out:File2.exe *.cs Kompiliert alle C#-Dateien im aktuellen Verzeichnis, um eine Debugversion von File2.dll zu generieren. Zeigen Sie keine Logos oder Warnhinweise an
csc /target:library /out:File2.dll /warn:0 /nologo /debug *.cs Kompilieren Sie alle C#-Dateien im aktuellen Verzeichnis in Something.xyz (eine DLL).
csc /target:library /out:Something.xyz *.cs Kompilieren Sie File.cs, um File.dll zu generieren
csc /target:library File.cs ist der am häufigsten verwendete Befehl. Tatsächlich kann er einfach als csc /t:library File.cs geschrieben werden. Eine andere Möglichkeit, ihn zu schreiben, ist csc /out:mycodebehind.dll /t:library mycodebehind.cs können Sie den Namen der Ausgabedatei selbst angeben.
csc /out:mycodebehind.dll /t:library mycodebehind.cs mycodebehind2.cs, die Funktion besteht darin, zwei CS-Dateien in einer .dll-Datei zu installieren
Beispiel (aus dem Internet entnommen)
1. Dynamische Linkbibliothek
Was ist eine dynamische Linkbibliothek? Die drei Buchstaben DLL sind Ihnen bestimmt bekannt. Es ist die Abkürzung für Dynamic Link Library. Eine Dynamic Link Library (DLL) ist eine ausführbare Datei, die eine gemeinsam genutzte Funktionsbibliothek ist. Die dynamische Verknüpfung bietet einem Prozess die Möglichkeit, Funktionen aufzurufen, die nicht Teil seines ausführbaren Codes sind. Der ausführbare Code für eine Funktion befindet sich in einer DLL, die eine oder mehrere Funktionen enthält, die separat von dem Prozess, der sie verwendet, kompiliert, verknüpft und gespeichert wurden. DLLs helfen auch beim Teilen von Daten und Ressourcen. Mehrere Anwendungen können gleichzeitig auf den Inhalt einer einzelnen Kopie einer DLL im Speicher zugreifen.
Wie die meisten Programmierer müssen Sie DLLs häufig verwendet haben. Haben Sie jemals das Gefühl gehabt, dass es Ihnen gute Fehler beim Programmieren und Codieren beschert? Heute möchte ich mit Ihnen ein Thema besprechen: Wie man eine DLL (Dynamic Link Library) in C# erstellt und aufruft Dadurch kann ich als Software-Designer einen hohen Code-Wiederverwendungseffekt erzielen. Lassen Sie mich vorstellen, wie man eine DLL in C# erstellt und aufruft.
2. Vorbereitungsarbeiten
Wir müssen eine kurze Einführung in das geben, was wir als Nächstes tun werden. In diesem Artikel werden wir die Sprache C# verwenden, um eine dynamische Linkbibliothek mit dem Namen MyDLL.DLL zu erstellen Tauschen Sie die Werte zweier Parameter aus. Eine weitere Funktion besteht darin, den größten gemeinsamen Teiler zweier Parameter zu ermitteln. Erstellen Sie dann eine Anwendung zur Verwendung dieser DLL. Führen Sie die Ergebnisse aus und geben Sie sie aus.
3. DLL erstellen
Erstellen wir die folgenden drei C#-Codedateien:
1. MySwap.cs
}
Verwenden des Systems;
Namespace MyMethods
{
öffentliche Klasse SwapClass
{
public static bool Swap(ref long i,ref long j)
{
i = i+j;
j = ij;
i = ij;
return true;
}
}
}
2. MyMaxCD.cs
Verwenden des Systems;
Namespace MyMethods
{
öffentliche Klasse MaxCDClass
{
public static long MaxCD(long i, long j)
{
long a,b,temp;
if(i>j)
{
a = i;
b = j;
}
anders
{
b = ich;
a = j;
}
temp = a % b;
while(temp!=0)
{
a = b;
b = Temperatur;
temp = a % b;
}
Rückkehr b;
}
}
}
Es ist zu beachten, dass wir beim Erstellen dieser beiden Dateien Visual Studio.NET oder andere Texteditoren, sogar Notepad, verwenden können. Obwohl sich diese beiden Dateien nicht in derselben Datei befinden, gehören sie zum selben Namespace, sodass wir diese beiden Methoden in Zukunft bequem verwenden können. Natürlich können sie auch zu unterschiedlichen Namespaces gehören, was völlig in Ordnung ist, aber wir müssen bei der Anwendung nur auf zwei verschiedene Namespaces verweisen, daher empfiehlt der Autor, sie besser unter einem Namespace zu schreiben.
Die nächste Aufgabe besteht darin, diese beiden CS-Dateien in die von uns benötigten DLL-Dateien umzuwandeln. Die Methode ist folgende: Auf einem Betriebssystem mit installiertem Microsoft.NET Framework finden wir das Microsoft.NET-Verzeichnis in dem Verzeichnis, in dem sich Windows befindet. In diesem Verzeichnis wird ein C#-Compiler bereitgestellt: csc /target:library /out:MyDLL.DLL MySwap.cs MyMaxCD.cs Nach Abschluss finden Sie die Datei MyDLL.DLL, die wir gerade in diesem Verzeichnis erstellt haben. Die Compileroption /target:library weist den Compiler an, DLL-Dateien anstelle von EXE-Dateien auszugeben. Die Compileroption /out gefolgt vom Dateinamen gibt den DLL-Dateinamen an. Wenn auf /out kein Dateiname folgt, verwendet der Compiler die erste Datei (MySwap.cs) als DLL-Dateinamen. Die generierte Datei ist die Datei MySwap.DLL.
OK! Unsere Aufgabe, die dynamische Linkbibliotheksdatei zu erstellen, ist jetzt an der Zeit, die Früchte unserer Arbeit zu genießen. Im Folgenden werde ich Ihnen vorstellen, wie Sie die von uns erstellte dynamische Linkbibliotheksdatei verwenden. 4. Verwenden von DLL Wir schreiben einfach ein kleines Programm, um zu testen, ob die beiden Methoden, die wir gerade geschrieben haben, korrekt sind. Okay, folgen Sie mir:
MyClient.cs
Verwenden des Systems;
using MyMethods; //Hier beziehen wir uns auf den gerade definierten Namespace. Wenn wir die beiden Dateien gerade in zwei verschiedene Namespaces schreiben
Klasse MyClient
{
public static void Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine("Verwendung: MyClient
zurückkehren;
}
long num1 = long.Parse(args[0]);
long num2 = long.Parse(args[1]);
SwapClass.Swap(ref num1,ref num2);
// Beachten Sie, dass Sie mit der using-Direktive am Anfang der Datei unqualifizierte Klassennamen verwenden können, um zur Kompilierungszeit auf DLL-Methoden zu verweisen
Console.WriteLine("Das Ergebnis des Austauschs ist num1 = {0} und num2 ={1}",num1, num2);
long maxcd = MaxCDClass.MaxCD(num1,num2);
Console.WriteLine("Die MaxCD von {0} und {1} ist {2}",num1, num2, maxcd);
}
}
Um die ausführbare Datei MyClient.exe zu generieren, verwenden Sie die folgende Befehlszeile:
csc /out:MyClient.exe /reference:MyDLL.DLL MyClient.cs
Die Compileroption /out weist den Compiler an, eine EXE-Datei auszugeben, und gibt den Namen der Ausgabedatei an (MyClient.exe). Die Compileroption /reference gibt die DLL-Datei an, auf die das Programm verweist.
5. Ausführung
Um das Programm auszuführen, geben Sie den Namen der EXE-Datei gefolgt von zwei Zahlen ein, zum Beispiel: MyClient 123 456
6. Ausgabe
Das Ergebnis des Tauschs ist num1 = 456 und num2 = 123
Die maximale CD von 456 und 123 beträgt 3
7. Zusammenfassung
Dynamische Links haben folgende Vorteile:
1. Sparen Sie Speicher und reduzieren Sie Auslagerungsvorgänge. Viele Prozesse können eine DLL gleichzeitig verwenden und eine Kopie der DLL im Speicher gemeinsam nutzen. Stattdessen muss Windows für jede Anwendung, die mit einer statisch verknüpften Bibliothek erstellt wurde, eine Kopie des Bibliothekscodes in den Speicher laden.
2. Sparen Sie Speicherplatz. Viele Anwendungen können eine Kopie der DLL auf der Festplatte gemeinsam nutzen. Stattdessen ist bei jeder Anwendung, die mit einer statisch verknüpften Bibliothek erstellt wurde, der Bibliothekscode als separate Kopie in das ausführbare Image eingebunden. 3. Es ist einfacher, auf DLL zu aktualisieren. Wenn sich Funktionen in einer DLL ändern, müssen die Anwendungen, die sie verwenden, nicht neu kompiliert oder neu verknüpft werden, solange sich die Parameter und Rückgabewerte der Funktion nicht ändern. Im Gegensatz dazu erfordert statisch verknüpfter Objektcode eine erneute Verknüpfung der Anwendung, wenn sich Funktionen ändern.
4. Bieten Sie After-Sales-Support. Beispielsweise kann eine Monitortreiber-DLL so geändert werden, dass sie Monitore unterstützt, die bei der ursprünglichen Auslieferung der Anwendung nicht verfügbar waren.
5. Unterstützen Sie mehrsprachige Programme. In verschiedenen Programmiersprachen geschriebene Programme können dieselbe DLL-Funktion aufrufen, solange das Programm der Aufrufkonvention der Funktion folgt. Programme und DLL-Funktionen müssen in der Reihenfolge kompatibel sein, in der die Funktion erwartet, dass ihre Argumente auf den Stapel verschoben werden, unabhängig davon, ob die Funktion oder die Anwendung für das Leeren des Stapels verantwortlich ist und ob Argumente in Registern übergeben werden.
6. Bietet einen Mechanismus zum Erweitern von MFC-Bibliotheksklassen. Sie können Klassen von vorhandenen MFC-Klassen ableiten und sie in MFC-Erweiterungs-DLLs zur Verwendung durch MFC-Anwendungen platzieren.
7. Erleichtern Sie die Erstellung internationaler Versionen. Durch das Platzieren von Ressourcen in einer DLL wird es viel einfacher, internationale Versionen Ihrer Anwendung zu erstellen. Sie können die Zeichenfolgen für jede Sprachversion Ihrer Anwendung in einer separaten DLL-Ressourcendatei ablegen und verschiedene Sprachversionen die entsprechenden Ressourcen laden lassen.
Ein potenzieller Nachteil der Verwendung einer DLL besteht darin, dass die Anwendung nicht eigenständig ist; sie ist auf das Vorhandensein eines separaten DLL-Moduls angewiesen.