.NET CORE: API para conversão de moedas – Yahoo Currency

Yahoo Currency

Salve galera. Na verdade, eu já havia feito uma postagem sobre isso no passado. Mas decidi reescrever algumas partes do código e atualizar o projeto (de Portable Class Library) para uma Class Library(.NET CORE 2) que é multi plataforma.

O funcionamento é o mesmo, a diferença principal fica pelo suporte à assincronicidade permitindo que você use métodos async e use await.

Esse é mais um projeto livre e open source que estou disponibilizando no meu GITHUB.

Os códigos estão sumarizados(documentados) e acompanham um Demo em WPF.

Abaixo uma pequena porção de código:

        ///

        /// O código abaixo é um exemplo simples de como usar os webservices de moeda de forma assíncrona
        /// 

        /// 
        public static async Task AsyncExample()
        {
            HL.YahooCurrency.Currency currency = new HL.YahooCurrency.Currency();

            //VOCÊ DEVE INCLUIR A LINHA ABAIXO OBRIGATORIAMENTE
            //É de extrema importância que você use o método WaitLoad() para aguardar a inicialização desse objeto, que ocorre de forma assíncrona
            await currency.WaitLoad();

            //Seleciona a moeda de origem
            currency.SourceUnit = currency.Units.ElementAt(0);
            //Seleciona a moeda de destino, para a qual se quer converter um valor
            currency.OutputUnit = currency.Units.ElementAt(1);
            //Dá um valor para conversão
            currency.SourceValue = 2.32f;
            //Mostra o valor convertido para a moeda de destino
            System.Diagnostics.Debug.WriteLine(currency.OutputValue);
        }

        ///

        /// O código abaixo é um exemplo simples de como usar os webservices de moeda de forma síncrona(normal)
        /// 

        public static void SynchronousExample()
        {
            HL.YahooCurrency.Currency currency = new HL.YahooCurrency.Currency();

            //VOCÊ DEVE INCLUIR A LINHA ABAIXO OBRIGATORIAMENTE
            //É de extrema importância que você use o método WaitLoad() para aguardar a inicialização desse objeto, que ocorre de forma assíncrona
            //Ao invés de usar await, você pode usar o método .Wait() em contextos síncronos.
            //Dessa forma, a thread em execução irá ser bloqueada por algumas frações de tempo, até que o carregamento dos dados seja feito completamente
            //Normalmente, isso deverá tomar cerca de 1 segundo, mas em conexões de internet mais lentas, pode levar até 6. Ou seja, a interface de usuário irá ficar bloqueada durante esse tempo
            currency.WaitLoad().Wait();

            //Seleciona a moeda de origem
            currency.SourceUnit = currency.Units.ElementAt(0);
            //Seleciona a moeda de destino, para a qual se quer converter um valor
            currency.OutputUnit = currency.Units.ElementAt(1);
            //Dá um valor para conversão
            currency.SourceValue = 2.32f;
            //Mostra o valor convertido para a moeda de destino
            System.Diagnostics.Debug.WriteLine(currency.OutputValue);
        }

Gostou?

Detalhe, esse objeto YahooCurrency pode ser usado diretamente no XAML, pois ele implementa a interface INotifyPropertyChanged, permitindo que seja feito Data Bindings. Quando usando em XAML ele irá operar, por padrão, de forma assíncrona. Você deverá utilizar a propriedade IsLoading para exibir alguma mensagem de carregamento para o usuário (enquanto os dados são baixados) e/ou desabilitar os controles da interface.

Isso tudo que mencionei acima está implementado no exemplo em WPF que acompanha a API.

Chega de papo, aí está o link:

GitHub – HerbertLausmann/HL.YahooCurrency: .NET C# Multiplatform wrapper for Yahoo Currency Web Service. Convert between over 100 different currencies.

Lembrando, que como ela é escrita sob os padrões do .NET STANDARD 2, você poderá usa-la no Xamarin, Mono e etc.

Um abraço!

Anúncios

.NET CORE: API de previsão do tempo – Yahoo Weather

Surprise modafocas!

Queridos colegas, amigos, parceiros, compatriotas, conterrâneos, irmãos!

