Nossa empresa está passando por várias mudanças e nas próximas semanas teremos algumas novidades, mas ainda não é esta a razão deste post. Este post é sobre os próximos cursos na Egenial que começam na semana que vem.

No ano passado nossa parceria com a Egenial se estreitou um pouco mais já que a empresa está voltando suas atenções em massa para a comunidade de software Brasileira. Eu (Daniel) acabei sendo convidado para dar uma mão nessa empreitada.

Nos últimos dias tivemos o mega sucesso que foi o RubyMasters, com mais de 270 inscritos e com 12horas de palestra (que também teremos um post a parte). Agora a novidade é que na semana que vem teremos 3 cursos iniciando e as matrículas ainda estão abertas.

Ruby on Rails

Ruby on Rails do Básico ao Avançado comigo como instrutor. Essa é a minha 12 turma na Egenial e a minha 8 só em Ruby/Rails. Ao longo dos últimos anos fui refinando os exemplos deste curso e acho que chegamos no ponto perfeito. São 22 horas de aula onde passamos desde o básico de Ruby e vamos construindo uma aplicativo real em Rails. O aplicativo é tão próximo de um projeto real que eu mesmo uso como referência várias vezes no meu desenvolvimento diário em Rails 3.0.

Neste curso eu tento cobrir tudo que é fundamental para o cotidiano de um Railer. Veja a grade detalhada no site: http://www.egenial.com.br/cursorails

GIT

Git revolucionou o mercado de desenvolvimento opensource e comercial. Chega a ser impossível pensar como era o desenvolvimento com equipe remota ou em projetos opensource antes do GIT. É o tipo de ferramenta que é praticamente impossível contestar seu valor mesmo trabalhando sozinho e sem equipe nenhuma.

Uma das coisas que mais me motiva em continuar envolvido com a comunidade Rails é que é um local onde as coisas novas sempre acontecem muito rápido e isso foi bem marcante com GIT. Boas práticas surgem e se tornam leis na comunidade Rails e GIT é uma dessas leis.

Sem exceção, todos os projetos opensource são versionados com GIT e a grande maioria dos projetos privados também. Isso ocorre por uma única razão: GIT é fantástico.

Uma tecnologia com dezenas de benefícios como sua organização descentralizada incrível para trabalho em equipes, um modelo de armazenamento que reduz drasticamente o tamanho dos repositórios e sua simplicidade que o torna acessível para qualquer pessoa.

Por essas razão a Egenial tem tentado levantar um curso de GIT realmente prático e aprofundado tem bastante tempo. Finalmente conseguimos. Em Março, Arthur Zapparoli vai ministrar um curso de 16h ensinando desde o básico da ferramenta até os detalhes mais profundos como Cherry Pick, Rebase, Object Model, Bisect, Gitosis e muito mais.

Essa é a sua chance de dominar o GIT: http://www.egenial.com.br/git

FlashPlataform – Flex4

Outro curso que também começa na semana que vem é o FlashPlataform Flex4. Um curso totalmente reformulado para cobrir as novas ferramentas criadas pela Adobe e o mais legal que o instrutor será Fábio Vedovelli. Figurinha carimbada do mundo Flex e com uma excelente didática.

Ultimamente tenho participado muito pouco da comunidade Flex o que não indica que ainda não utilizo e utilizarei estas ferramentas se for necessário. É preciso ser pragmático e para muito objetivos Flash/Flex ainda são imbatíveis e são as melhores soluções do mercado.

Soluções como o próprio TreinaTom ainda são impossíveis de serem implementadas da forma correta sem essas tecnologias. Jogos, interatividade que envolve gráficos 2D/3D de forma compatível com todos os browsers, multimídia, compatibilidade com API de escrita e leitura de arquivos pelo browser, desenvolvimento desktop usando o mesmo código web e muitas outras vantagens que só a Plataforma Flash consegue atender hoje em dia.

Se você precisa dessas soluções então esse curso é o que faltava para complementar o seu toolkit.

Não perca tempo e conheça: http://www.egenial.com.br/flashplatformweb

