Hoje eu reencontrei um site muito útil que eu já havia visto algum tempo atrás mas havia perdido o link. O site se chama “When can I use…” e contém diversas tabelas comparativas mostrando o suporte dos principais browsers ? s novidades de CSS, HTML5, SVG, Javascript e outros.

Clicando nos links das funcionalidades é possível ver as tabelas comparativas de suporte dos browsers e também é possível mudar os filtros para exibir outras funcionalidades.

As tabelas de comparação contam também com alguns browsers de smartphone, mas o Windows Phone não consta na lista (tem apenas iOS, Android, Opera Mini e Opera Mobile). Mas isso não é um problema pois o IE do Windows Phone usa a mesma engine de renderização do desktop, com a única diferença de que não suporta plug-ins, então basta olhar a versão do IE normal na lista para ver se suporta a funcionalidade desejada. O IE do Windows Phone 7.0 (versão lançada na Europa e EUA em 2010) usa a engine do IE 7 e o Windows Phone 7.1 (Mango, lançado em 2011, inclusive no Brasil) usa a engine do IE 9.

Se você estiver trabalhando em um projeto usando HTML5, este site com certeza será muito útil para ajudar a identificar os pontos críticos do projeto do ponto de vista de suporte e portabilidade entre plataformas.

O Visual Studio 2010 tem diversos recursos que estão muito bem escondidos nos seus vários menus e telas de configuração, mas são acessíveis por teclas de atalho. Isso é vantajoso em diversas situações pois pode agilizar a utilização desses recursos mas também pode se tornar uma irritação ou mesmo um problema se você por acaso acionar uma dessas teclas de atalho por acidente e não souber como voltar atrás. Foi o que aconteceu com um colega no trabalho recentemente.

Por acidente esse colega acionou uma tecla de atalho do Visual Studio 2010 que ativa a exibição de caracteres ocultos (white space). Em outras palavras, o Visual studio passou a exibir todos os espaços e marcação de final de arquivo na tela. O resultado foi algo semelhante ? imagem abaixo:

Não parece ser algo muito irritante neste exemplo pois há pouco código, mas em arquivos com centenas de linhas de código e em arquivo com html esse modo de visualização é bastante irritante e chega a atrapalhar a produtividade pois polue visualmente a tela. Esse colega passou quase 2 meses trabalhando com essa configuração pois não conseguia encontrar um meio de desfazer e voltar ao modo normal de visualização. Ele chegou inclusive a reinstalar o Visual Studio mas não adiantou pois o instalador não removeu as configurações problematicas.

Hoje eu dei uma pesquisada um pouco mais a fundo e acabei encontrando a solução. A opção do menu para essa configuração se encontra em Edit > Advanced > View White Space e pode ser acionada pela tecla de atalho Ctrl+E, S (que foi o que aconteceu com meu colega).

Uma excelente notícia para quem desenvolve para Web: Hoje Ryan Gavin anunciou no blog oficial do Internet Explorer (em inglês) os planos para implementação de atualizações automáticas silenciosas no IE, começando já em janeiro de 2012 no Brasil e Austrália (isso mesmo, Brasil fará parte do piloto).

Essas atualizações ocorrerão, como o próprio nome diz, de forma automática e silenciosa, sem necessidade de nenhuma intervenção do usuário e possivelmente (pele menos é o que esperamos) sem reiniciar o computador. Esse tipo de atualização já é comum para usuários do Google Chrome.

Mesmo sendo automáticas e sem intervenção, ainda será possível optar por não atualizar (há casos de empresas que têm aplicações que dependem de versões específicas do browser e não podem simplesmente atualizar), ou mesmo remover a atualização e voltar para a versão anterior, mas o padrão agora será a atualização automática para a última versão.

A atualização será para a última versão disponível na plataforma do usuário, ou seja, usuários do Windows XP receberão o IE8 e usuários do Vista e Windows 7 receberão o IE9 (e IE10, quando for lançado).

Agora é esperar que essa atualização realmente diminua de forma substancial o tamanho da base instalada de IE6 e IE7 (e talvez IE8 também, mas não tanto) para que possamos desenvolver sites e aplicações com mais tranquilidade e menos dores de cabeça, além de ajudar a convencer os clientes de que não será mais tão imprescindível suportar versões tão antigas do browser da Microsoft.

versão traduzida para português do post sobre este anuncio

Twitter!

Uma das vantagens de utilizar a arquitetura do Spring para implementar projetos Web, é fazer uso do Sprin-WEB-MVC. Quem já usou sabe que isso é uma vantagem a se considerar quando for feita a escolha das tecnologias e frameworks que serão utilizados no projeto.
Spring WEB-MVC é uma abstração poderosa para a camada de apresentação, tornando muito flexível o uso de diferentes tipos de tecnologias no frnt-end da aplicação.
Veremos uma dessas abstrações que ajudam a modularizar e simplificar nosso trabalho do lado do servidor: Views.

