El proceso de compilar archivos .cs en .dll usando el comando csc
Muchas veces, necesitamos compilar por separado el archivo .cs en un archivo .dll. La operación es la siguiente:
Abra la ventana de comandos->ingrese cmd en la consola->cd C:WINDOWSMicrosoft.NETFrameworkv1.1.4322
Vaya al directorio donde está instalado vs.net -> ejecute el comando csc csc /target:library File.cs -> genere un archivo .dll con el nombre correspondiente en el directorio (requisito previo: coloque el archivo .cs en C: directorio WINDOWSMicrosoft.NETFrameworkv1.1.4322)
Hay muchas formas de utilizar el comando csc; consulte lo siguiente
Traducir File.cs para producir File.exe
csc File.cs compila File.cs para generar File.dll
csc /target:library File.cs Compile File.cs y cree My.exe
csc /out:My.exe File.cs Compila todos los archivos C# en el directorio actual usando optimización y definiendo símbolos DEBUG. La salida es File2.exe
csc /define:DEBUG /optimize /out:File2.exe *.cs Compila todos los archivos C# en el directorio actual para generar una versión de depuración de File2.dll. No mostrar ningún logotipo o advertencia.
csc /target:library /out:File2.dll /warn:0 /nologo /debug *.cs Compile todos los archivos C# en el directorio actual en Something.xyz (una DLL)
csc /target:library /out:Something.xyz *.cs Compile File.cs para generar File.dll
csc /target:library File.cs es el comando más utilizado. De hecho, se puede escribir simplemente como csc /t:library File.cs. Otra forma de escribirlo es csc /out:mycodebehind.dll /t:library. mycodebehind.cs, puede especificar el nombre del archivo de salida usted mismo.
csc /out:mycodebehind.dll /t:library mycodebehind.cs mycodebehind2.cs, la función de esto es instalar dos archivos cs en un archivo .dll
Ejemplo (tomado de Internet)
1. Biblioteca de enlaces dinámicos
¿Qué es una biblioteca de enlaces dinámicos? Las tres letras DLL deben resultarle familiares. Es la abreviatura de Biblioteca de vínculos dinámicos. Una biblioteca de vínculos dinámicos (DLL) es un archivo ejecutable que es una biblioteca de funciones compartidas. Los enlaces dinámicos proporcionan una forma para que un proceso llame a funciones que no forman parte de su código ejecutable. El código ejecutable de una función se encuentra en una DLL que contiene una o más funciones que han sido compiladas, vinculadas y almacenadas por separado del proceso que las utiliza. Las DLL también ayudan a compartir datos y recursos. Varias aplicaciones pueden acceder simultáneamente al contenido de una única copia de una DLL en la memoria.
Como la mayoría de los programadores, debes haber utilizado archivos DLL con frecuencia. ¿Alguna vez has sentido que te trae buenos errores en programación y codificación? Hoy quiero discutir un tema contigo: cómo crear y llamar a DLL (biblioteca de enlaces dinámicos) en C#. De hecho, en un sentido amplio, DLL lo permite. Me permite organizar y escribir nuestras aplicaciones de manera más flexible. Como diseñador de software, puedo lograr un alto efecto de reutilización de código basado en ello. Permítanme presentarles cómo crear y llamar a DLL en C#.
2. Trabajo de preparación
Necesitamos dar una breve introducción a lo que vamos a hacer a continuación. En este artículo usaremos el lenguaje C# para crear una biblioteca de enlaces dinámicos llamada MyDLL.DLL. En este archivo de biblioteca de enlaces dinámicos proporcionaremos dos funciones. Intercambiar los valores de dos parámetros. Otra función es encontrar el máximo común divisor de dos parámetros. Luego cree una aplicación para usar esta DLL. Ejecute y genere los resultados.
3. Crear DLL
Creemos los siguientes tres archivos de código C#:
1. MySwap.cs
}
usando Sistema;
espacio de nombres MisMétodos
{
clase pública SwapClass
{
Intercambio de bool estático público (ref long i,ref long j)
{
yo = yo+j;
j = ij;
yo = ij;
devolver verdadero;
}
}
}
2. MyMaxCD.cs
usando Sistema;
espacio de nombres MisMétodos
{
clase pública MaxCDClass
{
público estático largo MaxCD (largo i, largo j)
{
largo a,b,temperatura;
si(i>j)
{
a = yo;
b = j;
}
demás
{
segundo = yo;
a = j;
}
temperatura = a % b;
mientras(temp!=0)
{
a = b;
b = temperatura;
temperatura = a % b;
}
volver b;
}
}
}
Cabe destacar que cuando creamos estos dos archivos, podemos utilizar Visual Studio.NET u otros editores de texto, incluso el Bloc de notas. Aunque estos dos archivos no están en el mismo archivo, pertenecen al mismo espacio de nombres, lo que nos facilitará utilizar estos dos métodos en el futuro. Por supuesto, también pueden pertenecer a diferentes espacios de nombres, lo cual está completamente bien, pero solo necesitamos hacer referencia a dos espacios de nombres diferentes cuando los aplicamos, por lo que el autor recomienda que sea mejor escribirlos en un espacio de nombres.
La siguiente tarea es convertir estos dos archivos cs en los archivos DLL que necesitamos. El método es el siguiente: En un sistema operativo con Microsoft.NET Framework instalado, podemos encontrar el directorio Microsoft.NET en el directorio donde se encuentra Windows. Se proporciona un compilador de C# en este directorio. Ejecute CSC.EXE: csc /target:library /out:MyDLL.DLL MySwap.cs MyMaxCD.cs Una vez completado, puede encontrar el archivo MyDLL.DLL que acabamos de generar en este directorio. La opción del compilador /target:library le indica al compilador que genere archivos DLL en lugar de archivos EXE. La opción del compilador /out seguida del nombre del archivo especifica el nombre del archivo DLL. Si /out no va seguido de un nombre de archivo, el compilador utiliza el primer archivo (MySwap.cs) como nombre de archivo DLL. El archivo generado es el archivo MySwap.DLL.
¡Bien! Nuestra tarea de crear el archivo de biblioteca de enlaces dinámicos está completa. Ahora es el momento de que disfrutemos de los frutos de nuestro trabajo. A continuación, presentaré cómo utilizar el archivo de biblioteca de enlaces dinámicos que creamos. 4. Usando DLL Simplemente escribimos un pequeño programa para probar si los dos métodos que acabamos de escribir son correctos. Sígueme:
MiCliente.cs
usando Sistema;
usando MyMethods // Aquí nos referimos al espacio de nombres que acabamos de definir si escribimos los dos archivos en dos espacios de nombres diferentes.
clase MiCliente
{
público estático vacío principal (cadena [] argumentos)
{
si (args.Longitud! = 2)
{
Console.WriteLine("Uso: MiCliente <num1> <num2>");
devolver;
}
número1 largo = largo.Parse(args[0]);
número largo2 = largo.Parse(args[1]);
SwapClass.Swap(ref num1,ref num2);
// Tenga en cuenta que la directiva de uso al principio del archivo le permite usar nombres de clases no calificados para hacer referencia a métodos DLL en tiempo de compilación.
Console.WriteLine("El resultado del intercambio es num1 = {0} y num2 ={1}",num1, num2);
long maxcd = MaxCDClass.MaxCD(num1,num2);
Console.WriteLine("El MaxCD de {0} y {1} es {2}",num1, num2, maxcd);
}
}
Para generar el ejecutable MyClient.exe, utilice la siguiente línea de comando:
csc /out:MyClient.exe /referencia:MyDLL.DLL MyClient.cs
La opción del compilador /out le indica al compilador que genere un archivo EXE y especifica el nombre del archivo de salida (MyClient.exe). La opción del compilador /reference especifica el archivo DLL al que hace referencia el programa.
5. Ejecución
Para ejecutar el programa, ingrese el nombre del archivo EXE seguido de dos números, por ejemplo: MyClient 123 456
6. Salida
El resultado del intercambio es num1 = 456 y num2 = 123
El CD máximo de 456 y 123 es 3
7. Resumen
Los enlaces dinámicos tienen las siguientes ventajas:
1. Ahorre memoria y reduzca las operaciones de intercambio. Muchos procesos pueden usar una DLL simultáneamente, compartiendo una copia de la DLL en la memoria. En cambio, para cada aplicación creada con una biblioteca vinculada estáticamente, Windows debe cargar una copia del código de la biblioteca en la memoria.
2. Ahorre espacio en disco. Muchas aplicaciones pueden compartir una copia de la DLL en el disco. En cambio, cada aplicación creada con una biblioteca vinculada estáticamente tiene el código de la biblioteca vinculado a su imagen ejecutable como una copia separada. 3. Es más fácil actualizar a DLL. Cuando las funciones en una DLL cambian, las aplicaciones que las usan no necesitan volver a compilarse ni vincularse siempre que los parámetros de la función y los valores de retorno no cambien. Por el contrario, el código objeto vinculado estáticamente requiere que la aplicación se vuelva a vincular cuando cambian las funciones.
4. Proporcionar soporte posventa. Por ejemplo, una DLL de controlador de monitor se puede modificar para admitir monitores que no estaban disponibles cuando se envió originalmente la aplicación.
5. Admite programas en varios idiomas. Los programas escritos en diferentes lenguajes de programación pueden llamar a la misma función DLL siempre que el programa siga la convención de llamada de la función. Los programas y las funciones DLL deben ser compatibles en el orden en que la función espera que sus argumentos se inserten en la pila, si la función o la aplicación es responsable de limpiar la pila y si se pasan argumentos en los registros.
6. Proporciona un mecanismo para ampliar las clases de la biblioteca MFC. Puede derivar clases de clases MFC existentes y colocarlas en archivos DLL de extensión MFC para que las utilicen las aplicaciones MFC.
7. Facilite la creación de versiones internacionales. Al colocar recursos en una DLL, resulta mucho más fácil crear versiones internacionales de su aplicación. Puede colocar las cadenas para cada versión de idioma de su aplicación en un archivo de recursos DLL separado y hacer que versiones de diferentes idiomas carguen los recursos apropiados.
Una posible desventaja de utilizar una DLL es que la aplicación no es autónoma y depende de la presencia de un módulo DLL independiente.