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 ^-^

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.

Obtendo números Pares e Ímpares de um intervalo numérico – C#

Olá pessoal,

Neste post vou apresentar a vocês dois métodos para retornar os números pares e impares de um intervalo numérico, em ordem crescente ou decrescente:

        public IEnumerable<int> Par(int min, int max, bool ascendente)
        {
            if (ascendente)
            {
                for (int i = min; i <= max; i++)
                {
                    if (i % 2 == 0)
                        yield return i;
                }
            }
            else
            {
                for (int i = max; i >= min; i--)
                {
                    if (i % 2 == 0)
                        yield return i;
                }
            }
        }
        public IEnumerable<int> Impar(int min, int max, bool ascendente)
        {
            if (ascendente)
            {
                for (int i = min; i <= max; i++)
                {
                    if (i % 2 != 0)
                        yield return i;
                }
            }
            else
            {
                for (int i = max; i >= min; i--)
                {
                    if (i % 2 != 0)
                        yield return i;
                }
            }
        }

O parâmetro ascendente indica a ordem do retorno. Se definido para true os números serão retornados em ordem crescente, e se for false, em ordem decrescente.

That’s all folks!

C++ & C#(Wrapper): Definir/Pegar o Master Volume do Windows – Windows Vista+

Estava precisando desenvolver alguma forma para definir e pegar o volume da saída de som do Windows no C#/WPF. Obviamente, eu teria que lidar com a API do Windows.

Só que dessa vez, eu resolvi o problema de uma forma diferente. Pensei, a API do Windows foi escrita em C++, eu teria que importar um monte de interfaces, métodos, e estruturas para o C#. Então eu tive uma ideia melhor, escrever os métodos em uma DLL C++ e importa-los no C#. Foi exatamente o que eu fiz, ou quase. Na verdade o código em C++ eu encontrei na web, necessitando apenas uma pequena adaptação, no que acabou sendo meu primeiro projeto no C++. Depois criei o Wrapper (Api que faz a interoperabilidade entre a DLL C++, código nativo, e o .Net Framework, código gerenciado.

No fim das contas, ao invés de ter que importar um monte de interfaces, métodos, e estruturas para o C#, eu precisei importar apenas dois métodos. Aí eu vi vantagem em estudar C++, na verdade eu já vinha pensando em fazer esse tipo de coisa antes, mas nunca tive a real necessidade

Segue o código C++:

#include <mmdeviceapi.h>
#include <endpointvolume.h>
/*
The below code was based on: http://www.codeproject.com/Tips/233484/Change-Master-Volume-in-Visual-Cplusplus
Thanks to the author, Mr. Sayyed Mostafa Hashemi.
*/
extern "C" 
{
	_declspec(dllexport) bool WinVistaSetVolume(_In_ double nVolume, _In_ bool bScalar)
	{
		HRESULT hr = NULL;
		bool decibels = false;
		bool scalar = false;
		double newVolume = nVolume;

		CoInitialize(NULL);
		IMMDeviceEnumerator *deviceEnumerator = NULL;
		hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER,
			__uuidof(IMMDeviceEnumerator), (LPVOID *)&deviceEnumerator);
		IMMDevice *defaultDevice = NULL;

		hr = deviceEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &defaultDevice);
		deviceEnumerator->Release();
		deviceEnumerator = NULL;

		IAudioEndpointVolume *endpointVolume = NULL;
		hr = defaultDevice->Activate(__uuidof(IAudioEndpointVolume),
			CLSCTX_INPROC_SERVER, NULL, (LPVOID *)&endpointVolume);
		defaultDevice->Release();
		defaultDevice = NULL;

		float currentVolume = 0;
		endpointVolume->GetMasterVolumeLevel(&currentVolume);


		hr = endpointVolume->GetMasterVolumeLevelScalar(&currentVolume);

		if (bScalar == false)
		{
			hr = endpointVolume->SetMasterVolumeLevel((float)newVolume, NULL);
		}
		else if (bScalar == true)
		{
			hr = endpointVolume->SetMasterVolumeLevelScalar((float)newVolume, NULL);
		}
		endpointVolume->Release();

		CoUninitialize();
		if (hr == 0x00000000)
			return true;
		else
			return false;
	}
	_declspec(dllexport) bool WinVistaGetVolume(_Out_ double& nVolume, _In_ bool bScalar)
	{
		HRESULT hr = NULL;
		CoInitialize(NULL);
		IMMDeviceEnumerator *deviceEnumerator = NULL;
		hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER,
			__uuidof(IMMDeviceEnumerator), (LPVOID *)&deviceEnumerator);
		IMMDevice *defaultDevice = NULL;

		hr = deviceEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &defaultDevice);
		deviceEnumerator->Release();
		deviceEnumerator = NULL;

		IAudioEndpointVolume *endpointVolume = NULL;
		hr = defaultDevice->Activate(__uuidof(IAudioEndpointVolume),
			CLSCTX_INPROC_SERVER, NULL, (LPVOID *)&endpointVolume);
		defaultDevice->Release();
		defaultDevice = NULL;
		float currentVolume = 0;

		if (bScalar)
			hr = endpointVolume->GetMasterVolumeLevelScalar(&currentVolume);
		else
			hr = endpointVolume->GetMasterVolumeLevel(&currentVolume);
		endpointVolume->Release();

		CoUninitialize();

		nVolume = (double)currentVolume;
		
		if (hr == 0x00000000)
			return true;
		else
			return false;
	}
}

E o Wrapper em C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices;

namespace HL.CSharp.SystemVolume
{
    public static class WinVista
    {
        public static double GetVolume()
        {
            double volume = 0;
            WinVistaGetVolume(ref volume, true);
            return volume;
        }
        public static bool SetVolume(double Volume)
        {
            return WinVistaSetVolume(Volume, true);
        }
        [DllImport("HL.CPP.SystemVolume.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.Cdecl)]
        private static extern bool WinVistaSetVolume(double nVolume, bool bScalar);

        [DllImport("HL.CPP.SystemVolume.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.Cdecl)]
        private static extern bool WinVistaGetVolume(ref double nVolume, bool bScalar);
    }
}

Vou disponibilizar também os arquivos do projeto e as DLLs já compiladas:

HL.CPP.SystemVolume

Espero que possa ser útil.

Array: Instanciar definindo todos os membros para o mesmo valor – C#

Olá pessoal!

Neste post irei mostrar como inicializar um Array, definindo todas as entradas para o mesmo valor padrão.

Por questões de facilidade, nos exemplos eu irei usar um Array do tipo byte (byte[]) com o comprimento de 256 items.

Por padrão, quando se inicializa um array do tipo byte, como no exemplo abaixo, todas as entradas serão definidas para 0.

byte[] b = new byte[256];

Array inicializa default

Porém, e se você precisar inicializar o array para um outro valor que não seja 0?

Existem várias formas! A primeira que irei mostrar é funcional em todas as versões do .Net Framework (1.0 até a atual):

byte[] b = System.Collections.ArrayList.Repeat((byte)32, 256).ToArray(typeof(byte)) as byte[];

32 é o valor padrão a ser utilizado, e 256 vai ser o comprimento do array.

Array inicializa compati

Também é possível fazer isso usando LINQ (.Net Framework 3.5+):

byte[] b = System.Linq.Enumerable.Repeat<byte>(32, 256).ToArray();

Enfim, é algo bem útil em certas ocasiões.

Até a próxima!