Conceito de Views

Toda requisição que segue para o WEB-MVC passa pelo DispatcherServlet do spring. A partir daí, o container se responsabiliza por delegar a chamada para o controller correto, baseando-se nas configurações de sua aplicação.
Depois que a chamada é tratada pelo controller, o spring manda a resposta correspondente atrelada a uma View. Uma View é um descritor da forma com que os dados vão ser apresentados na interface, podendo ser JSP, JSF, JSon, XML, etc., ou até mesmo uma forma de encapsular os dados específica da sua aplicação.
O poder das Views está justamente no fato de ser apenas uma descrição de como os dados serão apresentados, portanto desconecta-se completamente da aplicação, e pode ser aproveitada em outras ocasiões por outros sistemas.
Uma View no Spring nada mais é do que uma interface Java que descreve o tipo do conteúdo, e é responsável por renderizar a requisição:

Todo o código e JavaDoc está no projeto do Spring.

JSon e XML

Vamos criar um exemplo de controller com duas views diferentes: JSon e XML. JSon e Xml são os formatos mais comuns na Web, por isso vamos ver uma das maneiras de devolvê-las em nossos contrllers.
Não vou entrar no detalhe de como configurar os controllers da sua aplicação para funcionar com o Spring-WEB-MVC, pois não é o intuito deste post, e existe bastante documentação disponível na internet sobre o assunto.


A maneira que escolhi para o exemplo, foi deixar a resposta padrão da servlet como XML, e criar uma alternativa de view em JSon. Você pode configurar como quiser a ordem e o padrão de view da sua aplicação, essa escolha serve apenas para ilustar como lidar com os dois casos.
Comece criando alguma classe de domínio para servir de resposta do nosso controller:

Agora vamos criar um Controller para devolver nosso objeto de domínio:

Agora temos uma servlet que responderá por “//exemplo/xml” devolvendo a instância de exemplo que acabamos de criar no método.
Vamos configurar agora nosso ‘empacotador’ de XML para torná-lo formato padrão da aplicação. No arquivo de beans do Spring crie os seguintes beans:

O que fizemos foi criar um “marshaller” de XML que usa o XStream para converter ‘de’ e ‘para’ XML. Também mapeamos nossa classe de domínio para o alias “exemplo”. Feito isso basta criar um bean que representa os conversores de mensagens do Spring, nesse caso ‘messageConverters’, e associar o conversor de XML nele.
Pronto! Agora que temos as configurações necessárias para criar XML, e anotamos nosso método do controller com ‘@ResponseBody’, o padrão do Spring será devolver o XML que representa a entidade de domínio criada:

Para criar a view de JSon agora, vamos fazer de maneira diferente. Comece criando um bean em seu arquivo do Spring que representa a View de JSon:

Note que precisamos da dependência do ‘Jackson’ no classpath do nosso projeto, que está disponível no site do projeto ou até mesmo no repositório do maven.
Agora em nosso controler, vamos adicionar a dependência da view que acabamos de criar, e adicionar o método que tratará a requisição em JSon:

Repare que não precisamos da anotação ‘@ResponseBody’, e que ao invés de devolver um ‘Exemplo’ estamos devolvendo o ModelAndView do SpringWEBMVC.
Para que a resposta chegue no formato correto, basta mandar a view de JSon que criamos junto com o ModelAndView, e o objeto de domínio. Dessa forma temos a resposta que esperamos:

Conclusão

Para a moda REST que está tomando força nos últimos tempos, as múltiplas views do Spring é uma ótima ferramenta para fazer parte dessa onda, e ainda prover diferentes maneiras de seu servidor se comunicar com diversos tipos de dispositivos e aplicações clientes, sem comprometer código com regras de negócio.

Espero ter sido útil, e qualquer dúvida, crítica ou comentário são sempre bem vindos.

Por @Gust4v0_H4xx0r

Twitter!

JodaTime

Não existe segredo quando se fala da implementação de datas no Java: é ruim de usar. Alguns chegam a dizer que é errado usar inclusive, mas não serei tão extremo.
A API de datas do Java é ruim por vários motivos, como por exemplo, é mal documentada, não é Thread Safe, é difícil de manipular datas, e o comportamento nem sempre é o esperado.
Vamos ver como susbtituir a API de datas que vem Out of the Box no Java, por uma mais efetiva, amigável e confiável: JodaTime.

Lembrando do Calendar

Todo programador Java conhece o Calendar, e sabe que para usá-lo, basta seguir o Design Pattern singleton, ou seja, basta chamar o método de classe em Calendar que devolve a instância única do sistema para o Calendar.


Problema: não funciona.