Twitter!

Para o pessoal que ficou curioso com o primeiro post sobre o Spring Roo aqui vai mais um post sobre esse assunto.

O que é Spring Roo?

Como a própria documentação do Spring Roo fala, Roo é uma ferramenta fácil e produtiva para construir Enterprise Applications com Java. Com Roo você não precisa aprender uma nova linguagem ou uma nova plataforma, você simplesmente programa em Java. Tudo que você precisa fazer é iniciar o Roo e deixar ele rodando enquanto você programa. Você pode interagir com Roo por linha de comando, mas na maior parte do tempo você apenas vai programar na sua IDE de preferencia. Enquanto você faz alterações no seu projeto Roo determina o que você esta tentando fazer e se encarrega disso para você.

Outra coisa importante sobre Roo é que ele não é usado quando seu projeto esta rodando em produção. Ou seja, você não vai encontrar nenhum jar do Roo no classpath ou Annotation compilada junto com sua classe. Desta forma você pode parar de usar Roo a qualquer momento do seu projeto.

Como instalar Spring Roo?

Antes de qualquer coisa precisamos garantir algumas dependências:

1 – Java 5 ou 6

2 – Maven 2.0.0 ou mais recente

Com as dependências resolvidas podemos instalar Roo com os seguintes passos:

1 – Fazer o download do Spring Roo em http://www.springsource.org/download

2 – Descompacte o arquivo Zip em um diretório de sua escolha, esse diretório será chamado de %ROO_HOME

3 – Se você usa Windows adiciona %ROO_HOMEbin na variável de ambiente %PATH%. Se você utiliza Linux ou Apple crie um link simbólico usando o comando ln -s $ROO_HOME/bin/roo.sh /usr/bin/roo

4 – Verifique se a Roo foi instalado corretamente, para isso abra o terminal e digite os comando “roo quit”:

(Opcional)

Para trabalhar com Roo é recomendado utilizar SpringSource Tool Suite (STS), uma ferramenta free que usa como base o Eclipse IDE e que tem varias features para trabalhar com Roo, mas você também pode trabalhar com a IDE de sua escolha. Neste e nos próximos posts eu vou utilizar a ferramenta STS.

Visão geral

Em sua atual versão Roo foca em Enterprise application escritas em Java utilizando banco de dados relacional, JPA para persistencia de dados, Spring FrameWork para injeção de dependência e controle de transação, JUnit para testes unitários, Maven para configuração e build e Spring MVC para camada de apresentação.

Outra característica do Spring Roo é que ele não adiciona camadas desnecessárias ao projeto. Normalmente uma aplicação tradicional é composta de uma camada com os DAO’s, uma camada com Serviços, uma camada de Domínio e uma camada de Controle. Já com Spring Roo você vai ter apenas uma camada web e uma camada de entidade (similar a camada de domínio). Porém uma camada de serviço pode ser adicionada se sua aplicação exigir.

Para as próximas releases Spring Roo pretende estender seu suporte para Cloud como Cloud Foundry, Amazon Web Services e Google App Engine. Também pretende dar suporte para Google Web ToolKit (GWT) e Flex.

Agora vamos iniciar nosso primeiro projeto utilizando Spring Roo

O nome “Pensamento Lean” nasceu nos anos 90 com o lançamento do best seller The Machine That Changed the World : The Story of Lean Production.  Os princípios de demanda puxada, just-in-time, qualidade total, melhoria contínua e flexibilidade aplicados na indústria japonesa, mais precisamente na Toyota e conhecidos como Toyota Way inspiraram também a indústria de software e fez surgir a abordagem do Lean Software Development

O Lean Software Development provê uma série de princípios sobre a aplicação de um conjunto de técnicas oriundas da indústria e aplicadas em desenvolvimento de software. Esses princípios foram amplamente adotados na manufatura japonesa onde vieram a ser conhecidos como “Lean Production“.

