Nos dois últimos posts, mostrei como animar uma transição usando código. O primeiro post mostrou como animar a transição usando code behind, criando uma animação em código. O segundo post mostrou o uso de componentes para facilitar estas transições. Embora o uso de componentes seja uma boa alternativa a criar as animações em código, ainda tem algumas desvantagens:

  • É necessário incluir uma referência à dll do componente ou incluir o código do componente no projeto.
  • Está sujeito a bugs – embora muitas pessoas usem estes componentes nada impede que eles tenham bugs. O fato de serem open source e terem seu código disponível pode minimizar isto, mas nem sempre é fácil debugar este código.
  • Pode ficar defasado. Com novas versões do Silverlight e WPF, um componente que não é mantido há muito tempo pode não funcionar nas novas versões

Assim, vamos ver aqui uma nova opção para animar as transições, que não usam código. “Como assim, não usam código?”, você deve estar se perguntando. Sim, o WPF 4 (ou o 3.5, com o WPF Toolkit) e o Silverlight introduziram um novo recurso, que dispensa o uso de código em C# ou VB para animar as transições: os Visual States. Com Visual States, você define qual é o estado de seu controle em diversas situações e transiciona entre eles sem usar código. Tudo é feito com o XAML.

Para este projeto, não usaremos o VisualStudio. A criação de Visual States é muito mais fácil usando o Blend.

Abra o Blend e crie um novo projeto WPF.

Neste projeto, inclua uma linha na Grid principal, na parte de baixo da janela, com 40 pixels de altura e, na segunda linha, coloque um botão com a propriedade Content configurada para o texto Esconde. Na primeira linha da grid, coloque outra grid, com fundo vermelho.

No painel do projeto, escolha a aba States. Ela deve estar vazia.

image

Clique no primeiro botão da barra superior da aba para adicionar um novo grupo de estados. Mude o nome do grupo para EstadosGrid. Clique no segundo botão deste grupo para adicionar um novo estado. Mude seu nome para Aparente. Adicione um novo estado e mude o nome dele para Escondido.

Note que o tempo padrão de transição (mostrado na frente do texto Default Transition) é de 0s

image

Mude este tempo para 1. Mude também o Easing Function para CubicInOut, clicando no segundo botão

image

Olhando a figura acima, você pode notar que estamos em modo de gravação, “gravando” o estado Escondido. Quando selecionamos um estado, todas as alterações que fazemos no layout são atribuídos a este estado. Assim, podemos mudar a aparência de nossos controles apenas mudando de um estado para outro. O estado Aparente é o nosso estado padrão. No estado Escondido iremos esconder a grid. A transição é feita automaticamente quando mudarmos de um estado para outro.

Selecione a grid e mude a propriedade RenderTransform X para –625, a propriedade Opacity para 0 e a propriedade Visibility para Collapsed. Desta maneira, a grid irá para a esquerda, ao mesmo tempo que fica cada vez mais transparente. Nossos estados estão prontos. Poderíamos mudar de estado usando o code behind, colocando o seguinte código no event Click do botão:

private void button_Click(object sender, System.Windows.RoutedEventArgs e) { VisualStateManager.GoToElementState(LayoutRoot, "Escondido", true); }

Mas assim estaríamos na mesma situação do post anterior, onde temos code behind. Além disso, eu prometi que não iríamos colocar código. E promessa é dívida!

O Blend tem um recurso muito interessante para executar ações sem a necessidade de código: Behaviors. Behaviors são ações personalizadas, usadas diretamente nos componentes, sem que seja preciso escrever código para executá-las (na realidade, você precisa escrever código para escrever um behavior mas, uma vez criado, basta arrastá-lo para um componente para ser usado). O Blend venm com diversos behaviors pré definidos. Para usá-los, basta ir na janela do projeto, na aba Assets e selecionar a opção Behaviors.

image

Usaremos o behavior GoToStateAction. Atribuímos este behavior a um componente, dizemos qual é o evento que o ativa e qual é o novo estado que se deve ativar quando o evento foi acionado. Selecione o GoToStateAction e arraste-o para o botão. Note que um GoToStateAction é adicionado ao botão, no inspetor de objetos.

 