Não funciona porque se a instância é singleton, e não utiliza threadlocking no código, então não é uma instância ThreadSafe. Logo toda vez que chamamos o getInstance() do Calendar, obtemos uma nova instância. Para ilustrar, crie um teste em JUnit 4 com o seguinte código:

Rode o teste e veja a barra do JUnit ficar vermelha. O comparador ‘==’ usado em objetos, compara pelo endereço de memória, o que deveria ser o mesmo se fosse seguido o padrão singleton de verdade.
Pra piorar, todos os métodos que alteram as intâncias do Date estão expostos (por mais que estejam depreciados) para mantêr compatibilidade com versões anteriores da VM. Portanto o Date também não é ThreadSafe, pois não existe controle de concorrência em sua implementação.
Agora vamos deixar o Date e o Calendar de lado, e vamos ao JodaTime.

DateTime

O JodaTime diferencia muito bem os conceitos de data, instante de tempo, período, etc. A classe mais básica (interface no caso) é a ReadableInstant. Não precisa dizer que todas as modelagens de data implementam essa interface, permitindo comparar todos os tipos de modelagem de tempo pontuais. Um período não descreve um único instante ou ponto no tempo, por exemplo.
DateTime é talvez o ReadableInstant mais conhecido, e funciona muito parecido com o Date do Java.
Fatores que tornam o DateTime mais amigável são: é ThreadSafe pois é imutável, é muito bem documentado, e é muto fácil realizar operações com data. Vamos escrever um pouco de código para entender o que se passa.
Comece criando um DateTime. Como no Java, este DateTime criado possui o instante atual do sistema. Em seguida para efeito de teste (o teste pode falhar dependendo de quando for executado), adicione um dia na data criada, e verifique que o novo date aponta para amanhã:

Repare que tive que reassociar o date para que ele pudesse ser alterado, afinal DateTime é imutável, o mesmo comportamento que o BinInteger possui. Repare também que pra adicionar um dia, basta chamar plusDays. Este método já se encarrega de fazer toda a lógica de adicionar um dia na data, como por exemplo mudar o mês ou ano se for preciso, por isso se esse teste for rodado no dia 31 de dezembro, ele irá falhar pois o DateTime irá adicionar mais um dia a data, e perceberá que se trata do ano seguinte, e portanto getDayOfYear irá devolver ’1′, e não ’366′ ou ’365′ como esperado.
O JodaTime também trata anos bissestos e horário de verão se for selecionado o fuzo correto.
Existe uma API bem completa em DateTime para manipular todos os campos possíveis da data, sendo assim fica muito mais fácil iterar ao longo dos dias, sem precisar delegar pro Calendar a tarefa, e depois recuperar o resultado.
Não vou abordar muito da API do JodaTime, pois está muito bem documentada e existem muitos exemplos nas internet. O objetivo desse post é tratar do assunto do próximo tópico.

JodaTime e Hibernate

Pior que manipular datas, é persistir datas. Cada banco persiste data do seu próprio jeito, e cada implementação de ORM trata o Date do seu próprio jeito. Mas se você está utilizando o Hibernate, o JodaTime tem uma solução de padronização pra você: JodaTime Hibernate.
Com o JodaTime Hibernate é possível mapear diversos tipos de representação de data em suas classes Java, com ou sem TimeZone, como String ou bigint, como período ou duração, etc.
Para se ter uma idéia do que é possível, basta verificar a documentação online.
E para utiliza é muito fácil. Imagine que você tenha uma entidade com um campo DateTime, que se chama entryDate, portanto temos o getter:

Para tornar este DateTime uma data que é padrão do banco que será utilizado, por exemplo, basta adicionar a seguinte anotação:

Estamos falando para o hibernate utilzar o tipo de coluna descrito pelo PersistentDateTime, e utilizar o mesmo para converter a data novamente para DateTime quando for recuperado.
Caso você esteja fazendo engenharia reversa de algum banco, recomendo ler a descrição de todos os tipo disponíveis pra fazer a melhor escolha.
Com isso conseguimos obter todos os benefícios do JodaTime em nossas entidades, facilitando controlar as datas no domínio de nossas aplicações.


Espero ter despertado sua curiosidade com o JodaTime. Na minha opinião é uma das melhores bibliotecas Java disponíveis, mas não quero falar muito sobre suas funcionalidades, pois um dos pontos mais fortes da biblioteca é a facilidade de se acostumar com ela, e principalmente utilizar todos seus recursos. Quero que vocês tenham um pouco desse gostinho .

Por @Gust4v0_H4xx0r

Twitter!

Spring @Configuration

O que há de novo

Para habilitar certas funcionalidades do Spring que envolvem AOP, era preciso escrever tags XML como por exemplo context:component-scan para especificar os pacotes em que o Spring pode buscar por beans anotados com @Component, @Repository ou @Service.
Na versão 3.1 foram disponibilizadas as mesmas funcionalidades via anotação. São elas:

Vamos abordar o caso básico, pois o resto é bem similar.

@ComponentScan

Caso você ainda não esteja familiarizado com as configurações por anotaçãoo, vamos ao básico.
Comece criando uma classe que representará seu container de beans, e a anote com @configuration:

Nesta classe estarão os beans que o container irá instanciar e deixar a nossa disposição.
Para iniciar o container vamos criar um test (JUnit 4) que instancia o contexto:

Aqui criamos um container do tipo AnnotationConfigApplicationContext e registramos nossa classe de configuração nele. Repare que é possível registrar mais classes, e portanto disponibilizar mais beans no container.
Agora vamos criar nosso bean de teste:

Vamos criar os métodos em nossa classe de configuração que instanciam nosso bean de duas maneiras diferentes:

Repare que a única diferença entre os dois é a String que passamos como parâmetro.
Agora que temos 2 beans diferentes em nosso container, vamos criar os testes para verificar o comportamento do Spring. Abaixo da inicialização do contexto, vamos adicionar as seguintes linhas:

Aqui estamos garantindo que nossos dois beans diferentes estarão no contexto como esperado.
Antes de rodar o teste, será necessário adicionar a dependência do CGLib ao seu projeto. Caso você esteja usando o maven, basta adicionar a seguinte dependência>

Pronto, com isso temos o suficiente pra deixar a barra do JUnit verde. Vamos agora adicionar o @ComponentScan.
Em nossa classe de configuração (poderia ser qualquer outra registrada no contexto) adiciona a seguinte anotação:

No meu caso meu bean está dentro do pacote br.com.dclick.tentativas.configuration.beans e portanto basta eu alterá-lo adicionando o seguinte código:

Dessa forma posso criar mais um teste e verificar que o bean está vindo corretamente:

Rode o teste e deixa o JUnit feliz.
A única coisa a se ter cuidado aqui, é que com @ComponentScan, você não pode mapear o diretório da própria classe de configuração.

Demais Configurações

Daqui em diante basta anotar suas classes de configuração com as configurações que você deseja ativar, como por exemplo @EnableAsync que permite que os beans rodem de maneira assíncrona com a anotação @Async.

Brinque um pouco com as outras anotações. Acredito que vale o esforço, pois esse tipo de configuração permite abandonar um pouco os arquivos XML e tornam mais fácil o refactor dos beans, afinal teremos erros de compilação com as mudanças de código.

Por enquanto é isso, qualquer dúvida mande nos comentários que responderei assim que possível.

Por @Gust4v0_H4xx0r

Twitter!

Spring Cache Abstraction

Abordamos um das novas funcionalidades do Spring 3.1 RC1, profiles e environments. Ainda existem outras funcionalidades, mas hoje iremos dar uma olhada em Cache Abstraction.

Cache Abstraction é literalmente uma abstração out of the box para adicionar uma camada de cache sobre seus beans, usando uma arquitetura AOP para gerenciar o que deve e o que não deve ser feito o cache.
Usar a nova camada de cache é muito fácil se você já está habituado com Spring, e veremos uma das diferentes maneiras de configurar seus beans.

Baixando a Denpendência

Para quem utiliza maven, basta adicionar a seguinte dependência no pom do seu projeto:

Se você perferir, pode baixar os jar direto do site do spring.
Sem segredos aqui, basta adicionar as dependências ao projeto e está pronto para usar.

Entendendo o funcionamento

A maneira com que o cache funciona é bem simples. Você pode enxergar o cache como um mapa chave-valor, onde a chave é o conjunto de argumentos do seu método, e o valor é o valor devolvido pelo seu método. Pensando assim fica fácil entender o funcionamento que irei mostrar no exemplo.
Referente a configuração do Spring, é necessário instanciar um gerenciador de cache, ou na linguagem spring, cacheManager. Existe algumas implementações de cache manager disponível no spring, portanto iremos utilizar uma delas em nosso exemplo.
Vamos escrever um teste unitário com JUnit 4.8.1 para ilustrar o comportamento do cache.
Comece criando um arquivo padrão de beans do spring, mas com um namespace a mais:

Repare no getter e setter que usaremos no teste, e na anotação @Cacheable(“property”). Esta anotação está dizendo que o valor que este método devolver será armazenado no cache que configuramos previamente como property. Fato importante é que este valor é referente ao argumento passado como parâmetro no método.
A outra anotação @CacheEvict(value = “property”, allEntries = true) descreve o método que chamaremos para esvaziar o cache. Note que passamos o nome do cache, e que ele deve limpar todos os valores.
É importante notar também que pode ser passado mais de um nome de cache em ambas as anotações.
Uma implementação básica para nosso bean pode ser:

Estou usando o package scan para instanciar o bean. Agora nosso teste:

