Extiende tus aplicaciones .NET con complementos

Spanish (Español) translation by Ana Paulina Figueroa (you can also view the original English article)

¿Tu aplicación carece de una funcionalidad impresionante? permite que otros desarrolladores interesados amplíen tu aplicación a través de complementos. Al abrir tu aplicación en su totalidad a funcionalidades adicionales, puedes construir una comunidad próspera alrededor de tu aplicación, ¡incluso potencialmente un mercado!.

¡En el tutorial de hoy vamos a aprender justamente eso!.

Paso 0 - Nuestro plan

Dependiendo de qué versión de Visual Studio estés usando, y de la versión del framework para el que estés desarrollando, algunas capturas de pantalla pueden verse ligeramente diferentes.

Vamos a construir una aplicación de prueba de concepto que, al arrancar, cargue complementos que encontrará en uno de sus subdirectorios. Estos complementos son ensamblados .NET que contienen al menos una clase que implementa una interfaz en particular según lo definamos nosotros. Los conceptos de este tutorial deben poder transferirse fácilmente a tus aplicaciones existentes sin mucho trabajo. Después veremos un ejemplo más complejo utilizando componentes de la interfaz de usuario cargados desde un complemento.

Este tutorial fue escrito usando Microsoft Visual Studio 2010, en VB.NET y desarrollando para el Framework 4.0 de .NET. Los conceptos principales de este tutorial deben funcionar en otros lenguajes CLR, desde el Framework 1.1 de .NET en adelante. Hay algunas características de menor importancia que no funcionarán en otros lenguajes CLR (pero que deberían poder adaptarse con mucha facilidad) y algunos conceptos como los genéricos que evidentemente no funcionarán en .NET 1.1, etcétera.

Nota: Este es un tutorial de nivel experto para las personas que no tienen inconvenientes con la conversión de código entre diferentes lenguajes CLR y versiones del Framework de .NET. Se trata más de "reemplazar el motor de tu automóvil" que de "cómo conducir".

Paso 1 - Implementación inicial a pequeña escala

Nota: Tus referencias pueden ser diferentes dependiendo de la versión del Framework de .NET para la que estés desarrollando.

Vamos a comenzar implementando una versión a pequeña escala de nuestra aplicación. Necesitaremos tres proyectos en nuestra solución:

ConsoleAppA: Una aplicación de consola
ClassLibA: Una biblioteca de clases
AddonA: Una biblioteca de clases que actuará como nuestro complemento

Agrega una referencia a ClassLibA desde ConsoleAppA y AddonA. A continuación el explorador de soluciones se verá de esta manera:

Creando la interfaz del complemento

Para que una clase compilada sea considerada compatible, cada uno de los complementos de nuestra aplicación necesitará implementar una interfaz específica. Esta interfaz definirá las propiedades y operaciones necesarias que la clase debe tener para que nuestra aplicación pueda interactuar con el complemento sin problemas. También podemos usar una clase abstract/MustInherit como base para los complementos, pero en este ejemplo usaremos una interfaz.

Aquí está el código de nuestra interfaz, que debe ser colocado en un archivo llamado IApplicationModule dentro de la biblioteca de clases ClassLibA.


Public Interface IApplicationModule

    ReadOnly Property Id As Guid
    ReadOnly Property Name As String

    Sub Initialise()

End Interface

Las propiedades y métodos que defines en la interfaz son arbitrarios. En este caso he definido dos propiedades y un método, pero en la práctica puedes y debes cambiarlos según sea necesario.

No vamos a usar las propiedades Id ni Name en nuestro primer ejemplo, pero son propiedades útiles de implementar, y es probable que quieras que estén presentes si estás usando complementos en producción.

Creando un complemento

Ahora vamos a crear el complemento en sí. Reiterando, para que cualquier clase sea considerada un complemento para nuestra aplicación, se necesita que implemente nuestra interfaz - IApplicationModule.

Aquí está el código para nuestro complemento básico, que debe ser colocado en un archivo llamado MyAddonClass dentro de la biblioteca de clases AddonA.


Imports ClassLibA

