XAML

Posts que contém referência à XAML

MVVM Starter Pack – Iniciando no MVVM – C#

Introdução

Fala pessoal, tudo bom?

Nesse post irei falar um pouco sobre o padrão de projetos chamado MVVM (Model – View – ViewModel) usado principalmente em aplicações XAML (WPF, UWP, Xamarin e etc).

Saliento, que a intenção aqui não é desenvolver um curso, ou um material completo sobre o assunto. Existem inúmeras fontes sobre. Se trata de um manual básico para a implementação desse padrão para pessoas que já possuem um conhecimento, ainda que básico, sobre o XAML e programação em geral.

Embora o projeto de exemplo que iremos desenvolver e eu disponibilizarei ao final tenha sido escrito para o WPF (Windows Presentation Foundation), os conceitos, classes e técnicas que abordarei neste post são como se fossem um Starter Pack para o MVVM. Independente de quem seja você ou qual seja o segmento do sistema/software/aplicativo ou plataforma (WPF, UWP, Xamaring…) que você pretende desenvolver usando MVVM, você irá, com toda certeza, usar a grande maioria do conteúdo que vou apresentar.

Então, fique tranquilo and here we go!

Conceitos

Para começar, vamos tentar entender o porquê de implementar um padrão de projeto.

(mais…)

Anúncios

.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!

.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…)

WPF: Aplicativo de instância única

No Wpf não existe a opção (nas propriedades do aplicativo) para configurar o app como Single Instance (Instância única, ou seja, só será mantido um por vez em execução).

Mas isso não é difícil de implementar. Segue o código do arquivo App.xaml.cs:

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.Windows;

namespace Meu_App
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {

        protected override void OnStartup(StartupEventArgs e)
        {
            if (IsAppAlreadyRunning())
            {
                MessageBox.Show("O aplicativo já está em execução!", "Já está em execução", MessageBoxButton.OK, MessageBoxImage.Warning);
                Process.GetCurrentProcess().Kill();
            }
            base.OnStartup(e);
        }

        private static bool IsAppAlreadyRunning()
        {

            Process currentProcess = Process.GetCurrentProcess();

            if (Process.GetProcessesByName(currentProcess.ProcessName).Any(p => p.Id != currentProcess.Id && !p.HasExited))
            {
                return true;
            }

            return false;

        }

    }
}

Problema resolvido! Como mostrado, dessa forma é possível exibir uma MessageBox ao usuário informando que o aplicativo já se encontra em execução.

😀

MVVM: Uma ObservableCollection assícrona

Quando estamos programando usando o Padrão MVVM, pode ser que nós precisemos uma coleção multi thread, que possa ser alterada de uma thread diferente da thread da UI.

Para resolver este problema o Thomas Levesque’s desenvolveu uma solução e postou no seu blog.

Eis o código:

using System.Threading;

public class AsyncObservableCollection<T> : ObservableCollection<T>
{
    private SynchronizationContext _synchronizationContext = SynchronizationContext.Current;

    public AsyncObservableCollection()
    {
    }

    public AsyncObservableCollection(IEnumerable<T> list)
        : base(list)
    {
    }

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        if (SynchronizationContext.Current == _synchronizationContext)
        {
            // Execute the CollectionChanged event on the current thread
            RaiseCollectionChanged(e);
        }
        else
        {
            // Raises the CollectionChanged event on the creator thread
            _synchronizationContext.Send(RaiseCollectionChanged, e);
        }
    }

    private void RaiseCollectionChanged(object param)
    {
        // We are in the creator thread, call the base implementation directly
        base.OnCollectionChanged((NotifyCollectionChangedEventArgs)param);
    }

    protected override void OnPropertyChanged(PropertyChangedEventArgs e)
    {
        if (SynchronizationContext.Current == _synchronizationContext)
        {
            // Execute the PropertyChanged event on the current thread
            RaisePropertyChanged(e);
        }
        else
        {
            // Raises the PropertyChanged event on the creator thread
            _synchronizationContext.Send(RaisePropertyChanged, e);
        }
    }

    private void RaisePropertyChanged(object param)
    {
        // We are in the creator thread, call the base implementation directly
        base.OnPropertyChanged((PropertyChangedEventArgs)param);
    }
}

Algo sem dúvida de grande utilidade.

Link do post original (em inglês): [WPF] Binding to an asynchronous collection »  Thomas Levesque’s .NET blog