O arquivo de beans se chama spring31-test-beans.xml.
Repare que estamos invocando o método getForCache passando alguns valores diferentes, e o valor devolvido é sempre igual, mesmo que depois setamos um valor diferente ao bean. Para atualizar o valor e limpar o cache, basta invocar o método evictCache que havíamos anotado com @CacheEvict.
Vale a pena brincar um pouco com o funcionamento do cache, e até mesmo criar outros caches e ver o comportamento do evict em diferentes métodos.

Últimas Considerações

As mesmas configurações que fizemos com anotações, pode-se fazer direto no XML. Não entrarei no detalhe pois o funcionamento é exatamente o mesmo, mas se você preferir basta olhar a documentação que é bem straightforward.
Lembre-se que esta camada de cache não possui nenhuma relação com o banco de dados, e deve ser usada com muito cuidado em tais casos, pois alguns erros de concistência podem aparecer devido a um cache desatualizado.
Vale a pena brincar com o cache manager, pois o spring suporta o uso do EhCache, o que pode ser muito útil se você já possui alguma configuração pré-definida para sua aplicação.

Por enquanto é isso, qualquer dúvida mande nos comentários que responderei assim que possível.

Por @Gust4v0_H4xx0r

Na versão Mango do Windows Phone, você pode manipular uma base de dados localmente, chamada de local database na documentação oficial, o recurso permite que o desenvolvedor crie aplicativos com registros de dados em tabelas, além de manipular seus registros utilizando o LINQ to SQL.

Uma base de dados local no WP7 fica localizada no Isolated Storage, um local acessível somente pela aplicação corrente, a arquitetura fica conforme a figura abaixo, onde temos a aplicação que contém um DataContext e através de LINQ to SQL, fazemos o acesso a base de dados local no Isolated Storage

Arquitetura Local Database

Para saber mais sobre Isolated Storage acessem os links:

http://msdn.microsoft.com/en-us/library/ff402541(v=vs.92).aspx

http://www.windowsphonebrasil.net/windowsphonebrasil/post/2010/10/08/Salvando-e-restaurando-o-Application-State-no-Windows-Phone-7.aspx

No WP7 as aplicações ficam eram áreas isoladas uma das outras, ou seja, uma aplicação não tem acesso ao Isolated Storage de outra aplicação, portanto até o momento não é possível compartilhar uma base de dados local com diversas aplicações. Diferente de uma base de dados SQL Server, um local database não pode rodar como um serviço continuo, visto que ele é executado somente durante o processo da aplicação.

Você pode criar um local database para manipular uma quantidade de dados razoável utilizando as facilidades de consultas do LINQ to SQL juntamente com o relacionamento de tabelas, similar a uma base de dados comum, o local database é uma implementação do SQL CE para o WP7, permitindo realizar facilmente tarefas com incluir, alterar , excluir e realizar consultas com LINQ.

Até o momento não existe uma ferramenta de designer visual e oficial para criar as tabelas, relacionamentos, etc, com a base de dados local, o que poderia facilitar muito, neste artigo faremos um exemplo simples, somente com uma tabela, porém, em um projeto mais complexo, essa tarefa poderia ser um pouco trabalhosa, uma forma não oficial de criar o modelo seria utilizar o SQL Metal, para mais informação, acessem o Centro de Treinamento Oficial do Windows Phone no MSDN ou através do link : http://windowsphonegeek.com/articles/Using-SqlMetal-to-generate-Windows-Phone-Mango-Local-Database-classes .

Com o SQL Metal podemos criar o Data Context através de um comando e com poucas modificações deixá-lo compatível com o Mango e poupar a codificação manual da criação de tabelas e relacionamentos.

Exemplo de comando do SQL Metal:

%ProgramFiles(x86)%Microsoft SDKsWindowsv7.0ABin>SqlMetal.exe
/code:”C:CaminhoClienteDC.cs” “C:CaminhoClienteDB.sdf”

Outras formas:

http://claudiufarcas.blogspot.com/2011/10/windows-phone-mango-sql-ce-tips-and.html

http://blogs.ugidotnet.org/corrado/archive/2011/06/05/using-local-database-in-wp7-mango.aspx

Nesta primeira parte do artigo vou criar uma base de dados muito simples, com uma tabela somente e um único campo, dessa forma podemos focar em como criar e entender os conceitos envolvidos Vou criar uma base de dados Cliente.sdf, com uma tabela chamada Cliente e um campo chamado Nome.

A primeira classe que vamos criar é a entidade Cliente e decorar com alguns atributos utilizados para a manipulação da base de dados, a classe servirá de apoio para a criação da tabela cliente. Para que você possa inserir os atributos nas propriedades da classe, é necessário adicionar o using System.Data.Linq.Mapping, em seguida adicione o atributo [Table] logo acima da criação da classe e adicione o atributo [Column()] em cada propriedade, na primary key da tabela, personalize com :