Public Class MyAddonClass
    Implements IApplicationModule

    Public ReadOnly Property Id As System.Guid Implements ClassLibA.IApplicationModule.Id
        Get
            Return New Guid("adb86b53-2207-488e-b0f3-ecd13eae4042")
        End Get
    End Property

    Public Sub Initialise() Implements ClassLibA.IApplicationModule.Initialise
        Console.WriteLine("MyAddonClass is starting up ...")
        'Perform start-up initialisation here ...
    End Sub

    Public ReadOnly Property Name As String Implements ClassLibA.IApplicationModule.Name
        Get
            Return "My first test add-on"
        End Get
    End Property
End Class

Paso 2 - Encontrando complementos en tiempo de ejecución

A continuación necesitamos una manera de encontrar complementos para nuestra aplicación. En este ejemplo vamos a asumir que ha sido creada una carpeta Addons en el directorio del archivo ejecutable. Si estás haciendo pruebas dentro de Visual Studio, ten en cuenta el directorio predeterminado para la salida de los proyectos, es decir ./bin/debug/, por lo tanto necesitarás un directorio ./bin/debug/Addons/.

Tiempo para reflexionar

Coloca el método TryLoadAssemblyReference mostrado más adelante dentro de Module1 de ConsoleAppA. Investigamos el ensamblado cargado mediante el uso de Reflection. Un tutorial en pseudocódigo sobre su funcionalidad es el siguiente:

Intenta cargar el dllFilePath dado como un ensamblado de .NET
Si hemos cargado el ensamblado con éxito, continúa
Por cada módulo en el ensamblado cargado
Por cada tipo en ese módulo
Por cada interfaz implementada por ese tipo
Si esa interfaz es la interfaz de nuestro complemento (IApplicationModule), entonces
Guarda un registro de ese tipo. Termina con la búsqueda.
Finalmente, devuelve todos los tipos válidos encontrados


    Private Function TryLoadAssemblyReference(ByVal dllFilePath As String) As List(Of System.Type)
        Dim loadedAssembly As Assembly
        Dim listOfModules As New List(Of System.Type)
        Try
            loadedAssembly = Assembly.LoadFile(dllFilePath)
        Catch ex As Exception
        End Try
        If loadedAssembly IsNot Nothing Then
            For Each assemblyModule In loadedAssembly.GetModules
                For Each moduleType In assemblyModule.GetTypes()
                    For Each interfaceImplemented In moduleType.GetInterfaces()
                        If interfaceImplemented.FullName = "ClassLibA.IApplicationModule" Then
                            listOfModules.Add(moduleType)
                        End If
                    Next
                Next
            Next
        End If
        Return listOfModules
    End Function

Arrancando nuestros complementos

Finalmente, ahora podemos cargar en memoria una clase compilada que implemente nuestra interfaz. Pero no tenemos código que podamos encontrar, instanciar ni podemos hacer llamadas a métodos en esas clases. A continuación crearemos código que haga justamente eso.

La primera parte es encontrar todos los archivos que pudieran ser complementos, como se muestra abajo. El código lleva a cabo una búsqueda de archivos relativamente sencilla, y por cada archivo DLL encontrado intenta cargar todos los tipos válidos de ese ensamblado. Los archivos DLL descubiertos dentro de la carpeta Addons no son necesariamente complementos. Estos simplemente podrían contener funcionalidad adicional requerida por algún complemento pero no ser complementos por sí mismos.


        Dim currentApplicationDirectory As String = My.Application.Info.DirectoryPath
        Dim addonsRootDirectory As String = currentApplicationDirectory & "\Addons\"
        Dim addonsLoaded As New List(Of System.Type)

        If My.Computer.FileSystem.DirectoryExists(addonsRootDirectory) Then
            Dim dllFilesFound = My.Computer.FileSystem.GetFiles(addonsRootDirectory, Microsoft.VisualBasic.FileIO.SearchOption.SearchAllSubDirectories, "*.dll")
            For Each dllFile In dllFilesFound
                Dim modulesFound = TryLoadAssemblyReference(dllFile)
                addonsLoaded.AddRange(modulesFound)
            Next
        End If