Nesse contexto, Mary e Tom Poppendieck identificaram sete princípios fundamentais denominados “Lean Principles” e mostraram como eles podem ser aplicados em abordagens de desenvolvimento de software ágil.  Ao longo dos princípios, eles introduziram também e vinte e dois “thinking tools” para traduzir cada princípio em práticas ágeis, em particular eles apresentaram um toolkit para gerentes, lideres técnicos e gerentes de tecnologia que esperam adicionar valor ao invés de criarem barreiras para suas equipes de projetos, como os a seguir:

• Melhoria contínua em direção à excelência: desenvolvimento de software é como um exercício de descoberta.
• Gerenciando incertezas: “decidir o mais tardio possível” para adicionar mudanças dentro do sistema.
• Reduzindo o fluxo de valor: desenvolvimento rápido, feedback, e melhorias contínua.
• Dê autonomia ao time e ao indivíduo sem coordenação e comando-controle.
• Software com qualidade: promovendo coerência, usabilidade, alta coesão, manutenabilidade e adaptabilidade.

Princípio 1: Elimine o Desperdício

Elimine qualquer coisa que não agrega valor ao produto e que não são percebidos pelo cliente. No pensamento Lean, o conceito de desperdício é um grande obstáculo. Se um programador implementa mais funcionalidades do que o necessário de imediato, isso é um desperdício.  Se a equipe produz documentação de análise apenas para estar em concordância com o processo, isso é um desperdício. Se o time entrega funcionalidades incompletas, isso é um desperdício. O ideal é perceber o que os clientes precisam para então fazer ou desenvolver e entregar exatamente o que eles querem, o mais rápido possível. Qualquer outra coisa que fica que não satisfaça as necessidades do cliente é um desperdício.

Princípio 2: Amplifique o Aprendizado

Desenvolvimento é um exercício de descoberta, enquanto produção é um exercício de redução de variações, e por essa razão, aprender a abordagem de desenvolvimento resultam em práticas que são bastante diferentes do que aprender abordagens de práticas de produção.

Desenvolvimento é como fazer uma nova receita, enquanto produção é como fazer um prato. Receitas são formuladas a partir da experiência de chefes de cozinha. Desenvolver uma receita é um processo de descoberta, onde o chefe utilizando de toda sua experiência e dos ingredientes a sua disposição faz iterações, experimentações, até encontrar a melhor combinação de ingrediente para o melhor sabor. Não se espera que os chefes obtenham uma receita perfeita na primeira tentativa; espera-se produzir diversas variações como parte do processo de aprendizagem. Desenvolvimento de software é concebido de forma melhor com um processo de aprendizado similar ao de criar uma nova receita. A melhor abordagem para melhorar o ambiente de desenvolvimento de software é pelo conhecimento amplificado, em um espiral de criação do conhecimento.

Princípio 3: Decida o Mais Tarde Possível

Práticas de desenvolvimento que assegurem a tomada de decisão tardia são mais eficazes em domínios que envolvem incertezas. Decidir o mais tarde possível significa manter suas opções aberta o maior tempo possível. O principal conceito deste princípio é diminuir as incertezas retardando as decisões até que possam serem feitas com base em acontecimentos mais firmes, previsíveis e conhecidos. Decisões tardias tendem a ser mais acertadas porque as melhores decisões são feitas baseadas em fatos, e não em suposições ou especulações. A principal estratégia de atrasar as decisões em um desenvolvimento de um sistema complexo é construí-lo com a capacidade de suportar mudanças.

Princípio 4: Entregue o Mais Rápido Possível

Sem entregas rápidas é impossível haver decisões tardias durante o desenvolvimento. Sem entregas rápidas não haverá feedbacks confiáveis no curto prazo.  No desenvolvimento o ciclo de descoberta é fundamental para a aprendizagem: estórias, implementação, feedback e melhorias. Quanto menor esse ciclo, mais pode ser aprendido.

Uma vez que os clientes decidam o que querem, seu objetivo deve ser para criar esse valor tão rapidamente quanto possível. Entregas rápidas garante que o cliente vai ter o que ele precisa hoje, e não o que ele precisa amanhã.