image

No editor de propriedades, iremos configurar a ação.

image

O Trigger já está configurado: queremos ativar a action quando o evento Click do botão foi acionado. Falta apenas configurar o estado que queremos selecionar quando o botão for clicado. Para isto, basta configurar a propriedade StateName para Escondido.

image

Nossa aplicação está pronta. Ao executá-la e clicar no botão, ocorre a transição animada, que movimenta a grid para fora. E tudo isso sem uma única linha de código!

Vamos fazer agora uma pequena mudança para dar um pouco mais de funcionalidade à nossa aplicação. Mude a visualização do editor para Split, clicando no terceiro botão de mudança de visualização.

image

Com isso, podemos alterar o código XAML diretamente e alterar o nosso botão. Queremos que ele não seja um botão normal, e sim um ToggleButton. Para isso, altere o componente no XAML, mudando o seu tipo de Button para ToggleButton:

<ToggleButton x:Name="button" Content="Esconde" Grid.Row="1" HorizontalAlignment="Center" VerticalAlignment="Center" Width="65" Height="25"> <i:Interaction.Triggers> <i:EventTrigger EventName="Click"> <ei:GoToStateAction StateName="Escondido"/> </i:EventTrigger> </i:Interaction.Triggers> </ToggleButton>

O ToggleButton pode estar checado ou não. Faremos que quando ele está checado, mostre o estado Escondido e, quando não está checado, mostre o estado Aparente.

Para isso, devemos mudar o evento que ativa o estado Escondido. No inspetor de objetos, selecione o GoToStateAction e mude a propriedade EventName para Checked. Na paleta do projeto, selecione o GoToStateAction e arraste um segundo GoToStateAction para o botão. Configure a propriedade EventName para Unchecked e a propriedade StateName para Aparente. Execute o programa.

Agora temos uma animação para esconder a grid quando o botão é checado e outra para mostrar a grid, quando o botão não está checado. Fácil, não?

Aqui pudemos ver a quantidade de recursos que temos à disposição para criar estados e ativá-los, tudo feito visualmente, sem precisar escrever código. Ainda não terminamos nossa jornada, ainda temos maneiras de animar transições, mas isto é assunto para um outro post. Até lá!

No post anterior vimos como animar uma transição usando código. Como falei, não acho aquela a melhor solução, pois obriga a usar code behind, o que não é de fácil manutenção. Poderíámos refatorar o código, criando uma classe para a animação e usá-la. Isto traria um pouco mais de separação, mas ainda teríamos de usar code behind.