A continuación necesitamos hacer algo con cada tipo válido que hemos encontrado. El siguiente código creará una nueva instancia del tipo, le asignará un tipo de dato, invocará al método Initialise() (que es simplemente un método arbitrario que definimos en nuestra interfaz) y luego mantendrá una referencia a ese tipo instanciado en una lista a nivel de módulo.


        If addonsLoaded.Count > 0 Then
            For Each addonToInstantiate In addonsLoaded
                Dim thisInstance = Activator.CreateInstance(addonToInstantiate)
                Dim thisTypedInstance = CType(thisInstance, ClassLibA.IApplicationModule)
                thisTypedInstance.Initialise()
                m_addonInstances.Add(thisInstance)
            Next
        End If

Poniéndolo todo junto, nuestra aplicación de consola debería comenzar a verse algo así:


Imports System.Reflection

Module Module1

    Private m_addonInstances As New List(Of ClassLibA.IApplicationModule)

    Sub Main()
        LoadAdditionalModules()

        Console.WriteLine('Finished loading modules ...')
        Console.ReadLine()
    End Sub

    Private Sub LoadAdditionalModules()
        Dim currentApplicationDirectory As String = My.Application.Info.DirectoryPath
        Dim addonsRootDirectory As String = currentApplicationDirectory & '\Addons\'
        Dim addonsLoaded As New List(Of System.Type)

        If My.Computer.FileSystem.DirectoryExists(addonsRootDirectory) Then
            Dim dllFilesFound = My.Computer.FileSystem.GetFiles(addonsRootDirectory, Microsoft.VisualBasic.FileIO.SearchOption.SearchAllSubDirectories, "*.dll")
            For Each dllFile In dllFilesFound
                Dim modulesFound = TryLoadAssemblyReference(dllFile)
                addonsLoaded.AddRange(modulesFound)
            Next
        End If

        If addonsLoaded.Count > 0 Then
            For Each addonToInstantiate In addonsLoaded
                Dim thisInstance = Activator.CreateInstance(addonToInstantiate)
                Dim thisTypedInstance = CType(thisInstance, ClassLibA.IApplicationModule)
                thisTypedInstance.Initialise()
                m_addonInstances.Add(thisInstance)
            Next
        End If
    End Sub

    Private Function TryLoadAssemblyReference(ByVal dllFilePath As String) As List(Of System.Type)
        Dim loadedAssembly As Assembly
        Dim listOfModules As New List(Of System.Type)
        Try
            loadedAssembly = Assembly.LoadFile(dllFilePath)            
        Catch ex As Exception
        End Try
        If loadedAssembly IsNot Nothing Then
            For Each assemblyModule In loadedAssembly.GetModules
                For Each moduleType In assemblyModule.GetTypes()
                    For Each interfaceImplemented In moduleType.GetInterfaces()
                        If interfaceImplemented.FullName = 'ClassLibA.IApplicationModule' Then
                            listOfModules.Add(moduleType)
                        End If
                    Next
                Next
            Next
        End If
        Return listOfModules
    End Function
End Module

Ejecución de prueba

En este punto deberíamos poder llevar a cabo una compilación completa de nuestra solución. Cuando tus archivos hayan sido compilados, copia el resultado del ensamblado compilado del proyecto AddonA en la carpeta Addons de ConsoleAppA. La carpeta Addons debe crearse dentro del directorio /bin/debug/. En mi computadora usando Visual Studio 2010, con las ubicaciones predeterminadas del proyecto y una solución llamada "DotNetAddons", la carpeta se encuentra aquí:

C:\Users\jplenderleith\Documents\Visual Studio 2010\Projects\DotNetAddons\ConsoleAppA\bin\Debug\Addons

Deberemos ver la siguiente salida al ejecutar el código:

1
2	MyAddonClass is starting up ...
3	Finished loading modules ...

Tal como está, el resultado no es llamativo ni impresionante, pero demuestra una pieza clave de la funcionalidad, es decir, en tiempo de ejecución podemos tomar un ensamblado y ejecutar el código contenido en el mismo sin tener ningún conocimiento existente sobre ese ensamblado. Esta es la base para la construcción de complementos más complejos.