Em uma organização madura em desenvolvimento de software, tudo isso acontece em um fluxo rápido em resposta a uma necessidade dos clientes.

Princípio 5: Dê autonomia à Equipe

“Construir projetos ao redor de indivíduos motivados. Dando a eles o ambiente e suporte necessário, e confiar que farão seu trabalho.” Esse já é um dos doze princípios por atrás do manifesto ágil. A equipe de trabalho deve ter autonomia para adequar seus próprios processos de engenharia, fazer os seus próprios compromissos e reunir as informações necessárias para alcançar seus objetivos e cumprir as suas metas. Equipes autônomas são multidisciplinares, possuem indivíduos multidisciplinares, trabalham bem com a interdisciplinaridade  e promovem a autor organização. Nesse tipo de equipe mais um princípio ágil é adicionado: “em intervalos regulares, o time reflete em como ficar mais efetivo, então, se ajustam e otimizam seu comportamento de acordo.”

Nesse ambiente, a equipe de desenvolvimento está em melhor posição para saber responder a problemas difíceis e a pedidos urgentes. A melhor maneira de ter certeza de estar fazendo as coisas corretas é trabalhar diretamente com o cliente para entender suas necessidades, colaborar com os colegas para descobrir como satisfazer essas necessidades, e, frequentemente apresentar os resultados aos interessados para ter certeza de que estamos no caminho certo.

Princípio 6: Construa com Integridade

Qualidade é inegociável. Entregue qualidade intrínseca e explícita aos seus cliente, se eles perceberem isso, significa que foi uma entrega de qualidade. Mary e tom Poppendieck em seu livro identificaram duas dimensões de integridade: integridade percebida e integridade conceitual. A integridade percebida significa que a totalidade do produto alcança um equilíbrio entre as funções, usabilidade, confiabilidade, economia e isso encanta o cliente. A integridade conceitual significa que os conceitos centrais do sistema de trabalho em conjunto são facilitados e coeso. Ela é fator crítico de sucesso para a integridade percebida.

Um produto é considerado ter integridade percebida quando o cliente experimenta o produto e diz: Isso! Era exatamente isso que eu queria! Esse exemplo acontece com frequencia em aplicações do google. Eu particularmente senti isso quando experimentei o novo recurso de caixa prioritária do gmail.

Um produto de software deve estar sempre adicionando integridade. Isso prolonga o seu ciclo de vida operacional. Software com integridade possuem boas arquiteturas, possuem um alto nível de usabilidade e facilidade de uso, são fáceis de dar manutenção, de adaptar e de estender.

Princípio 7: Visualize o Todo

Integridade em sistemas complexo exigem um conhecimento holístico e profundo em diversas áreas. Um dos problemas mais intratáveis com o desenvolvimento do produto é que especialistas em qualquer área (por exemplo, banco de dados ou design) têm uma tendência natural em maximizar o desempenho da parte do produto que representa a sua própria especialidade, ao invés de focar no desempenho do sistema como um todo. Muitas vezes, a integridade do produto como um todo pode ser prejudicado se as pessoas atenderem aos seus próprios interesses especializados em primeiro lugar.

Segue uma lista de excelentes livros sobre métodos ágeis.

• User Stories Applied – For Agile Software Development – Mike Cohn

• Refatoração – Aperfeiçoando o Projeto de Código Existente – Martin Fowler

• Modelagem Ágil – Scott W. Ambler

• A arte de Desenvolvimento Ágil – James Shore & Shane Warden

• Código Limpo – Habilidade Práticas do Agile Software – Robert C. Martin

• Domain-Driven Design – Eric Evans

• O Mítico Homem-Mês – Frederick P. Books jr.

• Programação extrema (xp) explicada – Kent Beck

• Padrões de projeto – soluções reutilizáveis de software orientado a objetos – Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides

• TDD – Desenvolvimento Guiado por Testes – Kent Beck

• Padrões de Arquitetura de Aplicações Corporativas – Martin Fowler

• O Programador Pragmático – de aprendiz a mestre – Adrew Hunt & David Thomas

