Windows Desktop: Arquitetura para Plugins – C#

Olá pessoal!

Neste humilde post, irei apresentar uma Arquitetura Plugin para ser usada no .Net Framework.

Mas o que são Plugins? Várias vezes nos deparamos com essa expressão. Plugin vem do inglês e é a junção das palavras Plug in, que podem ser traduzidas como Conectar ou Ligar. A expressão plugin se refere justamente ao fato de ser algo que pode se conectar a um Programa. Um plugin é algo que pode adicionar funcionalidades a um programa, sem alterar o código do mesmo, pois o programa já possui o suporte à isso.

Grandes softwares do mercado possuem suporte à plugins. Vou citar o Adobe Photoshop. Quer adicionar um efeito novo à biblioteca? Baixe um plugin e coloque-o na pasta de extensões. Ele milagrosamente (só que não) irá incorporar o plugin à interface quando você iniciá-lo.

Resumindo, um plugin é um arquivo (Uma dll, um script, ou outra coisa) que quando adicionado à pasta da sua aplicação, poderá adicionar funcionalidades e/ou alterar a interface. Isso é o que ele faz!

No caso deste post, estarei mostrando como criar um Plugin em forma de um Assembly .Net. Assim você poderá programa-lo na sua linguagem preferida com todo o conforto.

Já tendo a aplicação que você deseja adicionar suporte à plugins, primeiramente você precisa criar uma Interface que irá definir o esqueleto desse Plugin. No nosso exemplo, faça assim:

    /// <summary>
    /// Descreve um plugin na sua forma rudimentar.
    /// </summary>
    public interface IPlugin
    {
        string Name { get; }
        string Author { get; }
        string Caption { get; }
        void Execute(ref System.Windows.Forms.Panel src);
    }

Tendo a interface pronta, você irá precisar de uma classe que fará o escaneamento da pasta da sua aplicação à procura de plugins e que carregue eles na memória e os deixe prontos para serem usados. Segue a mesma:

    public class PluginManager
    {
        #region Arquitetura Singleton

        private static PluginManager _Instance;
        public static PluginManager Current
        {
            get
            {
                if(_Instance == null)
                {
                    _Instance = new PluginManager();
                }
                return _Instance;
            }
        }
        #endregion
        private PluginManager()
        {
            _Plugins = new List<IPlugin>();
            Load();
        }
        private readonly string Folder = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + @"\Plugins";

        private List<IPlugin> _Plugins;
        public ICollection<IPlugin> Plugins
        {
            get
            {
                return _Plugins;
            }
        }

        private void Load()
        {
            if (!System.IO.Directory.Exists(Folder)) return;
            string[] pluginsPaths = System.IO.Directory.GetFiles(Folder, "*.dll");
            foreach (string path in pluginsPaths)
            {
                Assembly pluginAssembly = Assembly.LoadFile(path);
                LoadPlugin(pluginAssembly);
            }
        }

        private void LoadPlugin(Assembly Plugin)
        {
            Type[] typesInAssembly = Plugin.GetTypes();
            Type IPlugin = typeof(IPlugin);
            foreach (Type type in typesInAssembly)
            {
                if (!IPlugin.IsAssignableFrom(type)) continue;
                IPlugin Extension = (IPlugin)Plugin.CreateInstance(type.FullName);                  
                if (Extension != null) _Plugins.Add(Extension);
            }
            typesInAssembly = null;
        }

    }

A classe PluginManager possui arquitetura Singleton, ou seja, uma única instância será criada para toda a aplicação. Isso garante que os plugins não sejam carregados múltiplas vezes acarretando erros.

O código acima, basicamente, obtém todos os arquivos dll da pasta pré-definida onde irão ficar as extensões. Após isso, ele carrega cada dll na memória dinamicamente usando Reflexão. Logo depois, no método LoadPlugin, a dll recem carregada é escaneada à procura de tipos que implementem a interface IPlugin. Cada tipo que implemente essa interface é um Plugin capaz. Quando o código encontra um plugin, ele cria uma instância desse plugin e adiciona à lista de plugins. Assim seu aplicativo estará pronto para usufruir dos plugins existentes na pasta da sua aplicação.

É óbvio que isso tudo não servirá pra nada. Digo, você precisa agora adaptar a sua aplicação para usufruir dos Plugins. Obviamente, você pode modificar a interface IPlugin para adicionar características que você deseja que seus plugins tenham. Isso tudo é apenas um exemplo básico de como a coisa toda funciona.

Agora, que você já implementou sua aplicação para fazer uso dos plugins carregados (eu sei que você não fez isso, mas para melhor compreensão, vou disponibilizar um projeto completo para estudo) , está na hora de criar um plugin.

Na nossa arquitetura, um plugin será uma Class Library. A versão do .Net Framework usado pelo plugin deve ser o mesmo da aplicação. Na sua Class Library, você deve adicionar uma referência para a sua aplicação. Feito isso, crie uma classe e herde ela da interface IPlugin. Pronto, você criou um plugin! Implemente os códigos para as funcionalidades que você deseja. Ao colocar o plugin a pasta da sua aplicação, ele será identificado e carregado.

Um exemplo de plugin:

    public class Install : Main_Application.Plugins.IPlugin
    {
        public string Name
        {
            get { return "WebBrowser Plugin"; }
        }

        public string Author
        {
            get { return "Herbert Lausmann"; }
        }

        public string Caption
        {
            get { return "Navegar"; }
        }

        public void Execute(ref System.Windows.Forms.Panel src)
        {
            src.Controls.Clear();
            System.Windows.Forms.WebBrowser web = new System.Windows.Forms.WebBrowser();
            web.Name = "Web";
            src.Tag = "Web";
            src.Controls.Add(web);
            web.Dock = System.Windows.Forms.DockStyle.Fill;
            web.Navigate("https://herbertdotlausmann.wordpress.com/");
        }
    }

Note que eu citei pasta da aplicação, mas no caso do nosso exemplo, os plugins ficarão armazenados dentro de uma pasta Plugins que ficará no diretório da aplicação em si.

Abaixo, o link para download do projeto completo do Exemplo totalmente funcional:

Plugin Architecture.zip

Bom proveito!!

PS: Meu projeto Intelli Clip implementa suporte à plugins da mesma maneira ^-^

Anúncios

3 comentários

  1. Olá Herbert!

    Sem dúvida.. Inclusive é muito importante esse tipo de experimento para conseguirmos entender como as coisas funcionam por trás dos panos.. Só mencionei o MEF para caso você ainda não conhecesse..

    Abraço!
    André Lima

    1. Olá André,

      Sim, conheço, já li sobre o MEF. E tem o MAF também.

      O principio é o mesmo. A diferença é que no MEF é mais” automatizado”.

      A preferência vai pro MEF por já ser algo nativo no .Net, mas ele não é suportado em versões mais antigas que o 3.5.

      Enfim, sei lá, questão de preferência. Eu acho divertido fazer manualmente as vezes, fora que é possível ter um controle total da estrutura…

      Obrigado, abraço!

Deixe um comentário :)

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s