Paso 3 - Integración con una interfaz de usuario

A continuación veremos cómo crear un par de complementos para proporcionar funcionalidad adicional dentro de una aplicación de Windows Forms.

De manera similar a como lo hicimos con la solución existente, crea una nueva solución con los siguientes proyectos:

WinFormsAppA: Una aplicación de Windows Forms
ClassLibA: Una biblioteca de clases
UIAddonA: Una biblioteca de clases que albergará un par de complementos con componentes de la interfaz de usuario.

Similar a nuestra solución anterior, tanto el proyecto WinFormsAppA como UIAddonA deben tener referencias a ClassLibA. El proyecto UIAddonA también necesitará una referencia a System.Windows.Forms para acceder a su funcionalidad.

La aplicación Windows Forms

Crearemos una interfaz de usuario rápida y simple para nuestra aplicación. Estará compuesta por un MenuStrip y un DataGridView. El control MenuStrip debe tener tres MenuItems

File (Archivo)
Add-ons (Complementos)
Help (Ayuda)

Acopla el DataGridView a su contenedor padre, que es el formulario en sí. Vamos a crear código para mostrar algunos datos de ejemplo en nuestra tabla. El MenuItem Add-ons (Complementos) será rellenado con todos los complementos que hayan sido cargados durante el arranque de la aplicación.

Esta es una captura de pantalla de la aplicación en este punto:

Vamos a escribir un poco de código para darle algo de funcionalidad al formulario principal de WinFormsAppA. Cuando el formulario cargue, éste invocará al método LoadAddons() que actualmente está vacío (lo llenaremos más adelante). Después generamos algunos datos de empleados de ejemplo que enlazaremos a nuestro DataGridView.


Public Class Form1

    Private m_testDataSource As DataSet
    Private m_graphicalAddons As List(Of System.Type)

    Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        LoadAddons()
        m_testDataSource = GenerateTestDataSet()
        With DataGridView1
            .AutoGenerateColumns = True
            .AutoResizeColumns()
            .DataSource = m_testDataSource.Tables(0)
        End With
    End Sub

    Private Sub LoadAddons()        

    End Sub

    Private Function GenerateTestDataSet() As DataSet
        Dim newDataSet As New DataSet
        Dim newDataTable As New DataTable
        Dim firstNames = {"Mary", "John", "Paul", "Justyna", "Michelle", "Andrew", "Michael"}
        Dim lastNames = {"O'Reilly", "Murphy", "Simons", "Kelly", "Gates", "Power"}
        Dim deptNames = {"Marketing", "Sales", "Technical", "Secretarial", "Security"}

        With newDataTable
            .Columns.Add("EmployeeId", GetType(Integer))
            .Columns.Add("Name", GetType(String))
            .Columns.Add("IsManager", GetType(Boolean))
            .Columns.Add("Department", GetType(String))
        End With

        For i = 1 To 100
            Dim newDataRow As DataRow = newDataTable.NewRow()
            With newDataRow
                .Item("EmployeeId") = i
                .Item("Name") = firstNames(i Mod firstNames.Count) & " " & lastNames(i Mod lastNames.Count)
                .Item("IsManager") = ((i Mod 20) = 0)
                .Item("Department") = deptNames(i Mod deptNames.Count)
            End With
            newDataTable.Rows.Add(newDataRow)
        Next

        newDataSet.Tables.Add(newDataTable)
        Return newDataSet
    End Function

End Class

Cuando ejecutemos la aplicación deberá verse así:

Regresaremos a nuestro LoadAddons() vacío después de que definamos las interfaces del complemento.

La interfaz del complemento

Vamos a definir la interfaz de nuestro complemento. Los componentes de interfaz de usuario estarán listados dentro del MenuStrip Add-ons (Complementos), y abrirán un formulario de Windows que tiene acceso a los datos a los que está vinculado nuestro DataGrid. Agrega un nuevo archivo de interfaz llamado IGraphicalAddon al proyecto ClassLibA y pega el siguiente código dentro de dicho archivo:


