Gewusst wie: Erstellen und Verwenden von Assemblys über die Befehlszeile (C# und Visual Basic)

Artikel
06/10/2015

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