• Agile Estimating And Planning – Mike Cohn

• Lean Software Development -  An Agile Toolkit – Mary Poppendieck & Tom Poppendieck

• Continuous Integration: Improving Software Quality and Reducing Risk – Paul M. Duvall & Steve Matyas & Andrew Glover

• Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation -  Jez Humble & David Farley

• Test Driven Development A Practical Guide

• Practical Guide to Feature Driven Development, Stephen R. Palmer; John M. Felsing

• Crystal Clear, Cockburn

• Coaching Agile Teams, Adkins

• Agile Game Developent with Scrum, Keith

No link abaixo segue uma lista mais completa de livros sobre métodos ágeis de desenvolvimento: List of 100 best books for agile software development http://bit.ly/cg4K1R

Nesta etapa do tutorial podemos separar as entidades geradas pelo T4 em um projeto separado, que posteriormente vamos utilizar na camada visual da aplicação, para realizar essa tarefa, adicione um novo projeto do tipo Class Library em sua Solution, com o nome de Contatos.Entities, em seguida delete o arquivo Class1.cs, pois não vamos utilizá-lo.

Na camada Contatos.Data, localize o arquivo ModeloContato.tt, que contém a classe Contato.cs, e mova o arquivo para a camada Contatos.Entities, para mover, arraste o arquivo com a tecla Shift pressionada e solte na camada Contatos.Entities.

O padrão de design MVVM (Model-View-ViewModel) é muito utilizado em aplicações Silverlight e WPF, principalmente em aplicações LOB, apesar de ser um padrão avançado, ele não resolve todos os problemas do desenvolvimento de um projeto, porém proporciona uma forma interessante de separar a camada View da camada Model de sua aplicação.

Resumidamente este padrão proporciona separar o modelo (Model) da interface visual do projeto (View), tanto o WPF como o Silverlight, tem um forte suporte a databinding, com esse modelo o desenvolver poderá trabalhar separado do designer na aplicação, ou seja, o designer terá uma maior flexibilidade, podendo utilizar por exemplo o Expression Blend e se concentrar no layout.

Existem diversas ferramentas disponíveis para você aplicar o padrão MVVM com as melhores práticas para uma aplicação em produção, como por exemplo, o framework MVVM Light Toolkit e o Prism, este último tem uma documentação interessante no link  http://compositewpf.codeplex.com/, porém neste tutorial não vou utilizar nenhum framework, para simplificar, vou criar um exemplo básico,  com o objetivo de explicar o conceito do padrão.

Para separar a View do Model, uma terceira classe será criada, essa classe será a ViewModel, ou seja, será a ponte entre essas duas camadas, o ViewModel pode implementar a interface INotifyPropertyChanged, ICommand, fazer validações, escutar eventos, possibilitar testes direto no ViewModel e fazer a adaptação entre a View e o Model.

Dessa forma a View, mais precisamente o arquivo XAML, fica com o mínimo de code-behind em C#, através de binding, ligamos a View com o ViewModel, dessa forma, por exemplo, o código que estaria dentro do evento click de um botão no code-behind do XAML, estará no ViewModel, sendo ligado através de ICommand, na teoria, ao abrir o code-behind de um arquivo XAML não teríamos códigos em C# para a manipulação dos dados e eventos, dessa forma o layout da aplicação fica mais flexível para sofrer mudanças.

O Padrão tem a seguinte arquitetura:

Twitter: @atsh2

Existem diversas ferramentas que facilitam a vida do desenvolvedor quando a tarefa é a criação de gráficos para apresentação de dados, essas ferramentas são bem completas e visualmente ricas, geralmente possibilitam criar gráficos de diversos formatos, por exemplo, gráficos de pizza, linhas e colunas, que são os mais comuns e até gráficos combinados na mesma visualização.

Uma das ferramentas mais conhecidas é o Silverlight Toolkit , que além de criar gráficos, tem uma série de outros componentes interessantes, sua licença é a Microsoft Public License (Ms-PL).

O amCharts também é um excelente projeto, tem uma licença comercial e outra free, contém belos gráficos com animações e interações com o usuário, vale a pena dar uma conferida.