Public Interface IGraphicalAddon

    ReadOnly Property Name As String
    WriteOnly Property DataSource As DataSet
    Sub OnClick(ByVal sender As Object, ByVal e As System.EventArgs)

End Interface

Tenemos una propiedad Name (Nombre), que se explica por sí misma.
La propiedad DataSource se usa para "alimentar" datos a este complemento.
El método OnClick, que será usado como manejador cuando los usuarios hagan clic en la entrada de nuestro complemento en el menú Add-ons (Complementos).

Cargando los complementos

Agrega una biblioteca de clases llamada AddonLoader al proyecto de ensamblado ClassLibA con el siguiente código:


Imports System.Reflection

Public Class AddonLoader
    Public Enum AddonType
        IGraphicalAddon = 10
        ISomeOtherAddonType2 = 20
        ISomeOtherAddonType3 = 30
    End Enum

    Public Function GetAddonsByType(ByVal addonType As AddonType) As List(Of System.Type)
        Dim currentApplicationDirectory As String = My.Application.Info.DirectoryPath
        Dim addonsRootDirectory As String = currentApplicationDirectory & "\Addons\"
        Dim loadedAssembly As Assembly
        Dim listOfModules As New List(Of System.Type)

        If My.Computer.FileSystem.DirectoryExists(addonsRootDirectory) Then
            Dim dllFilesFound = My.Computer.FileSystem.GetFiles(addonsRootDirectory, Microsoft.VisualBasic.FileIO.SearchOption.SearchAllSubDirectories, "*.dll")
            For Each dllFile In dllFilesFound

                Try
                    loadedAssembly = Assembly.LoadFile(dllFile)
                Catch ex As Exception
                End Try
                If loadedAssembly IsNot Nothing Then
                    For Each assemblyModule In loadedAssembly.GetModules
                        For Each moduleType In assemblyModule.GetTypes()
                            For Each interfaceImplemented In moduleType.GetInterfaces()
                                If interfaceImplemented.Name = addonType.ToString Then
                                    listOfModules.Add(moduleType)
                                End If
                            Next
                        Next
                    Next
                End If

            Next
        End If

        Return listOfModules
    End Function
End Class

Puedes usar código similar a éste para restringir a los desarrolladores de complementos, de manera que solamente generen tipos de complementos específicos.

En esta clase hemos proporcionado una manera de cargar diferentes tipos de complementos. Puedes usar código similar a éste para restringir a los desarrolladores de complementos, de manera que solamente generen tipos de complementos específicos o para que al menos los categoricen. En nuestro ejemplo solamente usaremos el primer tipo de complemento declarado, es decir IGraphicalAddon.

Si tuviéramos otros tipos de complementos en nuestro proyecto, por ejemplo para mejorar la funcionalidad de generación de reportes o proporcionar útiles atajos de teclado, entonces no queremos que aparezcan listados en nuestro menú Add-ons (Complementos), ya que no tiene sentido que alguien pueda hacer clic en ese complemento.

Sin embargo, una vez dicho esto puede ser conveniente agregar una referencia a todos los complementos que estén bajo alguna barra de menú y que al hacer clic en ellos aparezca el formulario de opciones del complemento. No obstante, esto va mas allá del alcance de este tutorial.

El complemento gráfico

Vamos a construir el verdadero complemento de interfaz de usuario. Agrega los siguientes dos archivos al proyecto de ensamblado UIAddonA; una clase llamada UIReportAddon1 y un formulario de windows llamado UIReportAddon1Form. La clase UIReportAddon1 contendrá el siguiente código:


Imports ClassLibA

Public Class UIReportAddon1
    Implements ClassLibA.IGraphicalAddon

    Private _dataSource As DataSet
    Public WriteOnly Property DataSource As System.Data.DataSet Implements IGraphicalAddon.DataSource
        Set(ByVal value As System.Data.DataSet)
            _dataSource = value
        End Set
    End Property

    Public ReadOnly Property Name As String Implements IGraphicalAddon.Name
        Get
            Return "Managers Report"
        End Get
    End Property

    Public Sub OnClick(ByVal sender As Object, ByVal e As System.EventArgs) Implements IGraphicalAddon.OnClick
        Dim newUiReportingAddonForm As New UIReportAddon1Form
        newUiReportingAddonForm.SetData(_dataSource)
        newUiReportingAddonForm.ShowDialog()
    End Sub
