Gewusst wie: Erstellen und Verwenden von Assemblys über die Befehlszeile (C# und Visual Basic)
Eine Assembly oder Dynamic Linking Library (DLL) wird zur Laufzeit mit dem Programm verknüpft. Um die Erstellung und Verwendung einer DLL zu veranschaulichen, wird folgendes Szenario verwendet:
MathLibrary.DLL: Die Bibliotheksdatei, die die zur Laufzeit aufzurufenden Methoden enthält. In diesem Beispiel enthält die DLL zwei Methoden: Add und Multiply.
Add: Die Quelldatei, die die Add-Methode enthält. Sie gibt die Summe ihrer Parameter zurück. Die AddClass-Klasse, die die Add-Methode enthält, ist ein Member des UtilityMethods-Namespaces.
Mult: Der Quellcode, der die Multiply-Methode enthält. Er gibt das Produkt seiner Parameter zurück. Die MultiplyClass-Klasse, die die Multiply-Methode enthält, ist ebenfalls ein Member des UtilityMethods-Namespaces.
TestCode: Die Datei, die die Main-Methode enthält. Sie verwendet die Methoden in der DLL-Datei, um die Summe und das Produkt der Laufzeitargumente zu berechnen.
Beispiel
' 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
*/
Diese Datei enthält den Algorithmus, der die DLL-Methoden Add und Multiply verwendet. Er beginnt mit der Analyse der Argumente num1 und num2, die aus der Befehlszeile stammen. Anschließend wird die Summe berechnet, indem die Add-Methode auf die AddClass-Klasse angewendet wird, und dann das Produkt, indem die Multiply-Methode auf die MultiplyClass-Klasse angewendet wird.
Mit der using-Direktive (Imports in Visual Basic) am Anfang der Datei können Sie während der Kompilierungszeit die nicht qualifizierten Klassennamen als Verweis auf die DLL-Methoden verwenden, wie im Folgenden beschrieben:
MultiplyClass.Multiply(num1, num2)
MultiplyClass.Multiply(num1, num2);
Andernfalls müssen Sie die vollqualifizierten Namen wie folgt verwenden:
UtilityMethods.MultiplyClass.Multiply(num1, num2)
UtilityMethods.MultiplyClass.Multiply(num1, num2);
Ausführung
Um das Programm auszuführen, geben Sie den Namen der EXE-Datei, gefolgt von zwei Zahlen, folgendermaßen ein:
TestCode 1234 5678
Kompilieren des Codes
Um die Datei MathLibrary.DLL zu erstellen, kompilieren Sie die beiden Dateien Add und Mult mit folgender Befehlszeile.
vbc /target:library /out:MathLibrary.DLL Add.vb Mult.vb
csc /target:library /out:MathLibrary.DLL Add.cs Mult.cs
Mit der /target:library-Compileroption wird der Compiler angewiesen, eine DLL-Datei statt einer EXE-Datei auszugeben. Die /out-Compileroption, gefolgt von einem Dateinamen, wird zur Angabe des Namens der DLL-Datei verwendet. Andernfalls wird vom Compiler die erste Datei (Add.cs) als Name der DLL verwendet.
Zum Erstellen der ausführbaren Datei TestCode.exe verwenden Sie die folgende Befehlszeile:
vbc /out:TestCode.exe /reference:MathLibrary.DLL TestCode.vb
csc /out:TestCode.exe /reference:MathLibrary.DLL TestCode.cs
Mit der /out-Compileroption wird der Compiler angewiesen, eine EXE-Datei auszugeben, und der Name der Ausgabedatei (TestCode.exe) wird festgelegt. Diese Compileroption kann optional verwendet werden. Mit der /reference-Compileroption werden die DLL-Dateien festgelegt, die von diesem Programm verwendet werden. Weitere Informationen finden Sie unter /reference für C# bzw. unter /reference (Visual Basic) für Visual Basic.
Weitere Informationen zum Erstellen von der Befehlszeile aus finden Sie unter Erstellen über die Befehlszeile mit csc.exe und Erstellen von der Befehlszeile aus (Visual Basic).
Siehe auch
Aufgaben
Gewusst wie: Angeben einer Basisadresse für eine DLL
Referenz
Assemblys und der globale Assemblycache (C# und Visual Basic)
Konzepte
Erstellen einer Klasse zum Halten von DLL-Funktionen