Avaliação: | Publicado em: 04/09/2006

Criando aplicações com plugin

Francisco Rodrigues Graduando em Sistemas de Informação na UNIT e formado pelo NPOR. Atua há dois anos e meio na área de desenvolvimento de sistemas na plataforma .NET (WEB e MOBILE) através do desenvolvimento de soluções para as empresas do Grupo Constâncio Vieira.

Criando aplicações com plugin

Desta vez irei dar o caminho das pedras para aqueles que desejam que suas aplicações tenham suporte a plugins. A tarefa não é bicho de sete cabeças, mas é bom que se tenha uma orientação a objeto consolidada.

Nesse artigo irei criar uma aplicação windows form e definir uma interface que contenha tudo aquilo que for necessários para a criação e exibição dos plugins utilizando o menu.

Nível: Intermediário
Ferramenta utilizada: Visual Studio 2003
Linguagem: C#

Criação do Projeto

Criaremos uma solução e adicionaremos um projeto windows form(irei utilizar o que foi desenvolvido no artigo anterior ‘Criando um formulário base para aplicações Windows Form’. Adicione ao formulário um MainMenu(Ele que será responsável pela exibição das chamadas dos plugins) conforme a figura abaixo:

Agora iremos definir a nossa interface. Para isso, crie um projeto do tipo class library (já que iremos compartilhar a mesma referência para o projeto principal, que é um windows form, e para o projeto de teste) e adicione a interface conforme código abaixo.

Ela é através dela que o seu formulário principal irá saber como chamar os plugins.

/* Interface para demostrar o uso de plugins
* */
using System;

namespace AppArt03
{
  public interface IPlugin
  {
  /// <summary>
  /// Método responsável por chamar a tela para que ela seja exibida
   /// </summary>
   void ExibirTela();
   /// <summary>
   /// Texto que irá aparecer no menu
   /// </summary>
     string NomeMenu
    {
       get ;
    }
  }
}

Voltando ao formulário principal, no evento Load do form, iremos colocar toda a lógica de montagem do menu. Utilizaremos um HashTable para guardar os plugins que foram lidos, já que quando o usuário clicar no item que corresponde a um plugin, este irá disparar o evento ExibirTela não sendo necessário a carga e busca do item que foi selecionado.

O algoritmo básico é:

1	Ler todos as dll que estão em uma pasta pré-estabelecida;
2	Para cada dll que foi lida verificar se cada classe dela implementa a interface IPlugin
3	Se implementar a interface IPlugin faça
	3.1	Crie um novo item de menu, associando ao evento que será plugado ao onClick
	3.2	Adicionar no hashtable a classe (que é um form) para sinalizá-la como plugin
	3.3	Adicionar no menu o item do menu criado

Antes de tudo, adicione os namespaces System.IO (para trabalhar com arquivos) e System.Reflection(para verificar se ela implementa minha interface de plugins).

Mãos a obra!

private void frmMain_Load(object sender, System.EventArgs e)
{
///Limpando os itens do menu "Plugins"
menuItemPlugins.MenuItems.Clear();
//Configurando o diretorio padrão para os plugins
string lPathPlugins = Path.Combine( Application.StartupPath, "plugin");
//Verifica se existe o diretorio
if ( Directory.Exists( lPathPlugins ) )
{
//para cada arquivo no diretorio padrão com a extensão *.dll faça
foreach ( string lDll in Directory.GetFiles(lPathPlugins, "*.dll") )
{
//Carregue a dll para memória
Assembly ass = Assembly.LoadFile(lDll);
if (ass != null)
{
IPlugin lPlugin = null;
//Pegue cada classe da dll (uma dll pode conter mais de uma classe)
foreach ( Type lType in ass.GetTypes() )
{
try
{
//Para a classe solicitada, tenta crirar a instância
lPlugin = (IPlugin)Activator.CreateInstance(lType);
if ( lPlugin != null )
{
//Se conseguiu, cria um novo item de menu e informa qual o evento que será chamado no onClick
MenuItem lMenuItem = new MenuItem( lPlugin.NomeMenu, new EventHandler(EventoClickDoItemDoPlugin) );
//Adiciona o item do menu para o menu principal
menuItemPlugins.MenuItems.Add( lMenuItem );
//Adiciona no hashtable para que depois possamos recuperar a classe
fPlugins.Add( lMenuItem.GetHashCode(), lPlugin );
}
}
catch{}
}
}
}
}
}

///<summary>
/// Evento que será chamado ao selecionar um item do menu "Plugin"
/// </summary>
/// <param name="sender">Quem chamou o evento</param>
/// <param name="e"></param>
private void EventoClickDoItemDoPlugin(object sender, System.EventArgs e)
{
try
{
///Recupera o item do menu que foi selecionado
MenuItem mn = (MenuItem)sender;
//Recupera a interface do plugin
IPlugin lPlugin = fPlugins[mn.GetHashCode()] as IPlugin;
if ( lPlugin == null )
throw new Exception( "Erro ao carregar o plugin");
//Chama o metodo responsavel por exibir o plugin
lPlugin.ExibirTela();
}
catch( Exception Erro )
{
ExibirErro( Erro );
}
}

Pronto, definimos a carga dos plugins, agora vamos criar os plugins.

Criaremos um outro projeto windows form (depois mudaremos para class library) já que iremos trabalhar com outras dll. Nesse segundo projeto, adicione quantos formulários você desejar desde que ele implemente a nossa Interface de plugins.

O primeiro formulário consta como a imagem abaixo:

E o segundo,

As duas telas acima possuem os seguintes códigos:

private void btnFechar_Click( object sender, System.EventArgs e)
{
   this.Close();
}
public string NomeMenu
{
  get { return "Tela X" ;} //X é o número da tela
}
public void ExibirTela()
{
  this.Show();
}

Altere as configurações do projeto, colocando ele como Class Library conforme a figura abaixo:

Ao Executar o projeto, você perceberá que não irá aparecer nenhum plugin. Para que apareça, copie as dll geradas no projeto que contém os formulários acima para o caminho que está sendo executado a sua aplicação acrescentado de /Plugin/. O resultado é o seguinte:

Algumas melhorias:

•  Alterar carga de plugins para que ele leia de um arquivo xml

•  Adicionar alguns campos na interface para que possa fazer alguma validação

•  Alterar carga para que só seja criado o formulário quando necessário

Faça o download dos arquivos deste artigo logo abaixo.

Bom, por hoje fico por aqui. Espero que tenham gostado e estou aguardando sugestões de assuntos!

• source-windowsform-csharp.zip