End Class

Agrega un DataGridView a UIReportAddon1Form que esté acoplado dentro de su contenedor padre. Luego agrega el siguiente código:


Public Class UIReportAddon1Form

    Private m_providedDataSource As DataSet

    Public Sub SetData(ByVal DataSource As System.Data.DataSet)
        m_providedDataSource = DataSource
        FilterAndShowData()
    End Sub

    Private Sub FilterAndShowData()
        Dim managers = m_providedDataSource.Tables(0).Select("IsManager = True")
        Dim newDataTable = m_providedDataSource.Tables(0).Clone
        For Each dr In managers
            newDataTable.ImportRow(dr)
        Next
        DataGridView1.DataSource = newDataTable
    End Sub

    Private Sub UIReportAddon1Form_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        Text = "List of managers"
    End Sub
End Class

Simplemente estamos proporcionando los medios para enviar datos al formulario, y luego lo dejamos decidir qué hacer con dicha información. En este caso, vamos a llevar a cabo un Select() en una DataTable, obteniendo una lista de todos los empleados que son gerentes.

De vuelta a nuestra interfaz de usuario principal

Ahora es momento de terminar nuestro método LoadAddons() inconcluso dentro de nuestro proyecto WinFormsAppA. Este código instruirá al método GetAddonsByType de ClassLibA.AddonLoader para que encuentre un tipo de complemento en particular, en este caso complementos IGraphicalAddon.

Para cada complemento encontrado se llevarán a cabo las siguientes acciones

Crear una nueva instancia del complemento
Asignar un tipo IGraphicalAddon a la instancia del complemento
Rellenar su propiedad DataSource
Agrega el complemento al elemento del menú Add-ons (Complementos)
Agrega un manejador para el evento clic de ese elemento del menú


    Private Sub LoadAddons()
        Dim loader As New ClassLibA.AddonLoader
        Dim addonsLoaded = loader.GetAddonsByType(ClassLibA.AddonLoader.AddonType.IGraphicalAddon)

        For Each graphicalAddon In addonsLoaded
            Dim thisInstance = Activator.CreateInstance(graphicalAddon)
            Dim typedAddon = CType(thisInstance, ClassLibA.IGraphicalAddon)
            typedAddon.DataSource = m_testDataSource
            Dim newlyAddedToolstripItem = AddonsToolStripMenuItem.DropDownItems.Add(typedAddon.Name)
            AddHandler newlyAddedToolstripItem.Click, AddressOf typedAddon.OnClick
        Next
    End Sub

Probando nuestra interfaz de usuario

Asegúrate de poder llevar a cabo una compilación completa de la solución con éxito. Copia el archivo UIAddonA.dll de la carpeta de depuración de salida del proyecto UIAddonA en la carpeta /bin/debug/Addons/ del proyecto WinFormsAppA. Cuando ejecutes el proyecto deberás ver una tabla con información, como antes. Sin embargo, si haces clic en el menú Add-ons (Complementos) ahora deberás ver una referencia al complemento recientemente creado.

Al hacer clic en el menú Managers Report (Reporte de gerentes), esto ocasionará una llamada al método OnClick implementado en nuestro complemento, lo que causará que UIReportAddon1Form aparezca como se muestra a continuación.

Conclusión

Hemos visto dos ejemplos de cómo construir una aplicación que puede obtener y ejecutar complementos según sea necesario. Como mencioné anteriormente, debería ser lo suficientemente sencillo integrar este tipo de funcionalidad en aplicaciones existentes. En cuanto a la cantidad de control que necesitarás (o querrás) darle a desarrolladores de terceros, ese es otro tema por completo.

¡Espero que te hayas divertido con este tutorial! ¡Muchas gracias por leerlo!.