Neste artigo vou mostrar como criar um gráfico simples usando a ferramenta Visifire, essa ferramenta tem uma licença comercial e outra GPL, os gráficos são visualmente ricos, animados e interativos, permite de forma simples a criação de gráficos de atualização online, no site do fabricante tem uma página onde você poderá testar como o gráfico vai ficar.
Faça o download do visifire no site do fabricante, não é necessário instalar nada, o download contém os binários para o WPF, Silverlight e Windows Phone 7.

Crie uma aplicação Silverlight 4 no Visual Studio 2010, adicione uma referência ao binários do visifire para o Silverlight (SL.Visifire.Charts ), no código XAML, dentro do Layout Grid, adicione um elemento do tipo gráfico com o nome de Pizza:

Agora na sua MainPage_Loaded, adicione o código abaixo:

Title titulo = new Title();
titulo.Text = “Gráfico de Pizza”;
titulo.FontSize = 40;

Pizza.Titles.Add(titulo);

DataSeries dataSeries = new DataSeries();
dataSeries.RenderAs = RenderAs.Pie;
DataPoint dataPoint;

for (int i = 0; i < 5; i++)
{
        dataPoint = new DataPoint();
        dataPoint.YValue = 1000 + i;
        dataPoint.LabelText = “Item:” + i;
        dataSeries.DataPoints.Add(dataPoint);
}

Pizza.Series.Add(dataSeries);

Pizza.View3D = true;

O Código acima adiciona o título “Gráfico de Pizza” ao gráfico, depois acrescenta 5 itens que vão compor o gráfico de Pizza, em RenderAs definimos o tipo do gráfico como Pie e por fim habilitamos a visualização em 3D do gráfico.

Sem modificar nada no código fonte em C#, você também poderá criar o mesmo gráfico para WPF e Windows Phone 7, para Windows Phone por exemplo, basta você criar um projeto do tipo Windows Phone Application, se esse tipo de projeto não estiver disponível no seu Visual Studio 2010, instale o seguinte pacote, depois é só fazer uma referência aos binários do visifire para Windows Phone, e adicionar o gráfico da mesma forma que fizemos para o Silverlight.

Twitter: @atsh2

Boa noite pessoal!

Mais uma excelente noticia!
Foi lançado a edição número 76 da revista .NET Magazine, no qual tive o grande prazer de colaborar com o Alexandre Tadashi Sato (Silverlight Experience), na escrita de mais um artigo, sendo que o tema proposto foi sobre Silverlight Toolkit!

O Silverlight Toolkit proporciona aos desenvolvedores uma gama de controles extras ao Microsoft Silverlight, que vão desde componentes para dashboards, skins, controles de navegação, visualização de dados e muito mais. Você encontrará vários exemplos práticos de alguns dos principais componentes, e muito mais!

Lista de artigos desta edição:

• Silverlight Toolkit
• Design Patterns na prática – Parte 1
• Design Patterns
• Code Contracts
• Estimando seus Requisitos
• Pesquisa de objetos na memória
• É possível ganhar dinheiro com licença GPL?(Artigo Exclusivo Digital)

Grande Abs.

Robson Fernandes

Acaba de ser lançada a nova edição da revista .net Magazine, a edição de número 76, o destaque é a programação com Design Patterns.

Segue a lista de artigos:

• Silverlight Toolkit
• Design Patterns na prática – Parte 1
• Design Patterns
• Code Contracts
• Estimando seus Requisitos
• Pesquisa de objetos na memória
• É possível ganhar dinheiro com licença GPL?(Artigo Exclusivo Digital)

O Robson Fernandes (RIA Software) escreveu junto comigo um artigo sobre o Silverlight Toolkit que está nesta edição da .net Magazine, o Silverlight Toolkit é um conjunto de componentes que enriquece os aplicativos desenvolvidos com a tecnologia Silverlight. Além de conhecer a ferramenta, durante o artigo criamos exemplos práticos de alguns dos principais componentes.

