XAML

Posts que contém referência à XAML

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

.Net: Pegar a versão do aplicativo

Certas vezes temos a necessidade de pegar a versão atual do aplicativo (*.exe ou *.dll) para mostrar ao usuário, ou fazer alguma tarefa que envolva a versão.

Para fazer isso, use o código abaixo:

C#:

        public string AppVersion
        {
            get { return System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(); }
        }

VB.NET:

        Public ReadOnly Property AppVersion() As String
        	Get
        		Return System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString()
        	End Get
        End Property

Se você está usando o padrão MVVM no seu projeto, basta colar a propriedade acima na ViewModel, e utilizar DataBinding na View.

Até a próxima.

WPF: API’s para desenvolver aplicativos com interface Moderna (Metro, Windows 8)

Se você está querendo desenvolver aplicativos no WPF com uma interface mais limpa e moderna como a apresentada no Windows 8 vai ficar feliz ao saber que existem alguns projetos gratuitos (e open-source) disponíveis na internet que torna factível a criação de apps assim. Eis os projetos:

Elysium

Modern UI for WPF

MahApps.Metro

Existem, também, alguns sets de styles para serem usados no WPF (e no Silverlight):

FREE Metro Light and Dark Themes for WPF and Silverlight Microsoft Controls – Brian Lagunas’ XAML Blog

Visual Studio 2012 Metro Styles for WPF – CodeProject

E por aí vai, se você buscar na internet com certeza irá encontrar mais styles para usar nos seus projetos.

Paletta de Cores do Windows 8

Pois bem, o Windows 8 introduziu uma nova interface, mas simples e limpa chamada anteriormente de Metro UI (Não utilize este nome, pertence à uma empresa lá de não sei aonde…) com uma nova Tela Inicial que possui Tiles e etc. Esta tela inicial possui a opção do usuário definir uma cor de fundo, e baseada nesta escolha, é selecionada uma cor para os Tiles.

Como um desenvolvedor atento à atualidade, você irá querer criar aplicativos que se adaptem bem à essa nova interface, e para isso nada melhor que ter em mãos a palleta de cores do Windows 8.

Para isso visite o artigo Jason N. Gaylord | Windows 8 Color Palette.