Cómo: Crear y utilizar ensamblados desde la línea de comandos (C# y Visual Basic)
Un ensamblado o una biblioteca de vínculos dinámicos (DLL) se vincula al programa en tiempo de ejecución. Para ilustrar la compilación y el uso de una DLL, considere el siguiente escenario:
MathLibrary.DLL: archivo de biblioteca que contiene los métodos que se utilizarán durante la ejecución. En este ejemplo, la DLL contiene dos métodos, Add y Multiply.
Add: archivo de código fuente que contiene el método Add. Devuelve la suma de sus parámetros. La clase AddClass, que contiene el método Add, es un miembro del espacio de nombres UtilityMethods.
Mult: archivo de código fuente que contiene el método Multiply. Devuelve el producto de sus parámetros. La clase MultiplyClass, que contiene el método Multiply, es también un miembro del espacio de nombres UtilityMethods.
TestCode: archivo que contiene el método Main. Utiliza los métodos del archivo DLL para calcular la suma y el producto de los argumentos especificados en tiempo de ejecución.
Ejemplo
' 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
*/
Este archivo contiene el algoritmo que utiliza los métodos de la DLL, Add y Multiply. Empieza analizando los argumentos especificados en la línea de comandos, num1 y num2. A continuación, calcula la suma mediante el método Add de la clase AddClass, y el producto mediante el método Multiply de la clase MultiplyClass.
Observe que la directiva using (Imports en Visual Basic) situada al principio del archivo permite utilizar los nombres de clase sin calificar para hacer referencia a los métodos de la DLL en tiempo de compilación, tal y como se indica a continuación:
MultiplyClass.Multiply(num1, num2)
MultiplyClass.Multiply(num1, num2);
De lo contrario, sería necesario usar nombres completos, como se indica a continuación:
UtilityMethods.MultiplyClass.Multiply(num1, num2)
UtilityMethods.MultiplyClass.Multiply(num1, num2);
Execution
Para ejecutar el programa, especifique el nombre del archivo EXE seguido de dos números, como se indica a continuación:
TestCode 1234 5678
Compilar el código
Para compilar el archivo MathLibrary.DLL, compile los dos archivos Add y Mult mediante la siguiente línea de comandos.
vbc /target:library /out:MathLibrary.DLL Add.vb Mult.vb
csc /target:library /out:MathLibrary.DLL Add.cs Mult.cs
La opción /target:library indica al compilador que genere un archivo DLL en vez de un archivo EXE. La opción /out del compilador seguida de un nombre de archivo se utiliza para especificar el nombre de archivo de la DLL. Si no se utiliza, el compilador usa el primer archivo (Add.cs) como nombre de la DLL.
Para compilar el archivo ejecutable, TestCode.exe, utilice la siguiente línea de comandos:
vbc /out:TestCode.exe /reference:MathLibrary.DLL TestCode.vb
csc /out:TestCode.exe /reference:MathLibrary.DLL TestCode.cs
La opción /out indica al compilador que genere un archivo EXE y especifica el nombre del archivo de salida (TestCode.exe). Esta opción del compilador no es de uso obligatorio. La opción /reference del compilador especifica el archivo o archivos DLL que utiliza el programa. Para obtener más información, vea /reference para C# y /reference (Visual Basic) para Visual Basic.
Para obtener más información sobre la compilación desde la línea de comandos, vea Compilar la línea de comandos con csc.exe y Generar desde la línea de comandos (Visual Basic).
Vea también
Tareas
Cómo: Especificar una dirección base para un archivo DLL
Conceptos
Ensamblados y caché global de ensamblados (C# y Visual Basic)
Crear una clase para contener funciones de archivos DLL