[Column(IsPrimaryKey = true, IsDbGenerated = true, DbType = "INT NOT NULL Identity", CanBeNull = false, AutoSync = AutoSync.OnInsert)]

Dessa forma a coluna será criada na tabela como sendo Primary Key, não permitindo registros duplicados e gerando automaticamente um número a cada inclusão. Com a adição do atributo Column() nas outras propriedades, cada coluna correspondente será criado na tabela.

Com os atributos de colunas você pode definir uma série de recursos, para saber quais são os atributos de colunas que você pode utilizar no LINQ to SQL para WP7 acesse o link http://msdn.microsoft.com/en-us/library/system.data.linq.mapping.columnattribute(VS.95).aspx

Um atributo em especial que adiciona uma coluna de versão pode auxiliar no desempenho de grandes atualizações de dados, apresentando uma significativa melhoria na aplicação, é o IsVersion=true, essa otimização é exclusiva para o LINQ to SQL do WP7 e usado internamente para identificar a versão da coluna modificada:

[Column (IsVersion = true)]
_VERSION Binary privado;

Igualmente importantes são os atributos de associações, que permitem realizar o relacionamento entre as tabelas, para mais informações acesse:

http://msdn.microsoft.com/en-us/library/system.data.linq.mapping.associationattribute(v=VS.95).aspx

Exemplo de Associação:

[Association(Storage = "_cliente", ThisKey = "_clienteId", OtherKey = "Id", IsForeignKey = true)]

Código da Classe Cliente:

? ? ?  [Table]

? ? ?  public class Cliente : INotifyPropertyChanged, INotifyPropertyChanging

? ? ?  

? 

? ? ? ? ? ? ?  #region INotifyPropertyChanged Members

? 

? ? ? ? ? ? ?  public event PropertyChangedEventHandler PropertyChanged;

? 

? ? ? ? ? ? ?  private void NotifyPropertyChanged(string propertyName)

? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ?  if (PropertyChanged != null)

? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ?  }

? 

? ? ? ? ? ? ?  #endregion

? 

? ? ? ? ? ? ?  #region INotifyPropertyChanging Members

? 

? ? ? ? ? ? ?  public event PropertyChangingEventHandler PropertyChanging;

? 

? ? ? ? ? ? ? 

? ? ? ? ? ? ?  private void NotifyPropertyChanging(string propertyName)

? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ?  if (PropertyChanging != null)

? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  PropertyChanging(this, new PropertyChangingEventArgs(propertyName));

? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ?  }

? 

? ? ? ? ? ? ?  #endregion

? 

? 

? ? ? ? ? ? ?  [Column(IsPrimaryKey = true, IsDbGenerated = true, DbType = "INT NOT NULL Identity", CanBeNull = false, AutoSync = AutoSync.OnInsert)]

? ? ? ? ? ? ?  private string id;

? ? ? ? ? ? ?  public string Id

? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ?  get

? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  return id;

? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ?  set

? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  if (id != value)

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanging("Id");

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  id = value;

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanged("Id");

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ?  }

? 

? ? ? ? ? ? ?  }

? ? ? ? ? ? ? 

? ? ? ? ? ? ?  [Column()]

? ? ? ? ? ? ?  private string nome;

? ? ? ? ? ? ?  public string Nome

? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ?  get

? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ?  ? ? ? ? ? ? ? ? return nome;

? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ?  set

? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  if (nome != value)

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanging("Nome");

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  nome = value;

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanged("Nome");

? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ? ?  }

? 

? ? ? ? ? ? ?  }

? ? ? ? ? ? ? 

? 

? ? ?  }

Em aplicações Silverlight é comum implementar a interface INotifyPropertyChanged para monitorar mudanças nas propriedades da classe , e tirar um melhor proveito do recursos de databinding da tecnologia, para auxiliar o LINQ to SQL, também vamos implementar a interface INotifyPropertyChanging, com ela é possível monitorar quando uma propriedade será modificada e com isso o DataContext é informado e pode identificar as mudanças e melhorar a performance da aplicação.

O Data Context é o local onde definimos o contexto dos dados que servirão para criar a base de dados local, o LINQ to SQL depende do mapeamento entre o modelo de objetos e o esquema da base de dados. Dependendo da complexidade do modelo, esse arquivo pode ser trabalhoso de ser criado manualmente, mas existem formas de utilizar alguma ferramenta para cria-lo, o SQL Metal é uma delas conforme comentado acima no artigo.

Crie uma classe chamada ClienteDataContext , ela vai herdar de DataContext, o DataContext contém diversas propriedades e métodos que auxiliam na manipulação de base de dados, como por exemplo, verificar se uma base de dados existe, criar e excluir uma base de dados, entre outros, mais adiante vamos utilizar o método CreateDatabase() para criar fisicamente a base de dados local no Windows Phone.

