Usar un ensamblado de C# desde Visual Basic

Introducción:

Desde que apareció .NET Framework, crear aplicaciones que usen librerías (ensamblados DLL) creadas con cualquiera de los lenguajes soportados ha sido una tarea fácil, entre otras cosas, porque ese es uno de los puntos fuertes de .NET Framework: usar cualquier ensamblado creado con cualquier lenguaje de esta plataforma, desde otro lenguaje que utilice el mismo "marco de trabajo".

Incluso desde la primera versión para .NET, Visual Studio ha permitido que esa "interoperabilidad" (o comunicación entre lenguajes distintos), sea fácil de realizar. Ya que permite crear soluciones o grupos de proyectos, en los que podemos usar lenguajes diferentes para cada uno de esos proyectos.

Si algunos de esos proyectos son bibliotecas de clases, las podemos usar desde cualquiera de los otros proyectos, simplemente agregando una referencia al proyecto en cuestión y después compilar y ejecutar esos proyectos sin hacer nada de especial.
Lo bueno de todo esto, es que incluso podemos hacer "depuración" entre esos proyectos escritos en lenguajes diferentes. Es decir, podemos poner puntos de interrupción y detener la ejecución en cualquiera de ellos, sin importar en que lenguaje esté escrito.

Sí, es posible que todo esto ya lo sepas... pero... mejor sigue leyendo.

Usar ensamblados de otros lenguajes en .NET Framework 2.0

O lo que es lo mismo desde Visual Studio 2005, incluso desde la versiones Express.

En Visual Studio 2005 (no en las versiones Express), el proceso a usar es el mismo que el descrito anteriormente, es decir, creamos una solución y en esa solución podemos agregar nuevos proyectos (o proyectos existentes) de cualquiera de los lenguajes soportados por Visual Studio 2005, y también podemos interoperar entre ellos.

Con las versiones Express de Visual Studio 2005 esto no es posible, es decir, no podemos crear una solución en la que tengamos mezclados proyectos escritos en lenguajes diferentes.
Sí podemos crear una solución con diferentes proyectos, y referenciar esos proyectos, hacer depuración, etc. Pero siempre en el mismo lenguaje.
Esto es lógico, ya que las versiones Express de Visual Studio 2005, en realidad son entornos de desarrollo (IDE) para un solo lenguaje. Por tanto no podemos crear con Visual Basic 2005 Express un proyecto de C#, y lo mismo ocurre al revés.

Nota:
La única versión Express que permite usar más de un lenguaje, es la versión de desarrollo Web: Visual Web Developer 2005 Express Edition, pero eso... es otro tema.
Si quieres saber cómo usar más de un lenguaje en un proyecto Web creado con esa versión, léete esto: Usar clases de VB y C# en una misma aplicación Web de Visual Studio 2005.

Antes de entrar en detalles de cómo hacer esa "comunicación" entre proyectos creados con las versiones Express de Visual Studio 2005, veamos algo que es nuevo en Visual Studio 2005 (y por tanto también aplicable a las versiones Express).

