Meus Projetos

Nesta categoria serão postados assuntos referentes à meus projetos pessoais.

.Net Portable: API de conversão de moedas com WebService do Yahoo – +100 Moedas – C#

Pode parecer tarefa fácil, mas não é. O fato é que, encontrar um bom WebService, que atenda às suas necessidades, que seja gratuito e simples de usar é algo um pouco complicado. Por isso, escrevo este post!

Recentemente eu descobri que o Yahoo possui um WebService de financias, e que o mesmo disponibiliza uma tabela para conversão de moedas, com as principais moedas do mundo. Para obter os dados do WebService é necessário, apenas, fazer um Request e pegar o Response do link abaixo:

http://finance.yahoo.com/webservice/v1/symbols/allcurrencies/quote

Ele vai retornar um arquivo XML contendo os valores das moedas, e isso de forma atualizada.

Tendo isso em mãos, já é possível criar um ótima API para conversão de valores monetários. Mas eu fui além. Baseado na página web abaixo, eu criei um pequeno banco de dados que reúne as principais informações de cada moeda, como por exemplo: País, Código, Simbolo, Imagem da Bandeira do País, e o Nome da moeda.

Currency Symbols – All existing currency symbols

E eu fui ainda mais além!! A API foi projetada para funcionar offline também, pois é possível salvar a tabela de conversão e carrega-la quando não quiser baixar o da internet.

E para fechar com chave de gold: A API é multiplataforma. É uma Portable Class Library, que pode ser referenciada em programas desktop, aplicativos Windows Phone e Windows Store, Silverlight, e um outro que eu esqueci.

Ah, e sem falar que as classes foram projetadas para funcionarem em harmonia com o XAML. De fato, você pode fazer Data Binding e fazer conversões monetárias sem usar praticamente nenhum código. Um exemplo (WPF):

Yahoo Currency Demo

E graças à forma como foi projetado, a DLL garante conversão em tempo real! Isso porque a tabela de conversão é baixada e armazenada de uma única vez na memória. E o banco de dados que possue as informações de cada moeda foi incluído dentro da API.

Algo muito útil, em sistemas financeiros e demais da categoria…

Bom, segue o projeto completo da API, do aplicativo demo, e da ferramenta que eu criei para montar o base de dados:

HL.Yahoo.Currency

Espero que possa ser útil à vocês!

Grande abraço.

Kernel: Obtendo os processos que estão usando um arquivo – C#

Pode parecer tarefa fácil, mas não é. O fato é que, obter o processo ou os processos que estão usando um arquivo/pasta é uma tarefa com uma pitada de complexidade em C++ e realmente complexa em C#/VB devido às diversas importações de funções necessárias.

No entanto, existe um utilitário gratuito que lhe permite descobrir essas coisas de forma super simples. Falo do Handle:

O Handle é um Console Application que faz todo o trabalho árduo; Você apenas especifica o caminho para um arquivo ou pasta e ele lhe retorna os processos que o estão usando.

Sendo assim, vou mostrar como usar este utilitário. Primeiro, obviamente faça o Download dele no link acima. Descompacte o arquivo zip e copie o arquivo Handle.exe para a pasta da sua aplicação. Então o poderá colocar em funcionamento o código abaixo:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Text;
using System.Diagnostics;
using System.Text.RegularExpressions;
using System.Runtime.InteropServices;

namespace System.IO
{
    public static class Kernel
    {
        /// <summary>
        /// Returns all the processes locking a file/folder
        /// </summary>
        /// <param name="path">The full path to file/folder to inspect</param>
        /// <returns>A IEnumerable containing all the processes locking the file/folder</returns>
        public static IEnumerable<Process> GetProcessesLockingFile(string path)
        {
            string currentDirectory = System.IO.Path.GetDirectoryName(new Uri(
                System.Reflection.Assembly.GetExecutingAssembly().CodeBase).LocalPath);
            string handlePath = currentDirectory + "\\handle.exe";
            ProcessStartInfo handleStarting = new ProcessStartInfo(handlePath);
            handleStarting.UseShellExecute = false;
            handleStarting.RedirectStandardOutput = true;
            handleStarting.Arguments = "\"" + path + "\" /accepteula";
            handleStarting.Verb = "runas";
            handleStarting.CreateNoWindow = true;
            Process handleProcess = Process.Start(handleStarting);
            handleProcess.WaitForExit();

            string outputTool = handleProcess.StandardOutput.ReadToEnd();

            string matchPattern = @"(?<=\s+pid:\s+)\b(\d+)\b(?=\s+)";
            foreach (Match match in Regex.Matches(outputTool, matchPattern))
            {
                Process pr = null;
                try
                {
                    pr = Process.GetProcessById(int.Parse(match.Value));
                }
                catch { }
                if (pr != null)
                    yield return pr;
            }
            yield break;
        }
    }
}

Esse código, basicamente, executa o utilitário e faz a leitura do resultado convertendo-o em um Enumerable de processos que estão usando o arquivo/pasta.

Mas, devo salientar algo muito importante:

O fato de um programa abrir um arquivo não quer dizer que ele esteja usando este arquivo. Se você abrir uma música no Windows Media Player ele irá carregar o conteúdo do arquivo para a memória, fechar este arquivo e então reproduzir. No fim das contas o código não irá detectar nenhum programa usando este arquivo de música, pois, realmente, nenhum está utilizando.

O mesmo pode acontecer com qualquer arquivo, pasta e software…

E, de brinde, vou disponibilizar para download um projeto de um programa pequeno para inspecionar arquivos e pastas para saber se estão sendo usados:

File Locker.zip

That’s all folks!

Fonte: c# – How do I find out which process is locking a file using .NET? – Stack Overflow

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.

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.

Icon Pro Beta: Download completo com código fonte e material de apoio

Fala galera!!

Meu projeto Icon Pro está quase completo.

Certeza que ainda tem bugs ocultos, e ainda não implementei todas as funcionalidades, mas o principal ele já faz, que é criar ícones a partir de imagens PNG/BMP.

O projeto foi desenvolvido no Visual Studio 2013:

Icon Pro Beta.zip – 4MB

Acompanha todo o material de apoio que eu usei para desenvolver a API, código fonte completo, e os executáveis compilados.

Espero que possa ser útil à vocês…