Nesse post venho apresentar-vos a minha API (escrita em C#/.NET CORE2) para previsão do tempo.

Ela é, basicamente, uma ponte em C# para o WebService de clima do Yahoo. Com ela você consegue obter muitas informações sobre o clima numa dada região, como por exemplo:

  1. Horário do nascer e pôr do sol
  2. Umidade e pressão atmosférica
  3. A sensação térmica, direção e velocidade do vento
  4. As temperaturas máxima e mínima previstas para a previsão
  5. Previsão do dia atual e dos 9 dias à frente

O webservice do yahoo, originalmente, retorna apenas os resultados em inglês. Mas eu adicionei suporte à globalização e assim ela emite os textos da previsão (Ex: Parcialmente Nublado, Chuvoso) em português.

Vale destacar que, sendo uma api escrita para o .NET CORE, ela pode ser usada em múltiplas plataformas, incluindo o XAMARIN e o MONO.

Ela também implementa a interface INotifyPropertyChanged podendo ser usada tanto em código (C#/VB.NET, whatever) quanto no XAML com Data Binding.

Saliento, também, que implementei suporte assíncrono. Você pode fazer umas coisinhas assim:

            YahooWeather weather = await YahooWeather.LoadAsync("New York city");
            Console.WriteLine(weather.Condition.Text);

Bacana né?

Isso tudo disponibilizado gratuitamente e com código aberto no GITHUB:

GitHub – HerbertLausmann/HL.YahooWeather: A .NET C# Multiplatform wrapper for the Yahoo Weather API

Divirta-se!
That’s all folks!

Criando um ícone personalizado para seu Aplicativo Windows – DICA

Icon Pro

Criando um ícone a partir de um arquivo SVG

GitHub – HerbertLausmann/HL.IconPro

Fala galera, beleza?!

Neste post eu venho lhes (re)apresentar minha ferramenta open source para criação de ícones para o Windows.

Como vocês podem ver acima, no GIF, é bem simples!! Basta selecionar uma imagem (PNG ou SVG), selecionar os tamanhos que irão para dentro do ícone, e pronto! Só salvar!

(mais…)

.NET: Medir força de senhas – C#

Password Strength.gif

Visualizando em tempo real a força da senha

Salve internautas! Tudo tranquilo?!

Então, depois de quase um ano após a última postagem, eis que eu retorno da cinzas, e mais zika dos códigos ainda haha! Aproveitando que entrei de férias (permanentes) agora posso me dedicar a uma coisa que gosto muito: Programação!

E nada melhor que elaborar uma postagem didática e útil, pois eu amo compartilhar conhecimento!

Chega de papo, and let’s go!

Já precisou alguma vez medir a força de uma senha? Bom, eu nunca, mas como precisava de um passatempo, resolvi estudar uma maneira de como fazer isso.

(mais…)

Windows Explorer: Abrir Explorer com arquivo/pasta selecionado – C#

Falaí galera!!!

Fiquei um tempinho sem postar.. Tá ok, um tempão!

Mas eu não ia deixar o blog fazer aniversário de inatividade, então resolvi postar alguma coisa..

O assunto de hoje é o Windows Explorer. Vou mostrar como abrir o Windows Explorer selecionando algum arquivo ou pasta. Um exemplo de uso muito bom é um gerenciador de downloads que muitos já devem ter experimentado. Quando termina o download, normalmente ele lhe dá a opção de Abrir Pasta, que vai abrir a pasta onde está o arquivo que você baixou. E, de quebra, ele seleciona o arquivo para facilitar a localização do mesmo pelo usuário final.

Executar essa tarefa em código é bem simples. Eis um exemplo:

        public void OpenAndSelectPath(string path)
        {
            bool isfile = System.IO.File.Exists(path);
            if (isfile)
            {
                string argument = @"/select, " + path;
                System.Diagnostics.Process.Start("explorer.exe", argument);
            }
            else
            {
                bool isfolder = System.IO.Directory.Exists(path);
                if(isfolder)
                {
                    string argument = @"/select, " + path;
                    System.Diagnostics.Process.Start("explorer.exe", argument);
                }
            }
        }

Essas poucas linhas acima farão este trabalho. Basicamente, o que fazemos é rodar o processo explorer.exe (Corresponder ao Windows Explorer) informando como argumento a instrução -select e o caminho do arquivo/pasta a ser selecionado. Segue um breve exemplo de uso:

       OpenAndSelectPath(@"H:\Biblioteca\Documentos\arquivo.txt");

Simples e prático! 🙂

Espero voltar em breve com novos posts!

.Net: Classe para pesquisa de arquivos assíncrona e com múltiplos filtros – C#

Olá Pessoal,

Esse é o meu último dia de férias do trabalho (choro eterno), e acabei escrevendo um código para uma contribuição no MSDN que achei que seria interessante publicar.

É uma classe para pesquisa de arquivos assíncrona e que permite o uso de múltiplos filtros (de forma simultânea, na qual só serão retornados os resultados que satisfizerem a todos os filtros, de forma normal, onde serão retornados os arquivos que atendem a qualquer um dos filtros, mesmo que só um).

É um código simples, mas que na pressa, vale um Ctrl + C Ctrl + V. Enfim, segue o código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.IO;

namespace HL.IO
{
    public class FileSearch
    {
        private string[] _Filters;
        public string[] Filters
        {
            get { return _Filters; }
            set { _Filters = value; }
        }

        private SearchOptions _SearchOption;
        public SearchOptions SearchOption
        {
            get { return _SearchOption; }
            set { _SearchOption = value; }
        }

        public FileSearch(SearchOptions SearchOption, params string[] Filters)
        {
            _Filters = Filters;
            _SearchOption = SearchOption;
        }
        public FileSearch()
        {
            _SearchOption = SearchOptions.AllDirectories | SearchOptions.MatchAllFilters;
            _Filters = null;
        }
        public IEnumerable<string> Search(string RootFolder)
        {
            if (_SearchOption.HasFlag(SearchOptions.AllDirectories))
            {
                IEnumerable<string> result = Directory.EnumerateFiles(RootFolder, "*.*", System.IO.SearchOption.AllDirectories);
                if (_SearchOption.HasFlag(SearchOptions.MatchAllFilters))
                    return result.Where(s => Path.GetFileName(s).ContainsAll(_Filters,
                        _SearchOption.HasFlag(SearchOptions.CaseSensitive)));
                else
                    return result.Where(s => Path.GetFileName(s).ContainsAny(_Filters,
                        _SearchOption.HasFlag(SearchOptions.CaseSensitive)));
            }
            else
            {
                IEnumerable<string> result = Directory.EnumerateFiles(RootFolder, "*.*", System.IO.SearchOption.TopDirectoryOnly);
                if (_SearchOption.HasFlag(SearchOptions.MatchAllFilters))
                    return result.Where(s => Path.GetFileName(s).ContainsAll(_Filters,
                        _SearchOption.HasFlag(SearchOptions.CaseSensitive)));
                else
                    return result.Where(s => Path.GetFileName(s).ContainsAny(_Filters,
                        _SearchOption.HasFlag(SearchOptions.CaseSensitive)));
            }
        }

        #region Async
        public void AsyncSearch(string RootFolder)
        {
            SynchronizationContext context = SynchronizationContext.Current;
            if (context == null)
            {
                context = new System.Threading.SynchronizationContext();
            }
            Thread th = new Thread(new ThreadStart(() =>
            {
                IEnumerable<string> result = Search(RootFolder);
                context.Send(new SendOrPostCallback((object state) =>
                {
                    OnAsyncSearchCompleted((IEnumerable<string>)state);
                }), result);
            }));
            th.IsBackground = false;
            th.SetApartmentState(ApartmentState.STA);
            th.Start();
        }
        public event AsyncSearchCompletedEventHandler AsyncSearchCompleted;
        protected virtual void OnAsyncSearchCompleted(IEnumerable<string> Result)
        {
            if (AsyncSearchCompleted != null)
            {
                AsyncSearchCompleted(this, new AsyncSearchCompletedEventArgs(Result));
            }
        }
        #endregion
    }

    public delegate void AsyncSearchCompletedEventHandler(object sender, AsyncSearchCompletedEventArgs e);

    public class AsyncSearchCompletedEventArgs
    {
        private IEnumerable<string> _result;
        public IEnumerable<string> Result
        {
            get { return _result; }
        }
        public AsyncSearchCompletedEventArgs(IEnumerable<string> Result)
        {
            _result = Result;
        }
    }
    public enum SearchOptions : int
    {
        /// <summary>
        /// The search engine will seach only on top level of the given root folder.
        /// </summary>
        TopDirectoryOnly = 1,
        /// <summary>
        /// The search engine will search in all the directory tree starting from the given root folder
        /// </summary>
        AllDirectories = 2,
        /// <summary>
        /// The search engine will use case sensitive approach.
        /// </summary>
        CaseSensitive = 4,
        /// <summary>
        /// If set, the search engine will return only the results matching all the filters.
        /// </summary>
        MatchAllFilters = 8
    };
    public static class StringExtensions
    {
        public static bool ContainsAll(this string Source, string[] strs, bool CaseSensitive)
        {
            foreach (string str in strs)
            {
                if (CaseSensitive)
                {
                    if (!Source.Contains(str)) return false;
                }
                else
                {
                    if (!Source.ToLower().Contains(str.ToLower())) return false;
                }
            }
            return true;
        }

        public static bool ContainsAny(this string Source, string[] strs, bool CaseSensitive)
        {
            foreach (string str in strs)
            {
                if (CaseSensitive)
                {
                    if (Source.Contains(str)) return true;
                }
                else
                {
                    if (Source.ToLower().Contains(str.ToLower())) return true;
                }
            }
            return false;
        }
    }
}

Mostrarei também um pequeno exemplo:

        private void btnSearch_Click(object sender, EventArgs e)
        {
            FolderBrowserDialog dialog = new FolderBrowserDialog();
            dialog.ShowDialog();
            FileSearch searcher = new FileSearch(SearchOptions.AllDirectories, ".png", ".bmp", ".jpeg");
            searcher.AsyncSearchCompleted += searcher_AsyncSearchCompleted;
            searcher.AsyncSearch(dialog.SelectedPath);
        }

        private void searcher_AsyncSearchCompleted(object sender, AsyncSearchCompletedEventArgs e)
        {
            listBox1.Items.Clear();
            listBox1.Items.AddRange(e.Result.ToArray());
        }

No exemplo acima a classe FileSearch é usada para encontrar todos os arquivos PNG, BMP e JPEG da pasta informada. Isso é bem básico, mas dá para fazer bastante coisa. Incluir uma palavra chave que o nome do arquivo deve conter também é uma opção. E o melhor de tudo, assíncrono. Não irá congelar a interface de usuário enquanto realiza a busca.

That’s all folks!!!

Win Forms: Teclas de atalho globais – C#

Fala aí galera. Tudo certo?!

Já faz um certo tempo que não posto aqui no blog, e também um tempinho que eu não contribuo no MSDN.

Então, receba esse post!!!

Já ouviu falar das teclas de atalho globais, ou Global Hot Keys? Se não segue uma explicação curta:

Teclas de atalho globais são combinações de teclas, sempre usando um modificador (Ctrl ou/e Alt ou/e Shift), que executam ações na sua aplicação, mesmo ela estando minimizada ou oculta! Por isso o Globais.

Baseado em .net – Set global hotkeys using C# – Stack Overflow, eu fiz alguns pequenos ajustes, para conseguir o código final abaixo. Uma classe que permite registrar ou remover Global Hot Keys para sua aplicação:

/*
O código foi obtido na thread abaixo, e modificado por mim, Herbert Lausmann:
http://stackoverflow.com/questions/2450373/set-global-hotkeys-using-c-sharp
Créditos ao criador, AaronLS.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace System.Windows.Forms
{
    public sealed class KeyboardHotKeys : IDisposable
    {
        #region Class Code
        // Registers a hot key with Windows.
        [DllImport("user32.dll")]
        private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
        // Unregisters the hot key with Windows.
        [DllImport("user32.dll")]
        private static extern bool UnregisterHotKey(IntPtr hWnd, int id);

        /// <summary>
        /// Represents the window that is used internally to get the messages.
        /// </summary>
        private class Window : NativeWindow, IDisposable
        {
            private static int WM_HOTKEY = 0x0312;

            public Window()
            {
                // create the handle for the window.
                this.CreateHandle(new CreateParams());
            }

            /// <summary>
            /// Overridden to get the notifications.
            /// </summary>
            /// <param name="m"></param>
            protected override void WndProc(ref Message m)
            {
                base.WndProc(ref m);

                // check if we got a hot key pressed.
                if (m.Msg == WM_HOTKEY)
                {
                    // get the keys.
                    Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
                    ModifierKeys modifier = (ModifierKeys)((int)m.LParam & 0xFFFF);

                    // invoke the event to notify the parent.
                    if (KeyPressed != null)
                        KeyPressed(this, new KeyPressedEventArgs(modifier, key));
                }
            }

            public event EventHandler<KeyPressedEventArgs> KeyPressed;

            #region IDisposable Members

            public void Dispose()
            {
                this.DestroyHandle();
            }

            #endregion
        }

        private Window _window = new Window();
        private int _currentId;

        public KeyboardHotKeys()
        {
            // register the event of the inner native window.
            _window.KeyPressed += delegate(object sender, KeyPressedEventArgs args)
            {
                if (KeyPressed != null)
                    KeyPressed(this, args);
            };
        }

        /// <summary>
        /// Registers a hot key in the system.
        /// </summary>
        /// <param name="modifier">The modifiers that are associated with the hot key.</param>
        /// <param name="key">The key itself that is associated with the hot key.</param>
        public void RegisterHotKey(ModifierKeys modifier, Keys key)
        {
            // increment the counter.
            _currentId = _currentId + 1;

            // register the hot key.
            if (!RegisterHotKey(_window.Handle, _currentId, (uint)modifier, (uint)key))
                throw new InvalidOperationException("Couldn’t register the hot key.");
        }

        /// <summary>
        /// A hot key has been pressed.
        /// </summary>
        public event EventHandler<KeyPressedEventArgs> KeyPressed;

        #region IDisposable Members

        public void Dispose()
        {
            // unregister all the registered hot keys.
            for (int i = _currentId; i > 0; i--)
            {
                UnregisterHotKey(_window.Handle, i);
            }

            // dispose the inner native window.
            _window.Dispose();
        }

        #endregion

        #region Others

        /// <summary>
        /// Event Args for the event that is fired after the hot key has been pressed.
        /// </summary>
        public class KeyPressedEventArgs : EventArgs
        {
            private ModifierKeys _modifier;
            private Keys _key;

            internal KeyPressedEventArgs(ModifierKeys modifier, Keys key)
            {
                _modifier = modifier;
                _key = key;
            }

            public ModifierKeys Modifier
            {
                get { return _modifier; }
            }

            public Keys Key
            {
                get { return _key; }
            }
        }

        /// <summary>
        /// The enumeration of possible modifiers.
        /// </summary>
        [Flags]
        public enum ModifierKeys : uint
        {
            Alt = 1,
            Control = 2,
            Shift = 4,
            Win = 8
        }
        #endregion
        #endregion
        #region Singleton
        private static KeyboardHotKeys _Current;
        public static KeyboardHotKeys Current
        {
            get
            {
                if (_Current == null)
                    _Current = new KeyboardHotKeys();
                return _Current;
            }
        }
        #endregion
    }
}

Dessa forma, você poderá criar teclas de atalho globais para sua aplicação, de uma maneira extremamente simples. Exemplo abaixo:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace Global_Hot_Keys
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            KeyboardHotKeys.Current.KeyPressed += Current_KeyPressed;
            KeyboardHotKeys.Current.RegisterHotKey(KeyboardHotKeys.ModifierKeys.Control | KeyboardHotKeys.ModifierKeys.Alt, Keys.T);
        }

        void Current_KeyPressed(object sender, KeyboardHotKeys.KeyPressedEventArgs e)
        {
            if (e.Modifier == (KeyboardHotKeys.ModifierKeys.Control | KeyboardHotKeys.ModifierKeys.Alt))
            {
                if (e.Key == Keys.T)
                {
                    this.WindowState = FormWindowState.Normal;
                    MessageBox.Show("Você pressionou o atalho Ctrl + Alt + T !!!!!!!!!!!!!!!!!!");
                }
            }
        }
    }
}

Espero que possa ser útil à alguém!