En el artículo anterior, vimos el uso de la clase AutomationFactory para poder crear objetos de tus ensamblados creados con el .NET Framework 4.0, y utilizarlos en Silverlight.

En el ejemplo, invocamos un método como cualquier otro y efectivamente obtenemos los resultados esperados, en este caso, la lista de unidades lógicas del equipo del usuario en donde está ejecutando la aplicación.  Pero ¿qué pasaría si necesitáramos manejar un evento que es disparado por el componente (tu ensamblado) de .NET?  En este caso la implementación debe cumplir con ciertos requisitos.

Atributo ComSourceInterfacesAttribute

Para que podamos exponer un evento en nuestro ensamblado, y que pueda ser manejado por la aplicación de Silverlight a través de automatización, debemos marcar nuestra clase que implementa el evento con el atributo ComSourceInterfacesAttribute, el cual indica una lista de interfaces que contienen los eventos a exponer en dicha clase.

Por lo tanto, en nuestro proyecto necesitamos crear una inteface que tenga la signatura del evento que deseamos exponer y disparar en la clase.  Asimismo, esta inteface debe ser de tipo IDispatch.

En el proyecto, he agregado la interface IInformacion, con la siguiente implementación:

[InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
[ComVisible(true)]
public interface IInformacion
{
    void OnGetLogicalDrivesInfo(int count);
}

El método OnGetLogicalDrivesInfo incluye como argumento un int que tendrá el conteo de cuántas unidades físicas han sido encontradas.

Una vez implementada la interface, la clase Informacion la decoramos con el atributo ComSourceInterfacesAttribute, indicando el tipo de interface que la clase expone, en este caso la interface IInformacion que creamos anteriormente:

[ComSourceInterfaces(typeof(IInformacion))]
[ComVisible(true)]
public class Informacion
{
...
}

Ahora bien, debemos implementar un delegado que empate la signatura del método incluido en la interface IINotificacion, y un evento que esté basado en dicho delegado.  Será este evento que el que dispararemos dentro de la clase Notificacion.

public delegate void GetLogicalDrivesInfoEventHandler(int count);

public event GetLogicalDrivesInfoEventHandler OnGetLogicalDrivesInfo;

Finalmente, disparamos el evento adecuadamente.  Esto lo estoy haciendo dentro del método GetLogicalDrivesInfo() una vez cargada la lista de unidades lógicas.

if (OnGetLogicalDrivesInfo != null)
{
    OnGetLogicalDrivesInfo(result.Count);
}

El ensamblado está listo para recompilarse y re-registrarse.

Clase AutomationEvent

Del lado de la aplicación de Silverlight, necesitamos manejar el evento expuesto por el componente: les presento la clase AutomationEvent.

La clase AutomationEvent representa un evento de automatización.  Necesitamos obtener una referencia del evento OnGetLogicalDrivesInfo, el cual disparará el componente de .NET una vez que hayamos obtenido la lista de todas las unidades lógicas.  Esto lo podemos hacer a través del método GetEvent() de la clase AutomationFactory, indicando primeramente el objeto que incluye el evento, seguido del nombre del evento como tal.  El método GetEvent() nos regresará un objeto de tipo AutomationEvent.

La clase AutomationEvent incluye un evento llamado EventRaised, el cual es disparado como resultado del evento del componente.  En los argumentos del evento EventRaised podremos obtener la lista de argumentos originales.  El siguiente código muestra el manejo del evento OnGetLogicalDrivesInfo, el cual una vez manejado obtenemos el conteo del total de unidades lógicas leídas.

dynamic obj = AutomationFactory.CreateObject("Utilerias.Informacion");

AutomationEvent ev = AutomationFactory.GetEvent(obj, "OnGetLogicalDrivesInfo");
ev.EventRaised += (s, a) =>
{
    MessageBox.Show(string.Format("Total de unidades: {0}", a.Arguments[0]));
};

Al ejecutar la aplicación con los cambios que hemos implementado, podremos obtener el valor del argumento del evento que se ha disparado.

El BCL (Biblioteca de Clases Base, por sus siglas en inglés) de Silverlight está reducido a comparación del BCL del .NET Framework completo que tenemos instalado en nuestros equipos, por lo que la funcionalidad no es la misma en un aplicativo de Silverlight que alguno construido con el .NET Framework completo.

No obstante, a partir de Silverlight 4, es posible que las aplicaciones de Silverlight sean clientes de automatización cuando ejecutan en Confianza Elevada, esto es, poder invocar los servidores de automatización registrados en el sistema operativo Windows.  Generalmente, la mayoría de ejemplos que podemos encontrar en la Web al respecto de esta característica van por el lado de invocar los servidores de automatización de Office (Outlook.Application o Excel.Application por ejemplo), pero ¿qué sucede si necesitamos invocar funcionalidad ya construida en alguno de nustros ensamblados que hayamos escrito en .NET 4.0?

Ensamblado

En esta solución crearemos dos proyectos, uno de tipo Class Library del .NET Framework 4.0 y otro proyecto será la aplicación de Silverlight.

En el proyecto de la Biblioteca de Clases escribiremos la funcionalidad para obtener la información de todas las unidades lógicas del equipo.  Tradicionalmente, esto lo podemos lograr por medio de la clase DriveInfo del espacio de nombres System.IO, pero justamente esa es una de las clases que no está en el BCL de Silverlight, por lo que crearemos un ensamblado de .NET 4.0 que regrese esa información, y la usaremos en un aplicativo de Silverlight.

La clave para lograr esto es abrir las propiedades del proyecto de la Biblioteca de Clases y seleccionar la opción “Register for COM interop” para poder exponer este ensamblado a través de COM.

En el proyecto agregaremos una clase llamada DriveInfo, la cual tendrá las propiedades Name, DriveFormat, TotalSize y TotalFreeSpace de la siguiente manera:

[ComVisible(true)]

public class DriveInfo

{

    public string Name { get; set; }

    public string DriveFormat { get; set; }

    public long TotalSize { get; set; }

    public long TotalFreeSpace { get; set; }

}

Nota cómo se está decorando la clase con el atributo ComVisibleAttribute.  Este atributo indica que este tipo estará disponible a través de COM.

Adicionalmente a esto, agregaremos una clase llamada Información.cs, la cual tendrá el método GetLogicalDrivesInfo() para regresar la información de todas las unidades lógicas del equipo del usuario.  También he agregado el método GetLogicalDrives() para obtener únicamente el nombre de todas las unidades lógicas.  De hecho, también podríamos agregar cualquier funcionalidad necesaria que utilice el .NET Framework 4.0 (métodos, propiedades y eventos).  El siguiente fragmento de código muestra la implementación de la clase Informacion.cs.   Nota cómo también se está decorando con el atributo ComVisibleAttribute.

[ComVisible(true)]
public class Informacion
{
    public DriveInfo[] GetLogicalDrivesInfo()
    {

        var result = new List<DriveInfo>();
        var drives = System.IO.DriveInfo.GetDrives();

        foreach (var item in drives)
        {
            if (true)
            {
                result.Add(new DriveInfo()
                {
                    Name = item.Name,
                    DriveFormat = item.IsReady ? item.DriveFormat : string.Empty,
                    TotalFreeSpace = item.IsReady ? item.TotalFreeSpace : 0,
                    TotalSize = item.IsReady ? item.TotalSize : 0
                });
            }
        }

        return result.ToArray();
    }

    public string[] GetLogicalDrives()
    {
        return System.Environment.GetLogicalDrives();
    }
}

Gracias a la opción que habilitamos en las propiedades del proyecto de Silverlight, al compilar el ensamblado este será registrado en el registro de la máquina local con un progID del tipo EspacioDeNombres.Clase, en este caso Utilerias.Información.  Para hacer esto manualmente podrías utilizar la utilería regasm.exe, cuando quisieras registrar el ensamblado en los equipos de tus usuarios.

Nota: necesitarás ejecutar Visual Studio .NET como Administrador, para que al momento de compilar el tipo sea registrado adecuadamente en el Registro de tu equipo.

Proyecto de Silverlight

Del lado del proyecto de Silverlight utilizaremos la clase AutomationFactory y su método CreateObject() para poder crear una referencia al componente con progID Utilerias.Información registrado previamente.

Además de esto, crearemos una clase DriveInfo.cs, igual a la que creamos en el proyecto de la Biblioteca de Clases.  Esto para poder crear un DataTemplate adecuado al presentar la información de las unidades lógicas en un ListBox.

if (AutomationFactory.IsAvailable)
{
    dynamic obj = AutomationFactory.CreateObject("Utilerias.Informacion");

    var drives = obj.GetLogicalDrivesInfo();

    var result = new List<DriveInfo>();

    foreach (var item in drives)
    {
        var driveInfo = new DriveInfo();
        driveInfo.Name = item.Name;
        driveInfo.TotalFreeSpace = item.TotalFreeSpace;
        driveInfo.TotalSize = item.TotalSize;
        driveInfo.DriveFormat = item.DriveFormat;

        result.Add(driveInfo);
    }

    if (result.Count > 0)
    {
        listBox1.ItemsSource = result;
    }
}

Nota el uso de los tipos dinámicos (palabra clave dynamic).  Debido a que se basan en Late Binding, no tendremos Intellisense para poder conocer los miembros del tipo en cuestión, por lo que es importante que los nombres correspondan correctamente.

Finalmente, al probar la aplicación te podrás dar cuenta que efectivamente tu aplicación de Silverlight utiliza el ensamblado Utilerias.dll que creamos en el primer paso, usando el .NET Framework 4.0 completo.  A través de AutomationFactory lo accedemos y obtenemos la información de todas las unidades lógicas del equipo.

Toma en cuenta que el ensamblado que vayas a utilizar, deberá estar registrado previamente en la máquina del usuario (utiliza regasm.exe), de lo contrario AutomationFactory.CreateObject() arrojará una excepción.  Probablemente necesitarás un instalador de prerequisitos antes de instalar y/o ejecutar la aplicación de Silverlight en Confianza Elevada.

¡Espero que les sea de utilidad!

Gracias a todos(as) por asistir al Webcast: “Interoperabilidad con COM en aplicaciones Silverlight 4” que realicé hoy por la mañana.  Pueden descargar el video de la misma dirección de donde se registraron (si no lo hicieron lo pueden hacer en este momento). Al momento de estar escribiendo este post aún no está disponible pero tengo entendido que en las próximas 24 horas deberá estarlo.

También pueden descargar el código fuente de la aplicación con los ejemplos que se realizaron en esta dirección.

Gracias y salu2!

Tengo el honor de haber sido invitado como expositor para la 1era. Convención Internacional de Interoperabilidad, el cual es un evento virtual que se llevará a cabo el próximo 09 de Junio 2010 a las 10:00 horas.  En el evento podrán ver escenarios de integración entre diferentes tecnologías, explicados por expertos de diversas materias y plataformas.

En mi caso participaré con el tema “Interoperabilidad con COM en aplicaciones de Silverlight 4”.  En dicha sesión, ustedes podrán comprobar lo sencillo que es invocar funcionalidades existentes en componentes de COM (Component Object Model) desde sus aplicativos que ejecuten Afuera del Navegador con Silverlight 4.  Si bien no es un escenario multi-plataforma como tal (COM es una plataforma de Microsoft, como lo es Silverlight), son tecnologías diferentes y hoy en día es bastante común tratar de lograr lo que en mi sesión expongo, por ejemplo, tratar de integrar un aplicación de Silverlight con Office.  ¡Espero que les sea de utilidad!  También les reitero que su retroalimentación es muy importante!

La información es la siguiente:

Microsoft Latinoamérica te invita a participar este miércoles 9 de junio, en la 1ª Convención Virtual Internacional de Interoperabilidad “Tecnologías Integradas”. Es un evento que tiene como objetivo mostrar escenarios de la vida real que te permitirán ver la manera más efectiva de integrar diversas tecnologías del mundo de hoy. Durante el mismo, tendrás la oportunidad de compartir las experiencias de cada uno de los expositores internacionales desarrolladores de soluciones en diferentes plataformas, dentro del marco de integración tecnológica. Contaremos con la participación de tecnólogos, desarrolladores y profesionales de interoperabilidad de Venezuela, Ecuador, México, Perú, Brasil y otros países de Latinoamérica.

Fecha: 09 de Junio

Horario: 10:00 horas

(Evento Virtual)

Pueden revisar toda la agenda del evento aquí

Asimismo, les invito a que se registren aquí

¡Los esperamos!