WPF - Formatação e conversão de dados - II

Estamos continuando a primeira parte deste artigo onde apresentei os recursos necessários para realizar a formatação e conversão de valores no WPF. Vamos agora a um exemplo prático.

Neste exemplo eu vou criar uma aplicação WPF onde usando a vinculação de dados irei exibir as informações formatadas em um controle WPF.

Para tornar o exemplo mais simples eu não vou usar um banco de dados; ao invés disso vou usar uma classe , atribuir valores a ela e usá-la como um recurso em minha aplicação WPF onde estarei implementando a formatação usando a interface IValueConverter.

Lembre-se que para isso devemos seguir o roteiro abaixo:

Eu vou usar o Visual Basic 2008 Express Edition para criar o projeto WPF, então abra o seu VB 2008 Express e selecione no menu File -> New Project (Arquivo->Novo Projeto)

Agora vamos criar uma classe no projeto para implementar o conversor usando a interface IValueConverter. No menu Project-> Add Class (Projeto->Adiconar Classe) defina a classe ConversorWPF.vb com o seguinte código:

Public Class ConversorValor
    Implements IValueConverter

    Public Function Convert(ByVal value As Object, ByVal targetType As System.Type, ByVal parameter As Object, _ 
ByVal culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.Convert
        Dim formatString As String = TryCast(parameter, String)
        If formatString IsNot Nothing Then
            Return String.Format(culture, formatString, value)
        Else
            Return value.ToString()
        End If
    End Function

    Public Function ConvertBack(ByVal value As Object, ByVal targetType As System.Type, ByVal parameter As Object, _ 
ByVal culture As System.Globalization.CultureInfo) As Object Implements System.Windows.Data.IValueConverter.ConvertBack
        'não vou usar este recurso
        Return Nothing
    End Function
End Class

A classe ConversorValor implementa a interface IValueConverter e define os métodos Convert() que no nosso exemplo esta efetuando a formatação de uma string conforme o parâmetro informado tomando como base a cultura local e o método ConvertBack() que não estamos usando neste exemplo.

Agora vamos incluir uma outra classe chamada RegistroVendas.vb onde estamos definindo algumas propriedades que serão usadas como fonte de dados para nossa aplicação. Segue abaixo o código da classe :

Public Class RegistroVendas

    Private _horaDaVenda As DateTime
    Private _valorDaVenda As Decimal
    Private _impostoDaVenda As [Single]
    Private _id As Integer

    Public Sub New()

    End Sub

    Public Sub New(ByVal vendasid As Integer, ByVal horaVenda As DateTime, _ 
ByVal valorVenda As Decimal, ByVal impostoPercentual As [Single])
        _id = vendasid
        _horaDaVenda = horaVenda
        _valorDaVenda = valorVenda
        _impostoDaVenda = impostoPercentual
    End Sub

    Public Property HoraDaVenda() As DateTime
        Get
            Return _horaDaVenda
        End Get
        Set(ByVal value As DateTime)
            _horaDaVenda = value
        End Set
    End Property

    Public Property Valor() As Decimal
        Get
            Return _valorDaVenda
        End Get
        Set(ByVal value As Decimal)
            _valorDaVenda = value
        End Set
    End Property

    Public Property ImpostoDaVendaPercentual() As [Single]
        Get
            Return _impostoDaVenda
        End Get
        Set(ByVal value As [Single])
            _impostoDaVenda = value
        End Set
    End Property

    Public Property ID() As Integer
        Get
            Return _id
        End Get
        Set(ByVal value As Integer)
            _id = value
        End Set
    End Property
End Class

Na nossa aplicação WPF criada temos o arquivo Window1.xaml e seu code-behind Window1.xaml.vb vamos definir o código para atribuir valores no arquivo code-behind de forma a termos as informações para formatar e exibir na aplicação WPF. Abaixo temos o código que faz isso:

  Public Sub windowLoaded(ByVal sender As Object, ByVal e As RoutedEventArgs)
        'defina uma instância do objeto 
        Dim vendas As ObjectDataProvider = TryCast(Me.FindResource("vendas"), ObjectDataProvider)
        'verifica se a instância é válida e atribui valores a instância da classe RegistroVendas
        If vendas IsNot Nothing Then
            Dim vendasDados As New ObservableCollection(Of RegistroVendas)()
            vendasDados.Add(New RegistroVendas(1001, System.DateTime.Now.Subtract(New TimeSpan(1, 1, 1)), 123.4D, 0.145F))
            vendasDados.Add(New RegistroVendas(1002, System.DateTime.Now.Subtract(New TimeSpan(1, 0, 0)), 42D, 0.12F))
            vendasDados.Add(New RegistroVendas(1003, System.DateTime.Now.Subtract(New TimeSpan(0, 58, 0)), 10.99D, 0.18F))
            'atribui os valores a instância criada
            vendas.ObjectInstance = vendasDados
        End If
    End Sub

No WPF os controles possuem tanto o evento Loaded como o evento Initialized. Esses eventos praticamente ocorrem ao mesmo tempo, mas possuem algumas diferenças. No nosso exemplo estamos usando o evento windowLoaded.

O evento Loaded é disparado quando um elemento é não apenas inicializado mas também renderizado. A motivação para para usar este evento é um cenário onde desejamos realizar a inicialização na carga da aplicação.

Agora já podemos definir o código na aplicação WPF para acessar e exibir as informações formatadas usando as classes que definimos acima.

A visão que devemos ter do arquivo Window1.xaml no descritor exibindo as duas visualizações é a seguinte:

Vejamos como deve ficar o código definindo no arquivo Window1.xaml:

<Window x:Class="Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:ConversorWPF"
    Title="Formatando com WPF" Height="185" Width="421"
    Loaded="windowLoaded">

No arquivo de recursos temos:

<Window.Resources>
        <ObjectDataProvider x:Key="vendas" />
        <local:ConversorValor x:Key="formatter" />
    </Window.Resources>

Aqui estamos efetuando as formatações usando o conversor de valor :

 <ListBox DataContext="{StaticResource vendas}" ItemsSource="{Binding}" Height="138" Width="394">
        <ListBox.ItemTemplate>
            <DataTemplate>
                <Border BorderBrush="#feca00" BorderThickness="2" 
                CornerRadius="3" Padding="5" Margin="2">
                    <StackPanel Orientation="Horizontal">

            <!-- formatando o Id -->
            <TextBlock Text="{Binding Path=ID, 
              Converter={StaticResource formatter}, 
              ConverterParameter='Venda No:\{0\} '}" /> 

            <!-- formatando o valor -->
            <TextBlock Text="{Binding Path=Valor, 
              Converter={StaticResource formatter}, 
              ConverterParameter=' \{0:C\}'}" 
              FontWeight="Bold" /> 

            <!-- formatando o percentual Imposto -->
            <TextBlock Text="{Binding Path=ImpostoDaVendaPercentual, 
              Converter={StaticResource formatter}, 
              ConverterParameter=' (\{0:P\} Vendas Imposto)'}" /> 

            <!-- formatando a data -->
            <TextBlock Text="{Binding Path=HoraDaVenda, 
              Converter={StaticResource formatter}, 
              ConverterParameter=' \{0:dd-MMM-yyyy hh:mm\}'}" /> 

          </StackPanel>
                </Border>
            </DataTemplate>
        </ListBox.ItemTemplate>
    </ListBox>

Executando o projeto iremos obter a visualização dos valores formatados conforme abaixo:

Eu sei é apenas WPF, mas eu gosto...

Referências:

José Carlos Macoratti