Mês: março 2015

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

Win32: Carregando um aplicativo externo dentro de um Panel – C# Win Forms

Fala aí galera!

Bom, hoje quero falar de algo um tanto interessante, e bem útil em casos bem raros. Trata-se de carregar a janela de uma outra aplicação dentro da sua aplicação, como se a janela externa fosse parte do seu aplicativo, quando na verdade está sendo executada em um processo completamente separado.

Abaixo, um print do que falo:

Application Hoster

No caso acima, eu carreguei o Paint dentro do Panel da janela do meu aplicativo.

Eu já utilizei isso de forma prática no passado. Foi uma vez que eu criei um aplicativo para baixar charges animadas do site animatunes.com. As charges eram baixadas pelo aplicativo (no formato swf, flash) apenas usando a url da página. O aplicativo incluía um player de vídeo para rodar as charges. No entanto, naquela época, o componente SWF Player COM consumia muito processamento, e as vezes até travava. Então eu separei a aplicação em duas, sendo a primeira a aplicação em si,  e a outra apenas o componente SWF Player. Quando em execução, o projeto carregava o player do processo separado dentro de um panel, como se tudo fosse parte de um executável só. Caso o player travasse, era só reiniciar o processo do player e pronto. Foi a maneira que eu consegui para manter o projeto estável.

Mais ou menos o mesmo conceito é usado no Google Chrome, onde cada guia é executada em um processo separado. Se uma guia travar, você pode finaliza-la sem afetar em nada a aplicação.

A técnica acima, combinada com IPC (Inter Process Communication – Comunicação Inter Processual) lhe dá o poder de criar aplicações multi processos.

Não vou abordar o IPC neste post, mas pretendo faze-lo no futuro.

Segue o link para baixar o projeto do Application Hoster:

Application Hoster.zip – 60KB

O código está comentando para melhor entendimento.

Até a próxima.