A próxima etapa é criar a string de conexão com a base de dados, utilizaremos a palavra chave “isostore” para informar que o arquivo ficará no Isolated Storage, após isso informaremos o nome da base de dados como Cliente.sdf. É na string de conexão que você pode inserir um senha de acesso a base de dados, informar uma cultura específica ou até mesmo criar uma base de dados somente leitura, para mais informações sobre string de conexões para o WP7 acesse http://msdn.microsoft.com/en-us/library/hh202861(v=vs.92).aspx

Por último vamos definir uma tabela Cliente de acesso público e única no DataContext através de public Table Cliente.

No App.xaml.cs da aplicação , localize o construtor da classe e no final adicione o código abaixo, neste momento vamos criar uma base de dados usando o DataContext criado anteriormente, o código verifica se existe uma base de dados e caso não exista ele já cria uma nova base de dados.

using (ClienteDataContext ctx = new ClienteDataContext(ClienteDataContext.DBConnectionString))

? ? ?  if (ctx.DatabaseExists() == false)

? ? ? ? ? ? ?  

? ? ? ? ? ? ? ? ? ?  ctx.CreateDatabase();

? ? ? ? ? ? ?  

? 

}

Para finalizar o artigo vou criar uma tela simples em Silverlight, sem se preocupar com o layout, a tela tem um botão chamado “add” que vai adicionar um registro na base de dados e logo abaixo um ListBox chamado “lst”, que está ligado através de databinding a propriedade ItemSource com uma ObservableCollection chamada Items, na propriedade Text vamos mostrar o nome do cliente também ligando através de databinding.

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  ? Grid.Row="1" Margin="12,0,12,0">
? ? ? ? ? ? ? ? ? ? ?  ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  ? Click="add_Click">
? ? ? ? ? ? ? ? ? ? ? 
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? 

No constructor do MainPage vamos criar uma instância do DataContext chamado clienteDB :
clienteDB = new ClienteDataContext(ClienteDataContext.DBConnectionString);
No evento ? Loaded da MainPage, realizamos um consulta LINQ to SQL e já adicionamos o resultado em uma ObservableCollections chamada Items, que está ligado ao ItemSource da ListBox, veja como é prático ligar as informações na tela, neste exemplo como o foco é o conceito de local database, o projeto foi criado todo no code-behind da MainPage, mas você poderia criar usando o ViewModel e ligando o ObservableCollection com a View.
var result = from Cliente r in clienteDB.Cliente
select r;
Items = new ObservableCollection(result);
Para mais informações sobre LINQ:
http://msdn.microsoft.com/en-us/library/bb397897.aspx
http://msdn.microsoft.com/en-us/library/bb386976.aspx
http://msdn.microsoft.com/en-us/library/bb386913.aspx
Vamos agora para o código do botão “add” que vai adicionar os registros na base de dados, através do InsertOnSubmit() adicionamos o objeto ao DataContext e através do SubmitChanges(), o objeto é registrado na base de dados, por último, inserimos o objeto na coleção para que seja apresentado na tela.
Cliente c = new Cliente();
c.Nome = txtNome.Text;
clienteDB.Cliente.InsertOnSubmit(c);
clienteDB.SubmitChanges();
Items.Add(c);
? 
Código completo da MainPage:
? ?  public partial class MainPage : PhoneApplicationPage, INotifyPropertyChanged
? ? ?  
? ? ? ? ? ? ? ?  ClienteDataContext clienteDB;
? ? ? ? ? ? ? ?  #region INotifyPropertyChanged Members
? ? ? ? ? ? ? ?  public event PropertyChangedEventHandler PropertyChanged;
? ? ? ? ? ? ? ?  private void NotifyPropertyChanged(string propertyName)
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  if (PropertyChanged != null)
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ?  }
? ? ? ? ? ? ? ?  #endregion
? ? ? 
? ? ? ? ? ? ?  private ObservableCollection _items;
? ? ? ? ? ? ?  public ObservableCollection Items
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  get
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  return _items;
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  set
? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  if (_items != value)
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  _items = value;
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  NotifyPropertyChanged("Items");
? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  }
? ? ? ? ? ? ?  }
? ? ? ? ? ? ? 
? ? ? ? ? ? ?  // Constructor
? ? ? ? ? ? ?  public MainPage()
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  InitializeComponent();
? ? ? ? ? ? ? ? ? ? ?  clienteDB = new ClienteDataContext(ClienteDataContext.DBConnectionString);
? ? ? ? ? ? ? ? ? ? ?  this.DataContext = this;
? ? ? ? ? ? ? ? ? ? ?  Loaded += new RoutedEventHandler(MainPage_Loaded);
? ? ? ? ? ? ?  
? ? ? ? ? ? ?  void MainPage_Loaded(object sender, RoutedEventArgs e)
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  var result = from Cliente r in clienteDB.Cliente
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?  select r;
? ? ? ? ? ? ? ? ? ? ?  Items = new ObservableCollection(result);
? ? ? ? ? ? ?  
? ? ? ? ? ? ?  private void add_Click(object sender, RoutedEventArgs e)
? ? ? ? ? ? ?  
? ? ? ? ? ? ? ? ? ? ?  Cliente c = new Cliente();
? ? ? ? ? ? ? ? ? ? ?  c.Nome = txtNome.Text;
? ? ? ? ? ? ? ? ? ? ?  clienteDB.Cliente.InsertOnSubmit(c);
? ? ? ? ? ? ? ? ? ? ?  clienteDB.SubmitChanges();
? ? ? ? ? ? ? ? ? ? ?  Items.Add(c);
? ? ? ? ? ? ?  
? ? ?  }
Links:
Boas Práticas:
http://msdn.microsoft.com/en-us/library/hh286406(v=vs.92).aspx
Mais informações sobre local database no Windows Phone :
http://msdn.microsoft.com/en-us/library/hh202860(v=vs.92).aspx
http://msdn.microsoft.com/en-us/library/hh202876(v=VS.92).aspx
Alterações do esquema da base de dados:
http://msdn.microsoft.com/en-us/library/hh394018(v=VS.92).aspx