Nesta segunda parte, usaremos um enfoque diferente: o uso de componentes prontos. Podemos usar diversos componentes, como o Kevin Bag-O-Tricks (https://github.com/thinkpixellab/bot), FluidKit (http://fluidkit.com), Silverlight Toolkit (http://silverlight.codeplex.com – só para Silverlight), o Transitionals (http://transitionals.codeplex.com).

Usaremos aqui o Transitionals, para WPF. Se quisermos fazer animações em Silverlight, devemos escolher outro dos componentes acima.

Seu uso é muito simples: após baixar o componente e adicionar uma referência ao projeto para a dll Transitionals.dll, devemos adicionar um componente TransitionElement no local onde queremos a animação, configurar a animação e colocar um conteúdo para o componente. Ao mudar o conteúdo, ocorre a transição selecionada.

Vamos então fazer o nosso projeto de animação. Crie um novo projeto WPF e adicione uma referência a Transitionals.dll. Em seguida, coloque um TransitionElement na grid principal:

<Grid> <Grid.RowDefinitions> <RowDefinition Height="*" /> <RowDefinition Height="40" /> </Grid.RowDefinitions> <transc:TransitionElement x:Name="TransitionBox"> <transc:TransitionElement.Transition> <transt:TranslateTransition StartPoint="1,0" EndPoint="0,0" Duration="0:0:1"/> </transc:TransitionElement.Transition> </transc:TransitionElement> <Button Width="65" Grid.Row="1" Content="Esconde" Margin="5" Click="Button_Click" /> </Grid>

Devemos definir os namespaces para o TransitionElement e para a TranslateTransition na definição da janela:

<Window x:Class="WpfApplication2.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:transc="clr-namespace:Transitionals.Controls;assembly=Transitionals" xmlns:transt="clr-namespace:Transitionals.Transitions;assembly=Transitionals" Title="MainWindow" Height="350" Width="525">

Em seguida, é só colocar um conteúdo no TransitionElement:

<transc:TransitionElement x:Name="TransitionBox"> <transc:TransitionElement.Transition> <transt:TranslateTransition StartPoint="1,0" EndPoint="0,0" Duration="0:0:1"/> </transc:TransitionElement.Transition> <Grid Background="Red" /> </transc:TransitionElement>

O código do botão muda o conteúdo do TrasitionElement e, com isso ativa a transição:

private void Button_Click(object sender, RoutedEventArgs e) { TransitionBox.Content = new Grid() {Background = Brushes.Blue}; }

Desta maneira, o código fica muito mais fácil, só precisamos mudar o conteúdo do elemento. Além disso, o componente Transitionals tem muitos tipos de transições, e podemos configurá-las de diversas maneiras. Por exemplo, o TranslateTrasition tem as propriedades StartPoint e EndPoint, dizendo onde começa e onde termina a transição. Para fazer da esquerda para direita, StartPoint deve ser –1,0 e EndPoint, 0,0. De cima para baixo, StartPoint deve ser 0,-1 e EndPoint, 0,0. Podemos inclusive fazer uma transição diagonal usando os pontos 1,1 e 0,0.

Eliminando o Code Behind

Uma das coisas que podem ser melhoradas aqui é a eliminação do code behind, usando o padrão de projeto MVVM. Para isso, usaremos o framework MVVM Light, que pode ser obtido gratuitamente em http://galasoft.ch, ou ainda instalado diretamente no projeto usando o Nuget, uma extensão para o Visual Studio que facilita o download e instalação de bibliotecas e ferramentas no Visual Studio. Se você ainda não baixou o Nuget, vá imediatamente para http://nuget.org e baixe-o. Vale a pena!

Uma vez instalado o Nuget, clique com o botão direito em References, no Solution Explorer e  selecione “Manage Nuget Packages”. Tecle “mvvm” na caixa de pesquisa e instale o pacote MVVM Light:

image

Isto instala o MVVM Light em nosso projeto, adiciona as referências necessárias e cria uma pasta ViewModel, com dois arquivos, MainViewModel.cs e ViewModelLocator.cs. MainViewModel.cs é o ViewModel referente à janela princiapl e ViewModelLocator é um localizador de ViewModel, referente à View.

Em MainViewModel.cs, colocamos uma propriedade, do tipo ViewModelBase, que conterá os ViewModel referente à View do conteúdo atual:

private ViewModelBase conteudo; public ViewModelBase Conteudo { get { return conteudo; } set { conteudo = value; RaisePropertyChanged("Conteudo"); } }

Criaremos em seguida dois ViewModels, que serão referentes à nossas Views. Os dois ViewModels são muito semelhantes e têm apenas uma propriedade:

public class ViewModelA : ViewModelBase { private string texto; public string Texto { get { return texto; } set { texto = value; RaisePropertyChanged("Texto"); } } } public class ViewModelB : ViewModelBase { private string texto; public string Texto { get { return texto; } set { texto = value; RaisePropertyChanged("Texto"); } } }

Em seguida, crie no Solution Explorer um diretório chamado View e coloque lá dois UserControls, com apenas uma Grid com um TextBlock:

<UserControl x:Class="WpfApplication2.View.ViewA" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" mc:Ignorable="d" d:DesignHeight="300" d:DesignWidth="300"> <Grid Background="Red"> <TextBlock Text="{Binding Texto}" FontSize="36" /> </Grid> </UserControl>

Para eliminar o code behind, precisamos fazer um data binding da propriedade Content do TransitionElement com a propriedade conteúdo do ViewModel:

<transc:TransitionElement x:Name="TransitionBox" Content="{Binding Conteudo}"> <transc:TransitionElement.Transition> <transt:TranslateTransition StartPoint="1,0" EndPoint="0,0" Duration="0:0:1"/> </transc:TransitionElement.Transition> </transc:TransitionElement>

e eliminar o clique do botão, substituindo-o por um Command:

<Button Width="65" Grid.Row="1" Content="Esconde" Margin="5" Command="{Binding EscondeCommand}" />

O command é definido no MainViewModel:

private ICommand escondeCommand; public ICommand EscondeCommand { get { return escondeCommand ?? (escondeCommand = new RelayCommand(MudaConteudo)); } } private void MudaConteudo() { Conteudo = conteudo is ViewModelA ? (ViewModelBase)new ViewModelB() { Texto = "ViewModel B"} : (ViewModelBase)new ViewModelA() {Texto = " ViewModel A"}; }

Finalmente, devemos definir o DataContext para a View principal:

<Window x:Class="WpfApplication2.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:transc="clr-namespace:Transitionals.Controls;assembly=Transitionals" xmlns:transt="clr-namespace:Transitionals.Transitions;assembly=Transitionals" Title="MainWindow" Height="350" Width="525" DataContext="{Binding Source={StaticResource Locator}, Path=Main}">

Ao executar o programa, temos algo como mostrado na figura abaixo:

image

A view não é mostrada, apenas o nome da classe do conteúdo. Isso era de se esperar, pois a propriedade Conteúdo é do tipo ViewModelBase e sua representação é o método ToString(). Poderíamos ter colocado a View como sendo o conteúdo, mas isto vai contra o padrão MVVM: o ViewModel não deve conhecer a View. Uma solução para mostrar a View a partir do ViewModel é usar um recurso disponível no WPF ou no Silverlight 5: Data Templates implícitos. Em um Data Template implicito, não explicitamos a Key, apenas dizemos qual é o DataType e, com isso o WPF/Silverlight renderezam este DataTemplate toda vez que um conteúdo for do tipo referente a ele.

Definimos então os DataTemplates na seção Resources da janela:

<Window.Resources> <DataTemplate DataType="{x:Type ViewModel:ViewModelA}" > <View:ViewA /> </DataTemplate> <DataTemplate DataType="{x:Type ViewModel:ViewModelB}" > <View:ViewB /> </DataTemplate> </Window.Resources>

Agora, ao executar, temos a transição entre as duas views, sem o uso de code behind.

 

image

Conclusões

Usando componentes de animação de transições, temos a possibilidade de fazer transições muito sofisticadas, de maneira muito simples bastando mudar o conteúdo do componente.

Em seguida, vimos como tirar o código do code behind, colocando-o em um ViewModel, o que facilita na manutenção e permite maior testabilidade do código. Como bonus, vimos como usar implicit templates para ligar uma view a um viewmodel sem usar código. Este recurso está disponível apenas no WPF e no Silverlight 5. Embora você possa achar que não vale a pena (eliminamos apenas uma linha de código e incluímos dois viemodels, duas views, um novo componente MVVM, entre outros), minha intenção aqui foi mostrar como usar outros recursos, como a introdução do MVVM ao invés do code behind e como usar novos recursos, como o DataTemplate implícito. Numa aplicação maior, que requer maiores cuidados, estas mudanças se justificam plenamente.

Mas estas não são as únicas maneiras de se fazer transições de controles. Nos próximos artigos, veremos quais são as outras maneiras. Até lá!

Quando eu vi uma pergunta de um usuário nos forums do MSDN sobre animação de um user control para dar o efeito de saída ao clicar um botão, eu pensei que esta seria uma excelente oportunidade de criar uma série de posts aqui no blog, mostrando diversas maneiras de fazê-lo.

Apesar de colocar as alternativas aqui, algumas podem não ser tão boas: este post onde eu ponho animação no code behind, apesar de ser fácil de implementar, tem algumas desvantagens:

  • O código da animação é posto no code behind, uma técnica que eu não gosto. Eu nao acho que o padrão MVVM deva ter zero code behind, mas eu não gosto de por código lá, a menos que seja indispensável e estritamente relacionado com a view.
  • Não é design-friendly – se o designer quer mudar a animação, o código deve ser alterado.
  • Não é portável – se você quer criar a mesma animação em outros lugares, o código deve ser copiado ou refatorado para ser acessado de outros lugares.
  • Não é fácil de manipular – tudo é feito em código. Quaisquer mudanças, como a duração da animação deve ser alterado em código.

Temos o seguinte problema: temos um controle na janela e queremos escondê-lo quando o botão é clicado, usando uma animação, como vemos abaixo:

image_thumbimage_thumb1image_thumb3image_thumb4

Para fazer isso, devemos criar uma animação para o controle, do tipo RenderTransform e animá-la. Podemos fazer tudo em código desta maneira: no clique do botão, criamos a transformação, adicionamos ao controle e animamos ela:

 

private void Button_Click(object sender, RoutedEventArgs e) { // create the transformation and add it to the control var translate = new TranslateTransform(0, 0); gridLogin.RenderTransform = translate; // create the animation and start it var da = new DoubleAnimation(0, -ActualWidth, new Duration(TimeSpan.FromMilliseconds(1000))); translate.BeginAnimation(TranslateTransform.XProperty, da); }

Este código tem muitos inconvenientes:

  • Ele só pode ser aplicado ao nosso controle. Para adicioná-lo a outro controle, devemos copiar o código.
  • A duração da animação é 1 segundo – a duração é fixa.
  • Somente anima da direita para a esquerda.

Nesta primeira fase, refatoraremos o código para deixá-lo mais genérico:

public enum AnimationType { Right, Left, Up, Down } private void Button_Click(object sender, RoutedEventArgs e) { AnimateControl(gridLogin, TimeSpan.FromMilliseconds(1000), AnimationType.Left); } private void AnimateControl(UIElement control, TimeSpan duration, AnimationType type) { double xEnd = 0; double yEnd = 0; if (type == AnimationType.Left) xEnd = -ActualWidth; else if (tipo == AnimationType.Right) xEnd = ActualWidth; else if (tipo == AnimationType.Up) yEnd = -ActualHeight; else if (tipo == AnimationType.Down) yEnd = ActualHeight; // create the transformation and add it to the control var translate = new TranslateTransform(0, 0); control.RenderTransform = translate; // create the animation and start it if (tipo == AnimationType.Left || tipo == AnimationType.Right) { var da = new DoubleAnimation(0, xEnd, new Duration(duration)); translate.BeginAnimation(TranslateTransform.XProperty, da); } else { var da = new DoubleAnimation(0, yEnd, new Duration(duration)); translate.BeginAnimation(TranslateTransform.YProperty, da); } }

Apesar do código ser maior, ele é mais genérico e permite ser reutilizado. Podemos usar qualquer controle, configurar a deuração e a direção da animação. Ainda não é o idela, mas é melhor que o código anterior, não reutilizável. Nos próximos posts veremos outras maneiras de fazer isso. Até lá!

When I saw a question from an user in the MSDN forums about animating an user control to give the exit effect while clicking a button, I thought this would be an excelent opportunity to create a series of posts here in the blog, showing many ways to do it.

Although I will put the alternatives here, some can be not so good: this post, putting animation on the code behind, although easy to implement, has these disadvantages:

  • The animation code is put on the code behind, a technique I don’t like. I don’t think that the MVVM pattern should have zero code behind, but I don’t like to put code behind, unless is indispensable and strictly related to the view.
  • It’s not design friendly – if the designer wants to change the animation, the code should be changed.
  • It’s not portable – if you want to create the same animation on other places, the code must be copied or refactored to be accessed from other places.
  • It’s not easy to manipulate – everything is on the code. Any changes, like the duration of the animation must be changed in code.

We have the following problem: we have a control in the window and we want to hide it when the button is clicked with an animation, like we see below:

imageimageimageimage

To do that, we should create a transformation for the control, of type RenderTransform and animate it. We can do everything in code this way: at the button click, we create the transform, add it to the control and animate it:

private void Button_Click(object sender, RoutedEventArgs e) { // create the transformation and add it to the control var translate = new TranslateTransform(0, 0); gridLogin.RenderTransform = translate; // create the animation and start it var da = new DoubleAnimation(0, -ActualWidth, new Duration(TimeSpan.FromMilliseconds(1000))); translate.BeginAnimation(TranslateTransform.XProperty, da); }

This code has many shortcomings:

  • It can only be applied to our control. To add it to another control, we must copy the code.
  • The animation duration is 1 second – the duration is fixed.
  • It only animates from right to left.

In this first phase, we can refactor the code and leave it more generic:

public enum AnimationType { Right, Left, Up, Down } private void Button_Click(object sender, RoutedEventArgs e) { AnimateControl(gridLogin, TimeSpan.FromMilliseconds(1000), AnimationType.Left); } private void AnimateControl(UIElement control, TimeSpan duration, AnimationType type) { double xEnd = 0; double yEnd = 0; if (type == AnimationType.Left) xEnd = -ActualWidth; else if (tipo == AnimationType.Right) xEnd = ActualWidth; else if (tipo == AnimationType.Up) yEnd = -ActualHeight; else if (tipo == AnimationType.Down) yEnd = ActualHeight; // create the transformation and add it to the control var translate = new TranslateTransform(0, 0); control.RenderTransform = translate; // create the animation and start it if (tipo == AnimationType.Left || tipo == AnimationType.Right) { var da = new DoubleAnimation(0, xEnd, new Duration(duration)); translate.BeginAnimation(TranslateTransform.XProperty, da); } else { var da = new DoubleAnimation(0, yEnd, new Duration(duration)); translate.BeginAnimation(TranslateTransform.YProperty, da); } }

Although the code is larger, it is more generic and allows to be reutilized. We can use any control, set the duration and the animation direction. It still isn’t ideal, but it’s better than last code, non reutilizable. On the next posts, we will see other ways to do it. See you then!

O Silverlight 5 beta preview foi lançado no Mix 2011 (http://live.visitmix.com), com uma série de recursos novos:

  • XAML Debugging (você pode setar um breakpoint no XAML e examinar o binding)
  • Data Templates implícitos, onde você pode usar um mesmo data template para um determinado tipo, sem explicitar o seu uso
  • Suporte para duplo-clique (precisa falar mais?)
  • Gráficos 3D e 2D acelerados pela GPU
  • Efeitos de som de baixa latência e suporte a WAV
  • Suporte a múltiplos displays
  • Se você quer saber mais, veja os vídeos em http://www.silverlight.net/getstarted/silverlight-5-beta/

    Se você quer começar a trabalhar com ele, baixe as seguintes ferramentas (coloboração do @fernandomartin – Caverna):

    Agora, mãos à obra!

    My new WPF videos were just published in MSDN Brazil (in portuguese). Although they are geared towards the Windows Application Developer certification (70-511), it’s worth taking a look at them, because they contain may useful tips. The videos are:

  • Asynchronous Processes – With the popularization of multicore processors, it’s very important that our applications use this resource. This video will show how to desing the program in order to create processes that run in parallel, thus using the multiple processors in the machine
  • Using Drag & Drop in WPF – One of the resources for data interchange is Drag & Drop. This video will show how to develop an application that allows dragging and dropping
  • Globalization and Localization in .net – When your program ust run in many countries, you must design it in a way it can change its interface easily to adapt to the new country. This video will show how to design a localized application
  • Integration between WPF and Windows Forms – The introduction of WPF doesn’t mean that Winforms is obsolete. This video shows how you can embed WPF controls in WinForms programs and vice-versa and how these two platforms interact between them
  • Security in .net applications – When you develop an application, you should know what the OS allows in terms of security, or the program will fail when it tries to execute an operation not allowed. This video shows the Windows security resources and how you must design your programs to work fine with security restrictions
  • Application Settings in .net – This video shows the application settings in .net and how to use them
  • Meus vídeos de WPF acabaram de ser publicados no MSDN Brasil. Embora eles sejam voltados para a certificação Windows Application Developer (70-511), vale a pena dar uma olhada neles, pois eles contém muitas dicas interessantes. São eles:

    • Processos assíncronos – Com a popularização de processadores multi-core, torna-se imperativo que nossos programas façam uso deste recurso, tanto para melhorar sua performance como para evitar o bloqueio da interface enquanto o programa executa um outro processamento. Este vídeo irá mostrar técnicas para executar o processamento em paralelo, mostrando como sincronizar o processamento com alterações na interface
    • Usando Drag & Drop em WPF – Um dos recursos do Windows que permitem o intercâmbio de informações é o "Arrastar e Soltar" (Drag & Drop). Você arrasta uma informação de um lugar para outro e, "magicamente", a informação aparece no destino. Este vídeo irá mostrar como implementar o Drag & Drop em uma mesma aplicação e entre o Explorer e uma aplicação
    • Globalização e Localização em .net – Quando você quer que sua aplicação seja executada em muitos países, você deve projetá-lo de maneira a permitir que a interface mude conforme o país onde está send executado: idioma, configurações regionais, etc. Este vídeo irá mostrar dicas de como projetar uma interface globalizada e como localizar sua aplicação, para que o idioma da interface mude conforme selecionado.
    • Integração entre WPF e Windows Forms – A introdução do WPF não significa a completa obsolescência dos programas WinForms. Você pode continuar a desenvolver os programas Winforms e incluir partes em WPF, bem como criar programas WPF que hospedam partes em WinForms. Este vídeo irá mostrar como fazer esta integração entre as duas plataformas e como elas podem interagir entre si.
    • Segurança em aplicações .net – Quando você desenvolve uma aplicação, deve ter em mente o que o sistema operacional permite e o que ele não permite, em relação à segurança, senão ele falhará quando executar uma operação não permitida. Este vídeo irá mostrar os recursos de segurança do Windows e como você deve projetar seus programas para que eles comportem-se como projetados em tempo de execução
    • Application Settings em .net – Quando você desenvolve uma aplicação, deve ter em mente o que o sistema operacional permite e o que ele não permite, em relação à segurança, senão ele falhará quando executar uma operação não permitida. Este vídeo irá mostrar os recursos de segurança do Windows e como você deve projetar seus programas para que eles comportem-se como projetados em tempo de execução

    I see that there is a lot of interest in developing business applications with Silverlight, although there are not many books about that subject. The book Pro Business Applications with Silverlight 4, from Chris Anderson, Apress Publishing, brings Silverlight learning under a different concept the business applications development.

    Usually, the Silverlight books bring the platform concepts under a difficulty sequence, but with no concerns with the real world application development. This book concern is the creation of applications: in chapter 5, just after showing an introduction to Silverlight and to XAML and showing an introduction to the navigation framework, it shows RIA Services for data access with Entity Framework.

    In the sequence, the author talks about list generation and data entry forms, following with application security, an unusual topic in books on this subject. The following chapters are on Data Binding, custom control creation and MVVM pattern, a subject almost mandatory in the WPF/Silverlight development.

    The last chapters are about reporting and printing, Out of Browser applications and interaction with the operating system and application deployment. The book is well written and touches many subjects not touched by other books, although they are very important for the business application development.

    The book is focused in using RIA Services, and it lets aside other technologies for data access, like WCF, REST or JSon and there is barely nothing about network access, needed when you want to upload a file to the server or download a file. In the printing chapter, the author showed very little about the printing technology in Silverlight 4, spending a lot of pages to show how you can display PDF files generated on the server. Although this is a viable way to show reports, I don’t think it’s the best one, because we need to resort to tricks like use an IFrame over the Silverlight control, with several problems: it doesn’t work Out of Browser (we need to use the WebBrowser in this case), you cannot show a ChildWindow while it’s visible (the IFrame stays on top of the Silverlight control and hides the ChildWindow) and needs Acrobat Reader installed in the user’s machine. It would be better that, in this chapter, the author had written a mini report generator to aid report generation using Silverlight technology.

    On the other side, the book shows Silverlight under a different aspect, geared towards business applications, what, in my opinion is the real Silverlight vocation. The RIA Services explanation is very complete, and encompasses from the basics through validation, metadata and the use of a presentation layer, that eases the use with the MVVM pattern and the use of authentication.

    In summary, the book is very good for those who want to develop a business application with Silverlight using RIA Services, it contains a lot of information and, as and added bonus, its text contains links to tools, controls or articles that will aid the Silverlight development.

    Vejo que há um grande interesse no desenvolvimento de aplicações comerciais com Silverlight, embora não haja muita bibliografia sobre o assunto. O livro Pro Business Applications with Silverlight 4, do Chris Anderson, editora Apress, traz o aprendizado de Silverlight sob um conceito diferente, o desenvolvimento de aplicações de negócios.

    Normalmente os livros de Silverlight trazem os conceitos da plataforma em uma sequência lógica de dificuldade, mas sem uma preocupação com o desenvolvimento de aplicações para o mundo real. Já este livro preocupa-se com a criação de aplicações: logo no capítulo 5, após mostrar uma introdução ao Silverlight e ao XAML e mostrar o framework de navegação, ele mostra o WCF RIA Services para acesso a dados com o Entity Framework.

    Em seguida, o autor fala de geração de listas e de formulários de entrada de dados, seguindo com o tópico de segurança da aplicação, tópico raramente visto nos livros do assunto. Os capítulos seguintes são sobre Data Binding e a criação de controles personalizados, seguido pelo pattern MVVM, um tema que agora é quase obrigatório no desenvolvimento WPF/Silverlight.

    Os últimos capítulos são sobre impressão e relatórios, Out of Browser e interação com o sistema operacional e distribuição de aplicações. O livro é bem escrito e aborda diversos tópicos que normalmente não são tocados pelos livros tradicionais, embora sejam fundamentais para o desenvolvimento de aplicações de negócios.

    O livro é muito centrado em RIA Services, deixando de lado outras tecnologias de acesso a dados, como serviços WCF, REST, Json, além de tocar pouco no acesso a rede, indispensável quando se quer fazer upload de arquivos ou baixar dados do servidor. No capítulo de impressão, o autor mostrou muito pouco a tecnologia de impressão do Silverlight 4, gastando muitas páginas para mostrar como podemos mostrar arquivos PDF gerados no servidor. Embora esta seja uma forma razoável de mostrar relatórios, não considero a melhor, pois devemos recorrer a truques como usar um IFrame sobre o controle Silverlight, com diversos problemas: não funciona OutOfBrowser (devemos usar o WebBrowser, neste caso), não permite mostrar uma ChildWindow quando ativo (ele fica sobre o controle Silverlight e esconde a ChildWindow) e necessita que o Acrobat Reader esteja instalado. Seria muito melhor que, neste capítulo, o autor tivesse escrito um mini gerador de relatórios para auxiliar a criação de relatórios com a tecnologia do Silverlight.

    Por outro lado, o livro aborda o Silverlight com um enfoque diferente, voltado para aplicações de negócios, o que, a meu ver, é a verdadeira vocação do Silverlight. A explicação do RIA Services é bem completa, compreendendo desde o básico, até a validação, metadata e o uso de uma camada de apresentação, o que facilita o uso com o pattern MVVM, até o uso de autenticação.

    Em resumo, o livro é muito bom para quem quer desenvolver uma aplicação de negócios com Silverlight usando o RIA Services, ele contém muita informação e, como bônus, seu texto contém links para ferramentas, controles ou artigos que irão auxiliar o desenvolvimento de programas com Silverlight.

    Se você quer saber como desenvolver para multitouch em Windows 7, não pode perder o webcast que irei fazer no dia 3/12/2009, às 12:00.

    Lá irei mostrar como desenvolver aplicações que usam o recurso do multitouch, usando .net Framework 3.5 e também mostrando como programar multitouch com o WPF4, que vem por aí. Ah, e se você não tem um hardware multitouch, não tem problema: eu irei mostrar como contornar isso, usando dois mouses.

    A inscrição é gratuita e pode ser feita em https://msevents.microsoft.com/CUI/WebCastEventDetails.aspx?EventID=1032433821&EventCategory=4&culture=pt-BR&CountryCode=BR

    Até lá

    Bruno