Nesta segunda parte do tutorial vou continuar a trabalhar na camada de dados da aplicação, o Entity Framework já disponibiliza um meio padrão para o acesso a dados, que funciona perfeitamente com aplicações WPF, porém neste artigo quero ter uma maior flexibilidade na aplicação e por isso vou comentar duas outras formas de acessar os dados com Entity Framework:

• ADO.NET POCO Entity Generator
• ADO.NET Self-Tracking Entity Generator

A Primeira forma permite a possibilidade de trabalhar com POCO (Plain Old CLR Object) , esse padrão pode ser implementado através de uma extensão do Visual Studio 2010, para instalar basta ir no menu Tools – Extension Manager , clique em Online Gallery e digite no campo de busca a palavra T4, T4 (Text Template Transformation Toolkit) é um editor que possui um template POCO para o ADO.NET Entity Framework 4.

Instale as seguintes opções:

• tangible T4 Editor
• ADO.NET C# POCO Entity Generator
• ADO.NET C# Web Site POCO Entity Generator

Agora clique no seu ModelContato.edmx e com o botão direito do mouse, seleciona Add Code Generation Item, conforme a Figura Abaixo:

INTRODUÇÃO

Boa noite pessoal!
Novamente estou aqui, graças a deus, podendo compartilhar com vocês algumas experiências que tenho passado com o Microsoft Silverlight. Neste post, irei abordar o componente BusyIndicator.

O QUE É O BusyIndicator

O BusyIndicator é um controle que acompanha o SilverlightToolKit, e é utilizado como um meio de mostrar feedbacks ao usuário, sobre o tempo de aguardo de operações que são realizadas, e que exigem alto processamento.
Como por exemplo: Imagine que você queira efetuar uma pesquisa de um usuário em banco de dados com meio milhão de registros, é muito provável que isso demore um pouco, então, nós podemos utilizar o BusyIndicator, que poderá apresentar uma notificação ao usuário, indicando o tempo que faltará para realizar o processamento.

ONDE ENCONTRAR?

Você irá encontrá-lo no CodePlex, clique aqui

Exemplo do controle BusyIndicator, que será apresentado neste Post, e disponibilizado para download.

CÓDIGO XAML

Abaixo, temos o código XAML do BusyIndicator, sendo que a propriedade BusyContent, refere-se ao texto que será apresentado ao usuário, como neste exemplo, “Aguarde por favor…”; A propriedade IsBusy, que indica se o controle está em modo operante ou não, como neste caso, “False”, pois faremos com que ele entre em modo operante, somente quando o usuário efetuar uma ação, que envolva alto processamento.

<toolkit:BusyIndicator x:Name="busyIndicator"
                               BusyContent="Aguarde por favor..."
                               IsBusy="False"
/>

CÓDIGO C#

Abaixo, temos o código em C#, que foi implementado no evento Click do botão Entrar. Neste exemplo não houve nenhuma interação com o banco de dados, ele foi implementado para que vocês possam entender a lógica do controle BusyIndicator. Percebam que ao clicar no botão, ele ativa o modo isBusy do controle, e inicia uma Thread em paralelo, que aguarda um tempo de 3 segundos, e posteriormente inativa o modo isBusy, fazendo então, uma simulação de consulta do usuário ao banco de dados.

private void btnEntrar_Click(object sender, System.Windows.RoutedEventArgs e)
{
         //Inicia modo operante
         busyIndicator.IsBusy = true;

         //Inicia Thread
        ThreadPool.QueueUserWorkItem((state) =>
        {
              //Aguarda 3s
             Thread.Sleep(3 * 1000);
             //Altera BusyIndicator, para modo inoperante
             Dispatcher.BeginInvoke(() => busyIndicator.IsBusy = false);
        });

}

APLICAÇÃO – RUN

Abaixo, temos a aplicação executando em Microsoft Silverlight 4, clique no botão “Entrar”, para ativar o BusyIndicator

DOWNLOAD

Fontes Silverlight Completo-> BusyIndicatorApp

Abraços pessoal!

Robson Fernandes