Não sou um Mac, sou um PC, mas isso não muda em nada o fato de que o mundo ficou um pouco mais feio e triste hoje, com a perda de Steve Jobs para um câncer de pâncreas.

Desde quando comecei minha carreira como desenvolvedor, em 2000, eu trabalho com PCs e tecnologia primariamente da Microsoft, então acho que deve ser no mínimo estranho me ver fazendo aqui um post sobre o falecimento de Steve Jobs, mas ninguém pode negar que ele revolucionou todo o mercado de tecnologia.

Minha carreira começou como programador web, mas eu sempre me interessei bastante em fazer as coisas de forma a serem simples para o usuário (e se possível, para o desenvolvedor também). Na época esse conceito não tinha um nome nem era muito difundido, mas hoje chamamos de UX (experiência do usuário). Em toda minha carreira eu me dediquei a criar software seguindo o que considerava a melhor experiência possível. Comecei a focar mais intensamente nessa área a partir de 2007, com o surgimento do Silverlight e a crescente atenção dada pelo Microsoft ao assunto. Hoje, sou o especialista de UX e novas tecnologias na empresa onde trabalho e adoro o que faço. Devo muito ao Steve, pois se há alguém responsável por UX finalmente ter se tornado um assunto importante, ele foi esse alguém.

O único iProduto que tenho é um iPod Touch, que foi comprado 6 meses atrás quando eu estava ajudando em um projeto para portar uma aplicação de iOS para Windows Phone 7. É um bom aparelho e não me arrependo da compra, mas uso apenas para jogar e fazer testes de desenvolvimento.

Apesar de eu não ser muito fã da linguagem de design dos softwares da Apple, é impossível negar o impacto que eles têm no nosso mercado atual. Steve mudou o mundo ao mostrar que a experiência do usuário é o mais importante, não a tecnologia. As coisas devem ser fáceis de usar, simples de entender, práticas e belas ao mesmo tempo. Se não tiver esses 4 requisitos, não terá o sucesso que poderia ter.

A morte de Steve serve também para mostrar que ele era humano, como nós. Um humano extraordinário, mas humano, o que significa que todos temos esse potencial de mudar o mundo, fazer a diferença, mas apenas poucos conseguimos.

Para mostrar como Steve Jobs foi importante, basta olhar para quem já fez algum pronunciamento sobre seu falecimento e prestar atenção na mensagem que cada um tentou passar: Bill Gates, Barak Obama, Michael Bloomberg, Steve Wozniak, e muitos outros que nem dá pra citar aqui.

Por tudo isso, obrigado Steve. O mundo ficou um pouco mais feio e triste hoje. Meus mais sinceros sentimentos a todos seus amigos e familiares. Descanse em paz.

Na palestra de Silverlight 5 que apresentei este ano com Rodrigo Kono no TechEd Brasil, mostramos a nova versão do PivotViewer que vem no SDK do Silverlight 5.

Esta nova versão tem diversas melhorias, principalmente no que diz respeito ? forma de montar e utilizar a coleção de dados. Nesta nova versão não é mais necessário pré-processar a coleção usando Excel ou DeepZoom Composer e praticamente tudo pode ser feito usando Binding.

Abaixo tem um link para fazer download do código fonte do exemplo que apresentamos. Para usar este exemplo é necessário ter instalado o Tools do Silverlight 5 RC. Em breve vou publicar novos posts com mais detalhes sobre esta e outras novidades do Silverlight 5, mas por enquanto, aproveitem este exemplo.

PivotViewerSample.zip