La novedad de Visual Studio 2005 es que podemos crear referencias a otros proyectos, pero no tienen porqué ser ensamblados DLL, sino que también pueden ser ejecutables o ensamblados EXE.
Es decir, podemos crear un EXE y desde otro proyecto de Visual Studio 2005 usar las clases que ese ejecutable exponga, es decir, las clases que hayamos definido como públicas, porque si no son públicas... pues "casi" no se podrán usar... bueno, el "casi" es porque si se pueden usar, al menos si son "amigas" (internal en C#, Friend en Visual Basic), pero eso es otro tema y por ahora solo es posible desde C#, (es que parece que los que preferimos Visual Basic somos ciudadanos de segunda clase, y siempre nos dejan para el final... a ver el si llega el día que eso cambia). Por ahora quédate con la "copla" de que para poder usar una clase de un ensamblado en otro proyecto, esa clase debe ser pública.

¿Por qué podemos usar ensamblados escritos en otros lenguajes?

La respuesta es bien simple.
Cuando creamos una referencia a otros proyectos, Visual Studio, en realidad lo que hace es usar el ensamblado resultante y lo copia en la carpeta en la que está el ejecutable (o la librería) que lo tiene referenciado.
Como ves, no hay magia, salvo por la posibilidad de estar con esos proyectos en una misma instancia de Visual Studio en lugar de tener varios IDE abiertos, uno para cada lenguaje.

Por supuesto, todo esto solo es posible con las versiones "normales" de Visual Studio, ya sean de la versión 2002, 2003 o 2005. En realidad de las versiones anteriores a Visual Studio 2005 no existían versiones independientes para cada uno de los lenguajes.
Cuando digo "normales", a lo que me refiero es a que no son las versiones Express.

Usar ensamblados de otros lenguajes con las versiones Express

Como te he comentado en el punto anterior, la "gracia" de usar ensamblados escritos con cualquier lenguaje de .NET desde un proyecto, ya sea escrito en ese mismo lenguaje o en otro diferente, es porque en realidad tenemos una referencia al ensamblado que se genera (o compila).

Sabiendo esto, lo que podemos hacer es, por ejemplo, crear una librería (o biblioteca) de clases con C# y usarla desde Visual Basic.
Esto nos da la "libertad" de poder usar las versiones Express para crear esa "relación" entre clases escritas en un lenguaje que usamos desde otro.

La ventaja "aparente" de usar la versión "normal" de Visual Studio es que en cuanto hacemos un cambio en la clase que tenemos referenciada como proyecto, (al menos si usamos Visual Basic), es que en ese mismo momento nos estamos enterando de que dicha clase ha cambiado.
Pero no te preocupes, ya que si esa librería (o ejecutable) que tenemos referenciada está escrita en otro lenguaje diferente (o estás trabajando con C#), para que esos cambios se "vean" debes compilar el ensamblado al que haces referencia, sino, no se enterará de que ha habido cambios.

¡Y eso mismo es lo que ocurre con las versiones Express!

Sí, aunque tengas por un lado el IDE de Visual C# 2005 Express y por otro el de Visual Basic 2005 Express, cuando se compila el ensamblado al que has hecho la referencia, el otro IDE se da cuenta de ese cambio y te avisa de que algo ha cambiado.

¿Cómo lo hace? Ni idea, no me he puesto a "investigar", pero es así. Y eso que en realidad a lo que estás haciendo "referencia" es al ensamblado ya compilado.
Por tanto, puedes usar esa característica incluso desde las versiones Express, por supuesto con el "valor añadido" de que en cuanto haces cambios y compilas, desde el otro IDE se da cuenta de esos cambios y te avisa, al menos si es que esos cambios que has hecho afectan al código usado.

Veamos los pasos que debes seguir para probar esto que te acabo de contar.

Crear un proyecto de C# y usarlo desde Visual Basic (con las versiones Express)

Nota:
Para que puedas probar esto que te voy a contar, necesitas tener tanto la versión Express de Visual C# 2005 como la de Visual Basic 2005.

Lo que haremos para probar todo esto que te he comentado será lo siguiente:

1. Primero crearemos un proyecto del tipo Biblioteca de clases usando Visual C# 2005 Express en la que definiremos una clase pública con dos métodos estáticos (compartidos).

2. A continuación crearemos una aplicación de Windows con Visual Basic 2005 Express desde la que crearemos una referencia a la DLL creada con Visual C#, y usaremos los dos métodos.

3. Después modificaremos la librería de C# para añadir una propiedad de solo lectura, la que usaremos desde el proyecto de Visual Basic.
   Con esto comprobaremos que después de compilar la DLL desde VB ya podremos usar esa propiedad.

4. A continuación le cambiaremos el nombre a esa propiedad de solo lectura, y veremos cómo al compilar nuevamente la librería, en el proyecto de Visual Basic nos avisa de que hay un error, (ya que la propiedad de antes ha cambiado de nombre y no existe).

5. Después crearemos otro proyecto de C#, (el cual lo agregaremos a la misma solución que ya tenemos de C#), en este caso una aplicación de consola, en la que definiremos los mismos métodos que en la clase de la librería.

6. En el proyecto de Visual Basic añadiremos también una referencia a ese nuevo proyecto de C#, para que compruebes que se pueden usar las clases definidas en un ejecutable.

Vayamos siguiendo esos pasos para que puedas ver todo lo comentado de forma más clara (espero).

1- Crear un nuevo proyecto con Visual C# 2005 Express

Abre el Visual C# 2005 Express, y crea un nuevo proyecto del tipo Biblioteca de clases, usa el nombre: PruebaLibreria, (es importante que le dejes ese mismo nombre, ya que lo usaremos desde la aplicación de Visual Basic).

Cámbiale el nombre del fichero de la clase que añade automáticamente (que será Class1) a PruebaCS, seguramente te preguntará si quieres cambiar también el nombre a la clase, dile que sí.

Y añade el siguiente código:

using System;
using System.Reflection;
using System.Diagnostics;

namespace PruebaLibreria
{
    public class PruebaCS
    {
        // Dos métodos estáticos para mostrar el saludo
        public static string Saludo()
        {
            return "Saludo desde la librería de C#";
        }

        public static string Saludo(string nombre)
        {
            return "Hola " + nombre + ", desde la librería de C#";
        }
    }
}

Compila el proyecto por medio de la opción Generar solución del menú Generar (también puedes pulsar la tecla F6).

2- Crear un nuevo proyecto con Visual Basic 2005 Express

Abre el Visual Basic 2005 Express y crea un nuevo proyecto del tipo Aplicación para Windows, el nombre no es importante, pero yo le he dado el nombre usarLibreriaDeCS.

Pulsa en My Project (doble click) que estará en la ventana de soluciones, esto te mostrará las fichas de configuración de la aplicación, selecciona Referencias y pulsa en el botón Agregar, esto te mostrará el cuadro de diálogo de agregar referencia, selecciona la ficha Examinar, y busca el directorio en el que está la DLL que has creado con C#.
Tal como ves en la figura 1, normalmente, con Visual C# 2005 Express, esa DLL estará en la carpeta Release.
Pulsa en el botón Aceptar y tendrás la referencia a la librería creada con C#.

Figura 1. Agregar referencia a la DLL creada con C#

En el formulario que tienes en el proyecto de Visual Basic, añade dos botones, dos etiquetas y una caja de textos, tal como ves en la figura 2.

Figura 2. El formulario de la aplicación de Visual Basic

Los controles tienen los nombres predeterminados, salvo la etiqueta de abajo que tiene el nombre LabelSaludo.

Añade el siguiente código al formulario:

Private Sub Button1_Click(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles Button1.Click
    LabelSaludo.Text = PruebaLibreria.PruebaCS.Saludo()
End Sub

Private Sub Button2_Click(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles Button2.Click
    LabelSaludo.Text = PruebaLibreria.PruebaCS.Saludo(Me.TextBox1.Text)
End Sub

Como puedes comprobar, estamos usando los dos métodos que hemos definido en la clase de la librería de C#, que al estar compartidas (declaradas con static), podemos usarlas sin necesidad de crear una nueva instancia de esa clase, ya que solo es necesario usar el nombre de la clase, y en este caso, también usamos el espacio de nombres en el que está dicha clase. Si no quieres indicar el espacio de nombres, tendrás que añadir una importación de esta forma:

Imports PruebaLibreria

3- Añadir una propiedad a la clase de la librería de C#

Ahora vamos a añadir una propiedad de solo lectura al proyecto de C#, así comprobaremos que una vez que compilemos la DLL ya podremos usar esa nueva propiedad en el proyecto de Visual Basic, sin necesidad de refrescar las referencias.

Añade el siguiente código a la clase del proyecto de C#:

// Propiedad de solo lectura para mostrar la versión
// del ensamblado (la numeración de Windows)
public static string Version
{
    get
    {
        Assembly ensamblado = Assembly.GetExecutingAssembly();
        FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(ensamblado.Location);
        return fvi.FileVersion;
    }
}

Para que ese código compile bien, debes añadir también estas dos importaciones:

using System.Reflection;
using System.Diagnostics;

Compila el proyecto para que podamos usar esta propiedad desde Visual Basic.

4- Usar la nueva propiedad desde el proyecto de Visual Basic

Pásate al proyecto de Visual Basic, y crea el método para el evento Load del formulario (en modo diseño haz doble click en una parte vacía del formulario), al que debes añadirle el siguiente código:

Private Sub Form1_Load(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles MyBase.Load
    LabelSaludo.Text = "Versión del ensamblado de C#: " & PruebaLibreria.PruebaCS.Version
End Sub

Cuando escribas el punto después del nombre de la clase, te darás cuenta de que aparece la propiedad Version, además del método Saludo.

Sí, eso es lo que debe ocurrir, pero como habrás comprobado, no has tenido que hacer nada especial, es decir, consigues el mismo "efecto" que si estuvieras usando el Visual Studio "normal", pero con la ventaja de que estás usando las versiones gratuitas de Visual Basic y Visual C# 2005.

El resto de pruebas ya no te las voy a indicar tan "paso a paso", (o casi), ya que sabrás cómo hacerlas.

5- Cambiar el nombre de la propiedad Version

Recuerda que ahora debes cambiarle el nombre a la propiedad que acabamos de crear en el proyecto de C#, para que en lugar de llamarse Version, se llame FileVersion.
Cuando compiles el proyecto de C#, te pasas al de Visual Basic y verás como el IDE de este último te avisa de que la propiedad Version no existe, y tendrás que cambiarle el nombre a FileVersion para poder ejecutar el proyecto.

6- Añadir un nuevo proyecto de C#

Lo siguiente será crear un nuevo proyecto en C#, puedes hacerlo agregando un nuevo proyecto a la solución que tienes ahora. Ese proyecto será del tipo Aplicación de consola.

Si en el menú Archivo no aparece la opción Agregar, pulsa con el botón derecho (secundario) en la solución de C#, y ahí si que aparecerá esa opción, de la que tendrás que seleccionar Nuevo proyecto.

Al añadir ese nuevo proyecto, tendrás una clase llamada Program, que contiene el método Main.
Pero esa clase NO es pública, en realidad la clase está definida sin indicar si es pública o privada, pero en C#, el ámbito predeterminado de una clase es private, a diferencia de Visual Basic que es Public, (aquí tienes los ámbitos predeterminados de VB y C#).
Por tanto, debes añadirle el modificador public a la clase Program para que puedas usar los métodos y la propiedad que usaremos.

Esos métodos y la propiedad serán los mismos que hemos usado antes en la otra clase, por tanto solo tienes que copiarlos y pegarlos en el nuevo proyecto, por ejemplo, después del método Main. No te muestro el código ya que es exactamente el mismo, y recuerda agregar las dos importaciones (using) para poder usar las clases de la propiedad FileVersion.

En ese método Main puedes usar esas propiedades, con idea de que compruebes que esa aplicación de consola se comporta como cualquier aplicación de consola, además de proporcionar los miembros públicos que tenga. Fíjate después, (cuando añadas la referencia desde Visual Basic), que el método Main no se podrá usar desde fuera, ya que no se ha definido como public.

static void Main(string[] args)
{
    // Este es un ejecutable que exporta funciones
    Console.WriteLine("Este es el saludo:");
    Console.WriteLine(Saludo());
    Console.WriteLine();
    Console.WriteLine("Esta es la versión: {0}", FileVersion);

    Console.WriteLine("\nPulsa Intro para terminar");
    Console.ReadLine();
}

Acuérdate de generar nuevamente la solución.
Aunque antes deberías cambiar el valor de la versión de ambos proyectos, para que veas claramente en la siguiente prueba que estás usando una u otra versión. La versión que debes modificar es la que está junto a Versión de archivo, no la primera que indica Versión de ensamblado, ya que el código usado en la propiedad FileVersion usa la versión del fichero, (que es la que muestra Windows en las propiedades), no la versión del ensamblado, que es la que usa el .NET para sus cosas.

7- Usar el nuevo proyecto desde Visual Basic

Ahora, pásate de nuevo al IDE de Visual Basic y añade una referencia al nuevo proyecto de C#, en este caso debes seleccionar el .EXE que estará en la carpeta correspondiente al nuevo proyecto.

Para usar las dos "referencias", vamos a añadir un CheckBox al formulario, de forma que según esté seleccionado o no, se use una u otra "librería".

El código que debe tener ahora el formulario de Visual Basic es el siguiente:

Private Sub Button1_Click(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles Button1.Click
    If CheckBox1.Checked Then
        LabelSaludo.Text = pruebaLibreriaConsola.Program.Saludo()
    Else
        LabelSaludo.Text = PruebaLibreria.PruebaCS.Saludo()
    End If
End Sub

Private Sub Button2_Click(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles Button2.Click
    If CheckBox1.Checked Then
        LabelSaludo.Text = pruebaLibreriaConsola.Program.Saludo(Me.TextBox1.Text)
    Else
        LabelSaludo.Text = PruebaLibreria.PruebaCS.Saludo(Me.TextBox1.Text)
    End If
End Sub

Private Sub Form1_Load(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles MyBase.Load
    If CheckBox1.Checked Then
        LabelSaludo.Text = "Versión del ensamblado de C#: " & _
            pruebaLibreriaConsola.Program.FileVersion
    Else
        LabelSaludo.Text = "Versión del ensamblado de C#: " & _
            PruebaLibreria.PruebaCS.FileVersion
    End If
End Sub

Private Sub CheckBox1_CheckedChanged(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) _
                Handles CheckBox1.CheckedChanged
    If CheckBox1.Checked Then
        LabelSaludo.Text = "Versión del ensamblado de C#: " & _
            pruebaLibreriaConsola.Program.FileVersion
    Else
        LabelSaludo.Text = "Versión del ensamblado de C#: " & _
            PruebaLibreria.PruebaCS.FileVersion
    End If
End Sub

Como puedes comprobar, cada vez que cambies la marca del CheckBox, también se mostrará la versión de una u otra "librería". Así sabrás cual estás usando, que en este código será las definiciones de la DLL cuando NO está seleccionado o la del EXE cuando esté con la marca (Checked).

Resumiendo que es gerundio

Pues esto es todo, espero que a pesar de tanto "lío", te haya quedado claro los conceptos que te he querido explicar y que son:

• Cómo usar código escrito en un lenguaje desde un proyecto escrito en otro lenguaje de .NET.

• Que en Visual Studio 2005 /.NET Framework 2.0 se pueden crear referencias a ejecutables además de a librerías.

• Que puedes usar las versiones Express casi de la misma forma que la versión "normal" de Visual Studio.

Espero que todo esto te sea de utilidad y que te ayude a saber cómo usar unas clases de .NET desde otro proyecto, porque debes recordar que para usar esas clases no tienes porqué hacerlo desde otro proyecto de otro lenguaje de .NET, ya que también puedes hacerlo desde el mismo lenguaje, que además es aún más fácil de todo lo que te he explicado aquí.

¡Que lo interoperes bien!

Nos vemos.
Guillermo

Espacios de nombres usados en el código de este artículo:

System.Reflection
System.Diagnostics