Cidadão Carioca

MVC : Globalizando o Range Validator

noreply@blogger.com (Dennes) — Tue, 24 Jan 2012 05:26:00 +0000

Continuando a série sobre a globalização da validação no ASP.NET MVC, vamos ver como globalizar o Range Validator.

Range Validator

Assim como o validador numérico, pelo fato de lidar com números o Range Validator do jQuery precisa ter sua função alterada para poder interpretar corretamente as diferenças entre uso de “.” e “,” nos valores numéricos conforme a cultura utilizada.

Alterando a função

Veja a nova função para a globalização do Range Validator :
<script type="text/javascript">
    $(function () {
            jQuery.extend(jQuery.validator.methods,
            {
            range: function (value, element, param) {
          //Use the Globalization plugin to parse the value        
                var val = Globalize.parseFloat(value);
                return this.optional(element) || 
                           (val >= param[0] && val <= param[1]);
            }
          });
    });
</script>
Repare no uso do jQuery.extend em comparação com a síntaxe usada no método number. As duas síntaxes são, de fato, equivalentes. Essa mesma função acima poderia ser escrita na outra síntaxe :
<script type="text/javascript">
    $(function () {
            $.validator.methods.range=
function (value, element, param) {
          //Use the Globalization plugin to parse the value        
                var val = Globalize.parseFloat(value);
                return this.optional(element) || 
                              (val >= param[0] && val <= param[1]);
            }
       });   
</script>

MVC : Traduzindo a Mensagem de Validação Numérica

noreply@blogger.com (Dennes) — Mon, 23 Jan 2012 04:18:00 +0000

Continuando a série sobre globalização da validação, agora que já falamos sobre globalizar a validação numérica, vamos falar sobre a tradução da mensagem de validação.

Mensagem de Validação

Todos os validadores permitem a personalização – e consequentemente a globalização – da mensagem de validação, com exceção de um : o validador de valores numéricos.

Este validador é inserido automaticamente para verificar o tipo de dados numéricos e ficamos sem o controle de sua mensagem.

Alterando a Mensagem

A mensagem de erro deste validador é inserida dentro da página, em cada tag input, em um atributo chamado data-val-number.

Desta forma podemos usar um pouco de “força-bruta” para trocar a mensagem : Com jQuery e expressão regular podemos fazer a troca.

Trocando a Mensagem

A função de troca deverá ser executada assim que a página for carregada, portanto, no $(document).ready

<script type="text/javascript">
    $(function () {
        $("input[data-val-number]").each(
    function (index, el) {
        var re = new RegExp("The field (.*?) must be a number.");
        var string = $(this).attr("data-val-number");
        var m = string.match(re);
        if (m != null && m.length > 1) {
            $(this).attr("data-val-number", string.replace(m[0], "O campo " + m[1] + " precisa ser numérico"));
        }
       });
    });
</script>

O que a função faz

Usando jQuery localizamos todos os input que possuem o atributo data-val-number. Utilizando expressão regular trocamos a mensagem para uma equivalente em português, mantendo o nome do campo.

Onde Inserir a Função

Quando a página é carregada o script de validação (jquery.validate.unobtrusive.js) analisa os atributos das tags input e gera os objetos de validação.

Se a função acima for executada depois deste processo, não terá efeito algum, pois os objetos de validação já terão sido criados com a mensagem errada.

Portanto a função acima deve ser inserida antes da inserção do script jquery.validate.unobtrusive.js

MVC : Globalizando a Validação numérica

noreply@blogger.com (Dennes) — Sun, 15 Jan 2012 22:24:00 +0000

Falamos anteriormente sobre a globalização da validação no MVC. A globalização da validação numérica é um dos passos para essa globalização.

Validação Numérica

Quando criamos uma caixa de texto com base em um campo numérico o jQuery validator gera automaticamente uma validação do tipo de dados – como numérico – o que podemos ver pelo atributo data-val-number criado na tag input.

O formato de um valor numérico depende muito da globalização : Alguns paises usam “.” como casa decimal, outros usam “,” como casa decimal, o que é nosso caso. Especialmente por isso a globalização se torna fundamental para nós.

Globalizando

Para a validação numérica funcionar de forma globalizada precisamos alterar o método de validação de forma que ao invés da lógica padrão ele faça uma consulta ao plug-in de validação.

Os métodos de validação padrões ficam localizados na classe jQuery.validator.methods . A síntaxe do javascript facilita a substituição do método padrão – que se chama number – por um novo método que utilize o plug-in de globalização.

Novo método

Devemos inserir o novo método no inicio da página, após os scripts de globalização e do jQuery validator.
<script type="text/javascript">
    $.validator.methods.number = function (value, element) { 
        if (Globalize.parseFloat(value)) {
            return true;
        }
        return false;
    }
</script> 
A nova function faz uso do Globalize para identificar (ou não) o valor numérico. Atribuimos a nova function como propriedade number da classe methods e ela passa a substituir a validação numérica, resolvendo o primeiro problema da globalização

Globalização no ASP.NET MVC

noreply@blogger.com (Dennes) — Tue, 10 Jan 2012 03:24:00 +0000

Os validadores do ASP.NET MVC – baseados no uso de JQuery – validam datas e números, além de fornecerem algumas mensagens de validação pré-definidas. Porém para isso fazem grande uso do jQuery validator.

O uso do jQuery validator para a validação no MVC cria uma maior necessidade do controle de globalização, que precisará ser controlada também no lado client.

Veja os desafios que precisamos resolver em relação a globalização no jQuery validator :

Definir a cultura a ser usada no client
Fazer com que a validação numérica use a globalização
Traduzir a mensagem das validações numéricas
Fazer com que o Range validator use a globalização

jQuery validator x Globalize

O jQuery validator possui diversos validadores pré-codificados em sua biblioteca (.js). Esses validadores, porém, não preveêm o uso de globalização e 2 deles são afetados pela cultura : Validação numérica e validação de range numérico.

Para controlar a globalização utilizaremos um plug-in chamado jQuery Globalize. Este plug-in possui métodos para tratar valores numéricos e datas levando em consideração a cultura.

Porém para que a globalização funcione é necessário substituir alguns dos métodos do jQuery validator para que estes passem a utilizar o plug-in Globalize.

Plug-In Globalize

O Plug-In Globalize é disponibilizado no GitHub, pode-se fazer o download clicando-se no botão “Zip”.

Junto com o download é fornecida uma aplicação chamada “Generator” que faz a geração de arquivos de cultura, um arquivo .js para cada cultura, por exemplo, Globalize.Culture.pt-BR.js

Para fazer a globalização precisará inserir um destes arquivos .js na aplicação, ou todos se desejar uma aplicação flexivel em relação a cultura.

Por exemplo, caso deseje que a aplicação seja localizada para português, deverá inserir os seguintes arquivos nas páginas :
<script src="@Url.Content("~/Scripts/globalize.js")" type="text/javascript"> </script> 
<script src="@Url.Content("~/Scripts/cultures/Globalize.culture.pt-BR.js")" type="text/javascript"></script>
Utilizamos então o plug-in Globalize para especificar a cultura utilizada :
<script type="text/javascript">
        $(function() {
                Globalize.culture=Globalize.culture("pt-BR");
             });
</script> 

Mais sobre Globalização

Nos próximos posts mostrarei scripts que junto com o plug-in de globalize permitem fazer os validadores trabalharem com múltiplas culturas.

Porém esse é só parte do problema envolvendo globalização/localização. Você pode precisar, por exemplo, que a cultura seja definida dinamicamente, a partir do servidor.

Scott Hanselman escreveu um artigo muito bom sobre globalização, porém observe que o código do artigo ainda utiliza uma versão antiga do plug-in Globalize.

Corrigindo o controle de versão no Source Safe

noreply@blogger.com (Dennes) — Thu, 10 Nov 2011 22:56:00 +0000

O source safe utiliza um arquivo chamado MSSCCPRJ.SCC para fazer o controle de versão do projeto.

Quando, por algum motivo qualquer, esse arquivo desaparece, ao abrir o projeto passamos a receber duas desagradáveis opções : ou temporariamente removemos o controle de código fonte ou removemos em definitivo.

Corrigir esse problema é simples : Basta ir no menu File –> Source Control –> Change Source Control. Com isso será exibida a tela abaixo, na qual poderemos vincular novamente nosso projeto ao source safe, gerando novamente o arquivo que estava faltando.

Como entender MVVM e seus Frameworks

noreply@blogger.com (Dennes) — Wed, 09 Nov 2011 22:09:00 +0000

1) Entenda a relação existente entre as partes

2) Comece com os fundamentos básicos da MVVM

A) Nenhum código deve ser inserido no code-behind da tela

B) A ViewModel nunca faz referência a nenhum elemento da tela

3) Com base nesses principios, monte um pequeno exemplo, uma tela simples para fazer alguns cálculos, por exemplo.

A) Você descobrirá a necessidade da interface INotifyPropertyChanged

B) Você descobrirá a necessidade da interface ICommand

C) Você descobrirá a necessidade do atributo Command nos buttons

4) Faça com que sua tela possua mais de um botão, mais de uma ação a ser disparada na ViewModel

A) Se ainda não descobriu, descobrirá a necessidade de uma classe RelayCommand implementando a interface ICommand

5) Faça outra tela

A) Você descobrirá a necessidade de uma classe ViewModelBase com algumas implementações padrões

6) Para ligar o ação de outros objetos (select de combobox, listbox, etc) a ações da viewmodel, você precisará de behaviors personalizados

8) Compare o que desenvolveu com frameworks prontos de MVVM tal como Prism e MVVM Light

Enquanto segue esses passos, observe essas regras adicionais :

A) Quando sentir uma tentação de colocar código na interface, considere analisar este código pelo angulo de um comportamento padrão que se repetirá e crie um behavior personalizado

B) Ainda sobre código na interface, considere que pode substituir o atributo "command" nos buttons pelo uso de um behavior que dispare o command, podendo assim agregar mensagens de confirmação, mensagens de sucesso, foco em objetos e outras funcionalidades.

C) Assista ao webcast sobre desenvolvimento em camadas com Silverlight

Enterprise Library 5.0 já está disponível

noreply@blogger.com (Dennes) — Wed, 09 Nov 2011 10:09:00 +0000

Mais uma vez temos uma nova versão da enterprise library. Essa versão possui uma considerável importância pois é a primeira a se integrar com o .NET Framework 4.0 e Visual Studio 2010, a última versão lidava com o framework anterior.

Lembro que neste tempo de espera cheguei a esbarrar com pretensos arquitetos de software plajenando arquiteturas sobre a versão anterior mas ignorando os recursos disponíveis no VS 2010. Bad, very Bad.

Você pode ver as novidades prometidas em http://msdn.microsoft.com/en-us/library/ff632023.aspx

Alguns pontos se destacam :

Data Annotations

A enterprise library fez uma integração entre o Validation Application Block e as Data Annotations, o que é muito bom.

Além disso houve uma integração com os recursos de validação do WPF.

Tudo isso é muito importante pois pode estar trazendo uma padronização na forma de uso de Data Annotations para os sistemas. O WCF RIA Services utiliza bem as Data Annotations com os recursos de projeção, mas serviços WCF não tem essa facilidade. Vamos ver o que essa nova versão nos traz.

Cache Application Block

Apenas na versão 4.0 do .NET surgiu o conceito de cache providers, o que fez uma integração com App Fabric. Isso dispensa muita coisa que o cache application block da enterprise library possuia, cabe vermos de que forma o recurso nativo está sendo aproveitado nesta nova versão.

Assim que conferir as novidades, publico algo sobre o assunto

Gerando documentação XML : SandCastle

noreply@blogger.com (Dennes) — Wed, 05 Oct 2011 16:51:00 +0000

Os comentários em XML são muito úteis e fáceis de inserir no código. Provavelmente você mesmo já deve ter pensado : “Como extrair esses comentários em XML para gerar uma documentação ?”

Existe uma ferramenta chamada SandCastle que faz isso, mas seu uso não é trivial, o que faz com que poucos se aprofundem no assunto.

Justamente pelo fato do uso não ser trivial, crie um .BAT que simplifica muito o trabalho com o sandcastle.

Veja abaixo os passos para gerar a documentação

Passo-a-Passo

Baixe o SandCastle - http://sandcastle.codeplex.com/
Configure o projeto para gerar documentação – /doc. Nas propriedades do projeto, tab “Build”, marque a opção “XML Documentation File”

Copie o arquivo .bat para o diretório debug da sua aplicação.
Faça um rebuild (precisava colocar esse passo ;-)
Abra um prompt na pasta debug (shift + right click no windows explorer é seu amigo)
Rode o .bat : > Documentar NomeDoProjeto

Resultado

O SandCastle irá gerar uma pasta output contendo um .chm com a documentação do projeto, tanto contendo a estrutura das suas classes como seus comentários XML extraidos do código.

Imprevistos

O código do arquivo .BAT tenta contornar problemas de path, mas considera tudo instalado em seu caminho default. Se não estiver, precisará manipular o código e/ou contornar de outra forma.

Explicações Detalhadas

Veja mais detalhes sobre o parâmetro /doc : http://msdn.microsoft.com/en-us/library/f64ezf9b(v=vs.80).aspx

O SandCastle tem o mal hábito de não funcionar porque de fato são necessários 12 passos entre a compilação e a geração da documentação. São tais passos que estão ocultos no .BAT que criei. Veja os passo em http://blogs.msdn.com/b/sandcastle/archive/2006/07/29/682398.aspx

Pegadinha adicional : O VS por default gera o .xml com o nome do projeto, mas a ferramenta chamada BuildAssembler está configurada para usar por default um arquivo chamado comment.xml, exatamente com esse nome.

Para resolver, o .BAT que criei troca o nome do arquivo .xml

Código do Arquivo .BAT

(copie e cole em um arquivo .bat)

@Echo off

REM ******************* Testa o parâmetro *******************

if {%1}=={} (
@echo Por favor, informe o nome do assembly
goto End
)

REM ********************** Redefine o path *********************

set path=%path%;%DXROOT%productiontools
set TOOLSPATH=%ProgramFiles%
if exist "%ProgramFiles% (x86)" set TOOLSPATH=%ProgramFiles(x86)%

set PATH=%TOOLSPATH%\HTML Help Workshop;%TOOLSPATH%\Microsoft Help 2.0 SDK;%PATH%

REM ********************* Remove diretórios existentes *****************

if exist output rmdir output /s /q
if exist chm rmdir chm /s /q

REM ******************** Preparando arquivo de documentação ***************

if not exist %1.xml (
@echo Erro : Não há arquivo de documentação
goto End
)

if exist %1.xml copy /y %1.xml comments.xml

REM ********** Call MRefBuilder ****************************

MRefBuilder %2.dll /out:reflection.org

REM ********** Apply Transforms ****************************

XslTransform /xsl:"%DXROOT%\ProductionTransforms\ApplyVSDocModel.xsl" reflection.org/xsl:"%DXROOT%\ProductionTransforms\AddFriendlyFilenames.xsl" /out:reflection.xml /arg:IncludeAllMembersTopic=true /arg:IncludeInheritedOverloadTopics=true

XslTransform /xsl:"%DXROOT%\ProductionTransforms\ReflectionToManifest.xsl" reflection.xml /out:manifest.xml

call "%DXROOT%\Presentation\vs2005\copyOutput.bat"

REM **************Generate an intermediate Toc file that simulates the 2005 TOC format.

XslTransform /xsl:"%DXROOT%\ProductionTransforms\createvstoc.xsl" reflection.xml /out:toc.xml

REM ************** Montar Pastas ***********************

call %DXROOT%\Presentation\Prototype\copyOutput.bat

REM ********** Call BuildAssembler ****************************

BuildAssembler /config:"%DXROOT%\Presentation\vs2005\configuration\sandcastle.config" manifest.xml

REM ********** Gerar HTML Help Project ****************************

XslTransform /xsl:%DXROOT%\ProductionTransforms\ReflectionToChmProject.xsl reflection.xml /out:Output\test.hhp

REM ********** Gerar a table of contents ****************************

XslTransform /xsl:%DXROOT%\ProductionTransforms\createvstoc.xsl reflection.xml /out:toc.xml

REM ********** Gerar as informações do projeto de help *******************

XslTransform /xsl:%DXROOT%\ProductionTransforms\TocToChmContents.xsl toc.xml /out:Output\test.hhc

XslTransform /xsl:%DXROOT%\ProductionTransforms\ReflectionToChmIndex.xsl reflection.xml /out:Output\test.hhk

REM ********** Executar o processamento do Help ****************************

hhc output\test.hhp

:End

Windows Phone App : Eventos da Aplicação

noreply@blogger.com (Dennes) — Mon, 22 Aug 2011 07:07:00 +0000

Uma aplicação no Windows Phone possui um conjunto de eventos iniciais que podem confundir um pouco o desenvolvedor. Vamos analisar melhor esses eventos :

Launching : Quando a aplicação está sendo iniciada
Closing : Quando a aplicação está sendo encerrada
Activating : Quando a aplicação está sendo ativada
Deactivating : Quando a aplicação está sendo desativada

A definição pode inicialmente parecer simples, mas afinal, qual a diferença entre Launching e Activating ? E entre Closing e Deactivating ?

A principio Launching e Closing representam a abertura e fechamento da aplicação. Activating e Deactivating representam a aplicação sendo ativada ou colocada em background. Essa é a definição teórica.

Na prática em ambos os casos (fechar ou ir para background) a aplicação é totalmente retirada da memória do Windows Phone, sendo inicializada novamente no Launching ou Activating.

Desta forma fica a critério do desenvolvedor criar ou não uma experiência de usuário diferenciada entre o fechamento e a colocação da aplicação em background. Caso o desenvolvedor queira, pode simplesmente fazer com que as operações sejam equivalentes para a aplicação.

Porém uma outra dúvida constante é do ponto de vista do usuário : Qual a diferença entre Closing e Deactivating para o usuário ? Como o usuário fecha uma aplicação e como a manda para o background ?

A ação oposta também é confusa : Como o usuário inicializa uma aplicação (Launching) e como apenas ativa novamente (Activating) ?

Para ficar mais claro o que causa cada evento, acompanhe uma sequencia de ações no telefone :

Você inicializa a aplicação no menu – está ocorrendo o Launching
Você aperta o botão “start” no telefone – Ocorre o Deactivating, a aplicação vai para o background
Você aperta “back” até voltar para a aplicação – Ocorre o Activating
Você bloqueia o telefone – Ocorre o Deactivating
O telefone é desbloqueado – Ocorre o Activating
Você aperta o botão “start” no telefone – Ocorre o Deactivating
Você inicializa novamente a aplicação pelo menu – Ocorre o Launching
Você aperta o “back” no telefone – Ocorre o Closing

Resumindo

Launching só ocorre quando a aplicação é inicializada pelo menu
Closing só ocorre quando pressiona-se “back” na aplicação
Deactivating ocorre pressionando “start” ou iniciando uma “task” (envio de e-mail, câmera, bloqueio, etc).
Activating ocorre ao retornar da “task” para a aplicação ou ao pressionar “back” até retornar para a aplicação
Após um Deactivating feito com “start”, chamar a aplicação pelo menu continua gerando um Lauching, o Activating pode não voltar a ocorrer.

Programando os eventos

Tudo em memória da aplicação é perdido entre o fechamento e a abertura. Por exemplo, o bloqueio do telefone fará a aplicação perder dados da tela. Cabe a aplicação fazer a gravação e recuperação de dados.

Nos eventos Launching e Activating as ações precisam ser assíncronas para garantir uma inicialização rápida da aplicação.

MVVM no Windows Phone : Código fonte e PPTs

noreply@blogger.com (Dennes) — Sun, 14 Aug 2011 03:02:00 +0000

O webcast na noite de sábado, 13/08, foi um sucesso, todos os participantes gostaram muito da demonstração do uso do padrão MVVM com uma aplicação no Windows Phone.

Baixe o código fonte e ppt da apresentação

Aproveite também e leia os seguintes posts ligados ao tema da apresentação :

MVVM no Windows Phone 7 e o Command Binding

CommandBehavior com foco e MessageBox

CommandBehavior e Processamento Assíncrono

CommandBehavior e Processamento Assíncrono

noreply@blogger.com (Dennes) — Wed, 10 Aug 2011 02:59:00 +0000

Esse é o 3o post sobre MVVM com behaviors no Windows Phone. Você pode querer ver os dois anteriores :

MVVM no Windows Phone 7 e Command Binding

CommandBehavior com Foco e MessageBox

Neste 3o post vamos tratar de processamento assíncrono.

No post anterior implementamos várias funcionalidades adicionais no CommandBehavior, após a execução do Command. Porém nem tudo são flores : Em muitas situações a execução do Command pode ser assíncrona. A execução pode retornar antes da tarefa se encerrar.

Neste caso não podemos simplesmente inserir as tarefas adicionais (foco e messagebox) após a execução do command. Precisamos que o command dispare um evento informando que a tarefa foi encerrada.

Vamos aos passos para essa implementação :

No RelayCommand, crie um evento Finalizou

          1: public event EventHandler Finalizou;

Ainda no RelayCommand, crie um método chamado Finalizar que dispare o evento Finalizou

         1: public void Finalizar()

         2: {

         3:     if (Finalizou != null)

         4:         Finalizou(this, new EventArgs());

         5: }

É a ViewModel que sabe quando a tarefa foi finalizada ou não, ela precisará disparar o método Finalizar

Altere o método “Clicou” do CommandBehavior para que as tarefas adicionais (foco e messagebox em nosso exemplo) sejam executadas apenas no evento Finalizou

         1: private void clicou(object sender, EventArgs e)

         2: {

         3:    

         4:     ((RelayCommand)CommandObject).Finalizou +=

         5:         (s, e2) =>

         6:         {

         7:                 if (ExibirErro)

         8:                 {

         9:                     if (((RelayCommand)CommandObject).ErrorMessage != string.Empty)

        10:                     { 

        11:                     MessageBox.Show(((RelayCommand)CommandObject).ErrorMessage);

        12:                     ((RelayCommand)CommandObject).ErrorMessage = string.Empty;

        13:                     }

        14:                 }

        15:                 if (Foco != string.Empty)

        16:                 {

        17:                     Control ct = null;

        18:                     ct = (Control)botao.FindName(Foco);

        19:                     if (ct != null)

        20:                     {

        21:                         ct.Focus();

        22:                     }

        23:                 }

        24:         };

        25:  

        26:     CommandObject.Execute(null);

        27:  

        28: }

É tarefa da ViewModel disparar o método Finalizar

Conclusão

O suporte a tarefas assíncronas é um passo muito importante para a estrutura do MVVM no Windows Phone.

Baixe o código fonte das classes

Encurt.z 1.0 no MarketPlace do Windows Phone

noreply@blogger.com (Dennes) — Wed, 03 Aug 2011 20:58:00 +0000

Está disponível a primeira aplicação da Búfalo para o Windows Phone : Encurt.z é uma aplicação para encurtar URL’s utilizando os recursos do migre.me.

É bem simples, como vocês irão notar, uma funcionalidade simples mas que ainda assim já foi útil várias vezes para mim.

A aplicação continua evoluindo e novos recursos serão adicionados, tal como a possibilidade de twittar direto da aplicação bem como acompanhar as estatísticas das URL’s encurtadas, além, também, de ver as notícias mais clicadas e retuitadas no migre.me.

Comentem o que acharam da aplicação e, para vocês, qual seria a funcionalidade mais prioritária a ser implementada.

A propósito : É GRÁTIS

Baixe agora a aplicação para seu Windows Phone

CommandBehavior com foco e MessageBox

noreply@blogger.com (Dennes) — Thu, 28 Jul 2011 03:47:00 +0000

Mostrei anteriormente como construir um CommandBehavior para usar MVVM no Windows Phone. Para o Silverlight a diferença é pequena (usar dependency property ao invés de bindingListener, mas isso é outro assunto).

Continuando com a aplicação de MVVM, existem pequenas tarefas para as quais é mais difícil evitar código na interface : atribuir o foco a um objeto, exibir uma messagebox, pequenas tarefas de interface.

O Prism propõem algumas soluções para isso, porém para problemas simples prefiro soluções mais simples e deixar o Prism para problemas mais complexos.

Vamos ver como implementar isso no CommandBehavior, o mesmo CommandBehavior do artigo anterior.

Atribuindo Foco a um objeto

Problema : Após o término da execução de um command, definir o foco em um determinado objeto.

Solução : O CommandBehavior é responsável pela execução do Command, então também pode, após a execução, definir o foco para um objeto.

Passo 1 : Criar uma propriedade chamada “Foco” que conterá o nome do objeto que receberá o foco.
   1: public string Foco
   2: { get; set; }
Passo 2 : Após a execução do Command, atribuir o foco ao objeto
   1: private void clicou(object sender, EventArgs e)
   2: { 
   3:     CommandObject.Execute(null);
   4:     if (Foco != string.Empty)
   5:     {
   6:         ((Control)botao.FindName(Foco)).Focus();
   7:     }
   8: }

Exibindo uma MessageBox de erro

Problema : Quando ocorrer um erro na execução do Command, exibir uma MessageBox com a mensagem de erro.

Solução : Mais uma vez o CommandBehavior pode verificar a existência de um erro e se encarregar de exibir a mensagem de erro.

Passo 1 : Criar uma propriedade no ICommand para guardar a mensagem de erro

Saber se ocorreu ou não um erro não é tarefa do Behavior, mas da ViewModel. A ViewModel pode preencher uma mensagem de erro no Command e o Behavior se encarrega apenas de exibir.
   1: public string ErrorMessage
   2: {
   3:     get;
   4:     set;
   5: }
Passo 2 : Criar uma propriedade boolean, “ExibirErro”, no Behavior, para ativar ou não a exibição da mensagem
   1: public bool ExibirErro
   2: {
   3:     get;
   4:     set;
   5: }
Passo 3 : Após a execução do Command, exibir a mensagem de erro.
   1: private void clicou(object sender, EventArgs e)
   2: { 
   3:     CommandObject.Execute(null);
   4:     if (Foco != string.Empty)
   5:     {
   6:         ((Control)botao.FindName(Foco)).Focus();
   7:     }
   8:     if (ExibirErro)
   9:     {
  10:         MessageBox.Show(((RelayCommand)CommandObject).ErrorMessage);
  11:         ((RelayCommand)CommandObject).ErrorMessage = string.Empty;
  12:     }
  13: }

Conclusão

Sem dúvida esse é apenas o inicio das possibilidades. Baseado nessas idéias você poderá criar soluções para vários outros problemas.

Baixe as classes usadas nesse exemplo

MVVM no Windows Phone 7 e o Command Binding

noreply@blogger.com (Dennes) — Wed, 27 Jul 2011 04:29:00 +0000

O problema que vou explicar – e resolver – neste artigo pode ser atingido de diversas formas diferentes, além de possuir diversas soluções diferentes.

Você pode estar sofrendo de um dos seguintes males :

Você não faz idéia de para onde foi a propriedade Command dos botões
Você fez uma implementação linda de ICommand e não sabe porque está recebendo AG_E_PARSER_BAD_PROPERTY_VALUE como resultado
Você está tentando usar o InvokeCommand Behavior e não sabe o que fazer com a propriedade CommandName

Tudo isso pode se resumir a um problema :

Você está tentando usar MVVM no Windows Phone 7 e está mais perdido do que cego em tiroteio

Primeiramente, vamos começar dando algumas respostas que irão explicar para você o porquê dos problemas :

Windows Phone 7 roda com Silverlight 3 e não Silverlight 4. Por isso muitas das comodidades com as quais você se acostumou no Silverlight 4 (tal como a propriedade Command nos buttons) não funcionam no Windows Phone.
Silverlight 3 apenas permite realização de databindings em objetos derivados de FrameworkElement. Para os demais, não tem DependencyProperty que salve.
Behaviors e afins não são derivados de FrameworkElement, portanto não não suportam databinding

Como Jack, vamos por partes.

Problema 1 : Como fazer MVVM sem a propriedade Command ?

A resposta é simples : Interactivity! Use Behaviors e afins para disparar o Command.

As soluções são tantas e tão variadas que até confunde :

Você pode criar uma trigger action que possa ser inserida e disparada de dentro de EventTriggers

Você pode usar o InvokeCommand action para disparar um command. Porém em seu formato silverlight 3 o InvokeCommand exige que exista um behavior anexado ao botão e ele irá se referir ao command pelo nome de command exposto pelo behavior.

Você pode criar um behavior que já faça a interceptação de um evento e o dispara do command.

Com soluções tão variadas a escolha chega perto de ser uma opção pessoal. Vou fazer as demonstrações neste texto com a 3a opção, um behavior.

Porém : Qualquer das 3 soluções morre na praia se não houver como vincular o objeto com o command via binding, sem isso é impossível criar uma solução genérica o que torna o trabalho de implementação muito grande.

Problema 2 : Como fazer Binding em propriedades de um Behavior no Silverlight 3 ?

A resposta é simples : Não dá. Precisamos contornar esse problema.

Se usarmos essa expressão abaixo em um objeto que não aceita Binding :

Command=”{Binding MeuCommand}”

O objeto considera que o valor “{Binding MeuCommand}” está sendo atribuido para a propriedade Command. Mas que valor é esse ? Simples : É um valor do tipo Binding

Primeiro passo para a solução : Fazer com que a propriedade seja do tipo Binding

Desta forma guardamos o binding dentro da classe e precisaremos apenas processá-lo para obter seu valor. Porém, como processar um Binding ?

Segundo passo para a solução : Criar uma attached property dummy no objeto pai que sirva para processar e obter o valor do binding.

Relativamente simples, uma solução de 2 passos, mas nem por isso deixa de ser um bacalhau muito feio.

Para o 2o passo, supostamente o mais trabalhoso, já temos uma classe criada com o nome de BindingListener, justamente para fazer esse trabalho. Como única solução, essa classe (mesmo sendo bacalhau) passou a fazer parte do Prism, framework da Microsoft para implementação de MVVM com Silverlight.

Veja detalhes sobre a implementação original do BindingListener

Problema 3 : Criar o Behavior

Nesta altura já não é um problema, já estamos com todas as ferramentas em mãos. É importante destacar, porém, que os exemplos que encontrei na web usando a classe BindingListener em geral continham erros, excesso de código desnecessário.

Vamos então fazer uma criação passo-a-passo do Behavior que chamaremos de CommandBehavior.

Passo 1 : Iniciando

É necessário uma referência para a biblioteca System.Windows.Interactivity

É necessário um using para System.Windows.Interactivity

Crie a classe CommandBehavior herdando de Behavior<Button>. O uso do generics indicará o tipo de objeto para o qual o behavior é feito.
   1: public class CommandBehavior : Behavior<Button>
   2: {
   3:  
   4: }

Passo 2 : Características Básicas

Crie uma variável privada do tipo button na qual guardaremos o button no qual o behavior está vinculado.

Faça um override do método onAttached para capturar o button no momento em que o behavior for vinculado ao button.

Capture o evento Click do button, é quando nosso behavior precisará fazer sua tarefa principal : Executar o Command.

Crie o método para o click do button, por enquanto vazio.
   1: public class CommandBehavior : Behavior<Button>
   2: {
   3:     Button botao;
   4:  
   5:     private void clicou(object sender, EventArgs e)
   6:     {
   7:  
   8:     }
   9:  
  10:     protected override void OnAttached()
  11:     {
  12:         base.OnAttached();
  13:         botao = this.AssociatedObject;
  14:         botao.Click += clicou;
  15:     }
  16: }

Passo 3 : Criando a propriedade Command

Crie uma variável privada do tipo Binding

Crie uma propriedade chamada Command do tipo Binding
   1: private Binding _Command;
   2:  
   3: public Binding Command
   4: {
   5:     get
   6:     {
   7:         return _Command;
   8:     }
   9:     set
  10:     {
  11:         _Command = value;
  12:     }
  13: }
Importante : Ao contrário de muitos exemplos na web, essa propriedade não precisa ser uma DependencyProperty, é justamente pelo fato dos behaviors não suportarem o trabalho com tais propriedades que teremos mais trabalho.

Passo 4 : ICommand

Crie uma propriedade chamada CommandObject do tipo ICommand, apenas com Get.

           1: private ICommand CommandObject

           2: {

           3:     get

           4:     {

           5:         

           6:     }

           7: }

Passo 5 : Utilizando o BindingListener

Defina uma variável privada do tipo BindingListener.
Crie um construtor para o CommandBehavior e instancie o BindingListener
Crie o tratamento para o change do BindingListener

Importante : o “change” do bindinglistener na verdade será executado só uma vez, quando ele se tornar “pronto” para fazer o trabalho com o binding.

Crie o método CanExecute
Crie o método para o evento CanExecuteChanged, chamando o CanExecute

           1: private BindingListener listener;

           2:  

           3: public CommandBehavior()

           4: {

           5:     listener = new BindingListener(MudouBinding);

           6: }

           7: private void MudouBinding(object sender, BindingChangedEventArgs e)

           8: {

           9:     CommandObject.CanExecuteChanged += MudouCanExecute;

          10:     CanExecute();

          11: }

          12: private void MudouCanExecute(object sender, EventArgs e)

          13: {

          14:     CanExecute();

          15: }

          16: private void CanExecute()

          17: {

          18:     if (CommandObject != null)

          19:         botao.IsEnabled = CommandObject.CanExecute(null);

          20: }

Preencha o Item do BindingListener no método AttachedTo
Preencha o Binding do BindingListener no set da propriedade Command
Preencha o get da propriedade CommandObject returnando o Command do Listener
Programe o Click para disparar a execução do Command

Veja como fica o código final do behavior :

           1: public class CommandBehavior : Behavior<Button>

           2: {

           3:     Button botao;

           4:  

           5:     private Binding _Command;

           6:     private BindingListener listener;

           7:  

           8:     public CommandBehavior()

           9:     {

          10:         listener = new BindingListener(MudouBinding);

          11:     }

          12:     private void MudouBinding(object sender, BindingChangedEventArgs e)

          13:     {

          14:         CommandObject.CanExecuteChanged += MudouCanExecute;

          15:         CanExecute();

          16:     }

          17:     private void MudouCanExecute(object sender, EventArgs e)

          18:     {

          19:         CanExecute();

          20:     }

          21:     private void CanExecute()

          22:     {

          23:         if (CommandObject != null)

          24:             botao.IsEnabled = CommandObject.CanExecute(null);

          25:     }

          26:  

          27:     public Binding Command

          28:     {

          29:         get

          30:         {

          31:             return _Command;

          32:         }

          33:         set

          34:         {

          35:             _Command = value;

          36:             listener.Binding = _Command;

          37:         }

          38:     }

          39:  

          40:     private ICommand CommandObject

          41:     {

          42:         get

          43:         {

          44:             return (ICommand)listener.Value;

          45:         }

          46:     }

          47:  

          48:     private void clicou(object sender, EventArgs e)

          49:     {

          50:         CommandObject.Execute(null);

          51:     }

          52:  

          53:     protected override void OnAttached()

          54:     {

          55:         base.OnAttached();

          56:         botao = this.AssociatedObject;

          57:         botao.Click += clicou;

          58:         listener.Element = botao;

          59:     }

          60: }

Parte 6 : Utilizar o Behavior

Uma vez pronto, utilizar o Behavior é a parte fácil.

           1: <Button Content="Clique-me" Name="button1">

           2:     <i:Interaction.Behaviors> 

           3:         <bh:CommandBehavior Command="{Binding CriarGrupoCommand}" />

           4:     </i:Interaction.Behaviors>

           5: </Button>

Concluindo

Vimos como resolver, da forma mais simples possível, o problema de bindings no Windows Phone, passando a poder implementar MVVM no Wndows Phone.

Lembre-se que a classe BindingListener já faz parte do Prism, portanto chega-se a mesma solução usando o Prism.

Baixe aqui as classes BindingListener e CommandBehavior

Criando um Behavior no Silverlight

noreply@blogger.com (Dennes) — Tue, 26 Jul 2011 05:07:00 +0000

Mostrei anteriormente como criar uma property extension no silverlight para resolver o problema do binding com a textbox. Vamos neste novo post solucionar o mesmo problema, só que desta vez com um behavior ao invés de uma property extension.

Este é o 3o de uma sequencia de 3 posts, veja os dois anteriores :

Binding com TextBox

Automatizando o UpdateSourceTrigger

Vejamos os passos para criar o Behavior. Partindo de um projeto Silverlight :

Faça uma referência para System.Windows.Interactivity

Adicione uma nova classe chamada UpdateSourceBehavior

Adicione um using para System.Windows.Interactivity

Altere a classe para que herde de Behavior<TextBox>

A especificação de “TextBox” indica o objeto no qual esse behavior poderá ser aplicado.

Crie uma variável privada chamada txt, do tipo TextBox
   1: public class UpdateSourceBehavior : Behavior<TextBox>
   2: {
   3:     TextBox txt;
   4:  
   5: }
Faça um override no método OnAttached, capture a textbox e o evento TextChanged
   1: protected override void OnAttached()
   2: {
   3:     base.OnAttached();
   4:     txt = this.AssociatedObject;
   5:     txt.TextChanged += mudou;
   6: }
Programe o método “mudou” para fazer o UpdateSource da propriedade Text
   1: private void mudou(object sender, TextChangedEventArgs e)
   2: {
   3:     txt.GetBindingExpression(TextBox.TextProperty).UpdateSource();
   4: }
No XAML adicione o namespace System.Windows.Interactivity e o namespace da classe UpdateSourceBehavior

Altere a tag da textbox para que fique como abaixo.
   1: <TextBox Name="txtURL" Text="{Binding Path=Url, Mode=TwoWay}">
   2:     <i:Interaction.Behaviors>
   3:         <bh:UpdateSource />
   4:     </i:Interaction.Behaviors>
   5: </TextBox>

Conclusão

O Behavior é mais simples de aplicar do que a extension property, especialmente porque pode ser aplicado através do Expression Blend

SQL Server error 15372 : Failed to generate a user instance

noreply@blogger.com (Dennes) — Thu, 21 Jul 2011 10:11:00 +0000

Já peguei este erro ocorrendo diversas vezes com o SQL Express. O SQL Server não consegue gerar a instância de servidor e a aplicação não roda. A mensagem detalhada com código aparece apenas no Event Viewer.

A solução, apesar de não muito clara, é mais simples do que parece : Basta eliminar os arquivos contidos na pasta gerada pela user instance do SQL Express.

O caminho da pasta : c:\user\<usuario>\appdata\Local\Microsoft\Microsoft SQL Server Data

Apague todo o conteúdo desta pasta e o sql server express volta a funcionar.

Automatizando o UpdateSourceTrigger

noreply@blogger.com (Dennes) — Tue, 19 Jul 2011 04:00:00 +0000

Vimos anteriormente como resolver o binding da textbox usando o UpdateSourceTrigger. Porém ter que programar isso para várias textbox pode ser um trabalho desagradável, além de ser uma codificação que precisa ficar na interface, dificultando o trabalho do designer.

Então vamos ver formas de automatizar a aplicação do UpdateSourceTrigger. Além disso todos os casos que veremos podem ter utilidades bem mais amplas.

Extensions

O Silverlight (e também o WPF) nos permite criar extensões para os controles. Assim sendo podemos criar para os controles existentes novos atributos que podem inclusive alterar as funcionalidades existentes.

Uma extensão é basicamente uma Dependency Property. As dependency properties podem ser, ao invés de simplesmente “registradas”, “anexadas” a um objeto.

Em nosso exemplo, no momento em que a atribuição da propriedade é disparada, podemos interceptar o evento TextChanged para causar o disparo do método UpdateSource no momento correto.

Vamos partir do mesmo exemplo anterior para montar nossa extensão. Passo-a-Passo :

(continuando a partir do exemplo anterior)

1) Elimine o código do TextChanged

2) Adicione uma nova Silverlight Class Library na solução, com o nome de prjExtensao

3) Adicione uma classe chamada Extensao

4) Na classe Extensao, crie a Dependency Property utilizando o código abaixo :

          1: public static readonly DependencyProperty TextChangeUpdateSourceTriggerProperty =

         2:     DependencyProperty.RegisterAttached("TextChangeUpdateSourceTrigger",

         3:     typeof(bool), typeof(Extensao),

         4:         new PropertyMetadata((bool)false,

         5:         new PropertyChangedCallback(mudou)));

Vamos analisar cada trecho deste código :

A) A Dependency Property ficará “guardada” em um atributo estático chamado TextChangeUpdateSourceTriggerProperty

B) Nunca instanciamos uma Dependency Property, a instância é gerada pelo método Register ou, neste caso, RegisterAttached, que indica que esta propriedade será aplicada em outros controles (qualquer outro controle).

C) O primeiro parâmetro do RegisterAttached, “TextChangeUpdateSourceTrigger” é o nome da Dependency Property.

D) O 2o parâmetro, typeof(bool), é o tipo da propriedade, boolean.

E) O 3o parâmetro, typeof(Extensao), é a classe em que a propriedade está contida

F) O último parâmetro é uma instância da classe PropertyMetadata, que nos auxilia a definir mais algumas características da propriedade.

G) O primeiro parâmetro da PropertyMetadata é o valor default da propriedade, false.

H) O 2o parâmetro da PropertyMetadata é um callBack que será chamado quando a propriedade receber o seu valor. É neste método – mudou – que começaremos a programar a lógica que desejamos.

5) Crie o get/set da propriedade conforme o código abaixo :

         1: public static bool GetTextChangeUpdateSourceTrigger(DependencyObject d)

         2: {

         3:     return (bool)d.GetValue(TextChangeUpdateSourceTriggerProperty);

         4: }

         5:  

         6: public static void SetTextChangeUpdateSourceTrigger(DependencyObject d, bool value)

         7: {

         8:     d.SetValue(TextChangeUpdateSourceTriggerProperty, value);

         9: }

Como pode-se observar pelo código acima, o get/set de uma dependency property é bem diferente de uma propriedade tradicional.

6) Programar o método “mudou” conforme o código abaixo :

         1: private static void mudou(DependencyObject d, DependencyPropertyChangedEventArgs e)

         2: {

         3:     TextBox textBox = d as TextBox;

         4:     if (textBox == null)

         5:         return;

         6:  

         7:     bool novoValor = 

         8: (bool)d.GetValue(TextChangeUpdateSourceTriggerProperty);

         9:  

        10:     if (NovoValor)

        11:         textBox.KeyUp += OnTextChanged;

        12:     else

        13:         textBox.KeyUp -= OnTextChanged;

        14: }

A) É necessário garantir que a propriedade foi aplicada no tipo de objeto que esperamos. Se esperamos uma textbox mas a propriedade é aplicada em um botão, todo o código dará errado.

B) Recuperamos o valor atribuido a propriedade.

C) Processamos o valor. Em nosso caso, se true capturamos evento KeyUp, se false retiramos nosso tratador de evento do KeyUp

7) Programe o OnTextChange conforme abaixo :

         1: static void OnTextChanged(object sender, KeyEventArgs e)

         2: {

         3:     if ((e.Key == Key.Tab) || (e.Key == Key.Enter))

         4:         return;

         5:  

         6:     TextBox textBox = sender as TextBox;

         7:     var binding = textBox.GetBindingExpression(TextBox.TextProperty);

         8:     if (binding!=null)

         9:         binding.UpdateSource();

        10: }

A) Se a tecla for ENTER ou TAB, não processamos, pois o foco será mudado e o resultado não é adequado.

B) Recuperamos a textBox

C) Recuperamos a BindingExpression da propriedade Text

D) Existindo a BindingExpression, chamamos o UpdateSource

8) No projeto Silverlight, adicionamos uma referência para a Silverlight Class Library

9) No XAML adicione uma referência ao namespace prjExtensao :

xmlns:ex="clr-namespace:prjExtensao;assembly=prjExtensao"

10) Adicione o novo atributo na textbox :

ex:Extensao.TextChangeUpdateSourceTrigger="True"

11) Teste a aplicação. A textbox fará atualização do label a cada tecla, exatamente como estava com o código do TextChanged.

Resultado : Criamos uma alteração no comportamento da textbox que pode ser aplicada em qualquer textbox com o uso de um simples atributo. Isso facilita o trabalho de designers, evitando codificação na interface.

Training Kits Microsoft

noreply@blogger.com (Dennes) — Thu, 14 Jul 2011 14:13:00 +0000

A Microsoft tem o habito de disponibilizar training kits, pacotes que envolvem aplicações de exemplo para o estudo das mais diversas tecnologias.

Eis abaixo uma lista de Training Kits disponibilizados pela Microsoft para o estudo de tecnologias de desenvolvimento :

Visual Studio 2010 and .NET 4 Training Kit http://www.microsoft.com/download/en/details.aspx?id=23507

Windows Azure Training Kit http://www.microsoft.com/download/en/details.aspx?id=8396

SQL Server 2008 R2 for Developers Training Kit http://www.microsoft.com/download/en/details.aspx?id=16281

Silverlight 4 Training Kit http://www.microsoft.com/download/en/details.aspx?id=10409

LightSwitch Beta 2 Training Kit http://www.microsoft.com/download/en/details.aspx?id=23746

WCF and WF Samples for .NET Framework 4 http://www.microsoft.com/download/en/details.aspx?id=21459

Windows 7 Training Kit for Developers http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=6450

PHP on Windows and SQL Server Training Kit: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=c8498c9b-a85a-4afa-90c0-593d0e4850cb

Identity Developer Training Kit: http://www.microsoft.com/downloads/details.aspx?familyid=C3E315FA-94E2-4028-99CB-904369F177C0&displaylang=en

Office 2010 Developer Training Kit: http://www.microsoft.com/download/en/details.aspx?displayLang=en&id=23519

SharePoint 2010 Developer Training Kit: http://www.microsoft.com/downloads/details.aspx?FamilyID=bfd1603b-7550-4b8e-be85-4215a5069b90

Windows Server 2008 R2 Developer Training Kit: http://www.microsoft.com/downloads/details.aspx?FamilyID=c48b3eb4-ad4b-461c-9d5a-25f45d949b92&displaylang=en

Windows Phone 7 Training Kit for Developers: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=ca23285f-bab8-47fa-b364-11553e076a9a

Windows Mobile 6.5 Developer Tool Kit: http://www.microsoft.com/downloads/details.aspx?familyid=20686A1D-97A8-4F80-BC6A-AE010E085A6E&displaylang=en

Windows Azure Training Kit: http://www.microsoft.com/downloads/en/details.aspx?familyid=413e88f8-5966-4a83-b309-53b7b77edf78

SharePoint 2010 and Silverlight 4 Training Kit: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=ada43555-f785-4553-b5c7-6c17a499a6e0

BizTalk 2010 Training Kit: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=38c2ccfc-510c-4627-a33c-95e9d19f3478

Windows Server AppFabric Training Kit: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=7290f7ed-e86b-4114-a452-4f07fa32403d

Web Camps Training Kits: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=0a906559-28bd-4f5d-ac18-f895a200a2a5

Office 365 Developer Training Kit: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=E731BF34-FF5C-444E-9AD8-962D804B4D6A&displaylang=en

Windows Phone codenamed "Mango" Training Course: http://msdn.microsoft.com/en-us/WP7MangoTrainingCourse

Dynamics CRM 2011 Developer Training Kit: http://www.microsoft.com/downloads/en/details.aspx?FamilyID=78498c29-28ac-440b-9c20-ec5da6ee6e98&displaylang=en

SharePoint and Windows Azure Development Kit: http://www.microsoft.com/download/en/details.aspx?id=24398

Esqueci de algum ?

Video Dicas BufaloInfo–No 1

noreply@blogger.com (Dennes) — Wed, 13 Jul 2011 10:28:00 +0000

Estou inaugurando um canal no YouTube dedicado a vídeos com dicas técnicas, o canal será chamado de Video Dicas BufaloInfo.

A primeira dica, cujo vídeo está abaixo, é sobre a WebGrid do ASP.NET MVC e mostra ainda um pouco do uso do JQuery com ASP.NET MVC.

Comentários, opiniões, sugestões, dúvidas, pedido de novos assuntos, tudo é bem vindo, use os comentários.

Fixando Titulo e Colunas de uma GridView

noreply@blogger.com (Dennes) — Wed, 13 Jul 2011 07:35:00 +0000

Inspirado por uma pergunta que encontrei no MSDN Brasil, resolvi pesquisar mais sobre o assunto, achei até mesmo que fosse simples, pois tinha certeza de já ter escrito sobre isso anteriormente.

Resumindo : O objetivo é que em uma gridview com muito conteúdo em colunas e linhas possa ser utilizada uma barra de rolagem para visualizar o conteúdo, porém o título e algumas colunas iniciais possam ficar fixas durante a rolagem.

Realmente sobre isso antes escrevi : Podem ver uma dica aqui

O problema é que essa dica, amplamente divulgada por toda a web, só funciona até o IE 7.0, outros browsers esta dica não funciona.

Já inspirado, resolvi solucionar o problema com JQuery. A solução não ficou tão simples, mas graças ao JQuery isso é fácil de resolver : Criei um um plugIn para o JQuery, facilitando assim a aplicação desta solução.

Passo a Passo

Crie uma nova ASP.NET Empty Web Application

Adicione um webform

Adicione um sqlDataSource no WebForm com a seguinte query : SELECT [CustomerID], [CompanyName], [ContactName], [Address], [City], [Country] FROM [Customers]

Adicione uma gridView com edição, exclusão e ordenação, mas sem paginação

No page_load, acrescente o código abaixo para gerar o THEAD e o TBODY – o plugIn foi criado para funcionar com estas tags
Saiba mais sobre essas tags em TBODY, THEAD : JQuery e a Gridview e Melhorando a GridView : CoolGrid no CodePlex

Configure a propriedade clientIDMode da GridView para Static

Com essa configuração garantimos que a tag gerada pela gridview no client terá o mesmo ID que a GridView, facilitando a programação client

No source, em volta da GridView, adicione uma DIV de forma a limitar o espaço ocupado pela gridview, da seguinte forma :
   1: <div style="height:200px;width:500px;overflow:auto" id="divtabela">
   2:     <gridview ... />
   3: </div>
Teste a aplicação e observe a gridview com barras de rolagem

Crie uma pasta Scripts no projeto

Acrescente no projeto os scripts do JQuery

Acrescente no projeto o script do fixGrid, o plugIn criado (pegue-o em http://fixgrid.codeplex.com/)

Acrescente no webForm o script do JQuery e o script do PlugIn. O código no HEAD da página fica da seguinte forma :
   1: <script src="Scripts/jquery-1.4.1.js" type="text/javascript"></script>   1:  
   2: <script src="Scripts/fixGrid.js" type="text/javascript">
</script>
Programe em JQuery a colocação do título e colunas fixas na GridView, veja como fica :
   1: <script language="javascript" type="text/javascript">
   2:     $(function () {
   3:         $("#GridView1").fixarGrid(2);
   4:     })
   5: </script>
Teste a página para verificar o resultado

Código Fonte

Sem dúvida o código fonte ainda pode ser bastante melhorado, exatamente por isso disponibilizei o projeto deste plugIn no CodePlex em http://fixgrid.codeplex.com/

Idéias e desenvolvedores são muito bem vindos para a melhoria deste plugin.

Solução : SQL Server não encontra objeto no Schema Default

noreply@blogger.com (Dennes) — Mon, 11 Jul 2011 20:01:00 +0000

O bom uso dos schemas é uma novidade do SQL Server 2005 em diante, se popularizando mais a partir do SQL Server 2008.

É normal, portanto, que muitos desenvolvedores ainda não façam, ou não saibam fazer, um bom uso dos schemas.

Com isso o problema exposto acima, apesar de ter uma explicação técnica simples, pode ainda pegar muitos desenvolvedores desprevinidos.

Problema : Os objetos de banco encontram-se em um schema personalizado, não no schema dbo. Apesar do usuário da aplicação estar configurado usando o schema personalizado como default, os objetos não são encontrados. Logando-se no query analyzer com o mesmo usuário o problema também acontece, como se o schema default do usuário não fosse respeitado.

Motivo : O atributo schema default não tem efeito para usuários com permissão de sysadmin. Isso, simples assim. Um sysadmin sempre terá como schema default o schema DBO.

Solução : Para de usar usuários que pertençam a role sysadmin. Pode até usar usuários que sejam dbowner, mas sysadmin sempre terá esse problema

É muito interessante observar que essa característica do SQL Server leva os desenvolvedores a adotarem um comportamento mais adequado para aplicações reais :

Parar de usar sysadmin como usuário da aplicação
Passar a usar nomes de tabela qualificados com o schema na escrita SQL

Cuidado com SDKs, Tools, Toolkits e afins

noreply@blogger.com (Dennes) — Mon, 04 Jul 2011 17:06:00 +0000

Observei um padrão muito desagradável com alguns tipos de instalação, tais como esses que citei acima.

Com as versões de cada ferramenta avançando em escala exponencial, é frequente termos que atualizar estas instalações. Nestas horas é comum que algo inesperado aconteça :

Se confiamos que a nova instalação vai se virar corretamente sobre a antiga, recebemos durante a instalação uma mensagem de falta de arquivos – mensagem estranha, pois parece estar procurando por um arquivo que pertence a própria instalação.

Se tentamos fazer a desinstalação da versão mais antiga, a desinstalação falha, nos deixando sem ter para onde correr

Veja a causa disso

Essas instalações são baixadas em pacotes compactados, mas com a extensão .EXE
A primeira coisa que ocorre durante a instalação é a descompactação destes pacotes em um diretório na raiz do C: que recebe como nome um GUID (Global Unique Identifier : “c93308540a5c70e5cea8”)

Neste diretório-GUID fica o real instalador, que é disparado e a instalação executada.
O caminho deste diretório-GUID é registrado no windows e será usado para chamar o desinstalador quando desejarmos
Nós olhamos o monte de diretórios-guid na raiz do C: com cara de paisagem e, acreditando serem restos, deletamos. Não farão falta, até tentarmos desinstalar…

Exemplos

Já peguei exatamente estes casos com atualização das tools do Silverlight e atualização do Zune.

O principal sintoma é a reclamação de falta de arquivo, especialmente quando a instalação busca o arquivo em um diretório-GUID e nos deixa com cara de paisagem sem saber porque ela – a instalação – está procurando um arquivo que não existe.

Solução

Ter muita paciência e experiência para excluir do registry chave da instalação do registro. Enquanto fazia isso com o Zune me lembrava dos conceitos que estudei nos treinamentos de WOSSA I e WOSSA II. Alguém ai lembra disso ? Eram ótimos treinamentos !

Usar uma ferramenta para eliminar a força uma aplicação. Estou experimentando o Revo Uninstaller Pro, ainda muito desconfiado da eficácia.

Não estamos sós !

Veja um desabafo sobre este tipo de problema : http://geekswithblogs.net/go281/archive/2011/06/10/the-end-of-windows-as-we-know-it.aspx

Binding com TextBox

noreply@blogger.com (Dennes) — Mon, 13 Jun 2011 06:44:00 +0000

A textbox possui uma característica especial em seu binding que apenas se torna mais perceptível quando utilizamos MVVM ou quando envolvemos a textbox em algum binding um pouco menos tradicional.

Indo direto ao ponto : Quando o mode é twoway, a textbox apenas atualiza a origem do binding no evento lostfocus e não no evento change.

Em muitos casos isso é um resultado agradável : evita um excesso de processamento a cada tecla pressionada na textbox.

Porém existem algumas situações especiais, algumas validações, ativação e desativação de botões e outras em que nós gostaríamos que a interface reagisse a cada tecla pressionada. Como fazer ?

Vamos primeiro reproduzir esse problema em uma Silverlight Application :

1) Crie uma nova Silverlight Application

2) Adicione uma textbox, um botão e um label

3) Faça um binding na textbox entre a propriedade text e a propriedade content do label

4) Teste a aplicação

Resultado : Por mais que digite na textbox, o label apenas será atualizado depois que a textbox perder o foco e não de acordo com a digitação. A textbox só atualiza a origem do binding no lostfocus e não no change.

Para resolver isso podemos utilizar o atributo UpdateSourceTrigger do binding. O primo rico, WPF, possui mais opções no UpdateSourceTrigger, dai que apenas esse atributo seria suficiente para resolver o problema.

No Silverlight, porém, o máximo que podemos fazer é definir o UpdateSourceTrigger com Explicit. Com esta definição passa a ser nossa responsabilidade – e não mais da textbox – fazer uma atualização da origem do binding. Se não fizermos, o binding funcionará apenas como se fosse OneWay.

A programação do evento TextChanged para atualizar a origem do binding fica da seguinte forma :

          1: private void textBox1_TextChanged(object sender, TextChangedEventArgs e)

         2: {

         3:     textBox1.GetBindingExpression(TextBox.TextProperty).UpdateSource();

         4: }

Vamos decifrar essa linha de código :

GetBindingExpression : Método de todos os controles silverlight que nos permite recuperar uma expressão de Binding utilizada no objeto

TextBox.TextProperty : Toda propriedade, para permitir a realização de Binding, é criada na forma de uma Dependency Property. O método GetBindingExpression pede como parâmetro esta Dependency Property, que sempre encontraremos como um elemento estático da classe do controle que estamos utilizando.

UpdateSource : Método do objeto BindingExpression para atualizar a origem do binding quando este é TwoWay. Só tem utilidade para o caso do UpdateSourceTrigger=Explicit

Feito isso, teste novamente a aplicação e descobrirá que agora o label é atualizado

Compilando e Mesclando Dictionaries

noreply@blogger.com (Dennes) — Wed, 08 Jun 2011 08:37:00 +0000

Estilos, temas e outros recursos inseridos em resource dictionaries são recursos altamente reutilizáveis, em alguns casos desejaremos reutilizá-los até mesmo em outros projetos e para isso precisaremos compilar os resource dictionaries em class libraries (.dll) para podermos utiliza-las amplamente em outros projetos.

Compilar um Resource Dictionary

Essa sem dúvida é a parte fácil do trabalho :

1) Crie uma silverlight class library

2) Adicione um resource dictionary. Pode ser na raiz do projeto ou pode criar pastas para organizar múltiplos dictionaries.

3) Compile

URI para diferentes Assemblies

Uma questão sobre dictionaries compilados é como fazer referência a eles a partir de nossa aplicação. Uma questão importante é o fato de que as URI’s que utilizamos no silverlight poderem fazer referência a elementos em outras DLL’s e não apenas dentro da DLL principal.

Destaco essa questão da referência pois dictionaries compilados é apenas uma de suas utilidades. As URI’s permitem fazer referência a qualquer .xaml compilado em DLL diferente. Podemos, por exemplo, carregar uma página compilada em uma DLL diferente.

A questão é : Como escrever uma URI para outra DLL ?

/<assembly>;component/[<path>/]<arquivo>.xaml

Onde :

<assembly> : O nome do assembly no qual encontra-se o resource dictionary, sem uso do “.DLL”.

[<path>/] : O caminho do arquivo .xaml em relação a raiz da class library. Em uma class library com vários dictionaries ou outros elementos, os dictionaries podem ser separados em multiplas pastas para melhor organização.

<arquivo> : Nome do arquivo do resource dictionary

Importante observar que a palavra “component” é fixa.

Exemplos :

/meuassembly;component/dictionary.xaml

/meuassembly;component/dicionarios/dictionary.xaml

Mesclando Resource Dictionaries

A mesclagem de dictionaries é a forma de utilizar os dictionaries compilados : Eles precisam ser mesclados com o application dictionary.

Veja a síntaxe de mesclagem :
   1: <Application.Resources>        
   2:     <ResourceDictionary>            
   3:         <ResourceDictionary.MergedDictionaries>
   4:             <ResourceDictionary Source="/MeuAssembly;component/Dictionaries/TextBox.xaml" />                
   5:         </ResourceDictionary.MergedDictionaries>
   6:     </ResourceDictionary>
   7: </Application.Resources>
Parece simples, mas essa síntaxe possui algumas sutilezas muito interessantes. O principal é responder a duas questões :

A) Como mesclar vários dictionaries ?

Dentro do elemento ResourceDictionary.MergedDictionaries pode-se adicionar vários resource dictionaries, gerando a mesclagem

B) Como fazer a mesclagem em um application dictionary que possui outros elementos ?
A mesclagem não pode ser “simplesmente adicionada” junto a outros elementos do application dictionary. Existem duas possibilidades : pode-se adicionar os demais elementos dentro da tag resource dictionary, mas fora de MergedDictionaries; ou adicionar os elementos como um outro resource dictionary a ser mesclado.

Veja o local correto marcado no trecho abaixo :
   1: <Application.Resources>        
   2:     <ResourceDictionary>            
   3:         <ResourceDictionary.MergedDictionaries>
   4:             <ResourceDictionary Source="/slUtils;component/Dictionaries/TextBox.xaml" />
   5:     <ResourceDictionary>
   6:         Local Correto
   7:     </ResourceDictionary>                
   8:         </ResourceDictionary.MergedDictionaries>
   9:     Local Correto
  10:     </ResourceDictionary>
  11:     Local Errado
  12: </Application.Resources>

BackGround Value Converter

noreply@blogger.com (Dennes) — Tue, 07 Jun 2011 15:11:00 +0000

Vejamos mais um exemplo de value converter para deixar mais clara a versatilidade deste recurso.

Em relação ao background, a idéia é ter um value converter que transforme um valor numérico em uma cor de acordo com uma regra de negócio específica, permitindo que valores possam ser destacados em meio a interface.

Menos reutilizável que o anterior, o exemplo desde value converter mostra a versatilidade desta classe na implementação de regras da interface.

Veja como fica o código :

        1: public class FundoValueConverter : IValueConverter

       2: {

       3:  

       4:     #region IValueConverter Members

       5:  

       6:     public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

       7:     {

       8:         if (string.IsNullOrEmpty((string)value))

       9:             return new SolidColorBrush(Colors.White);

      10:  

      11:         decimal valor = Decimal.Parse((string)value);

      12:  

      13:         if (valor < 1000)

      14:             return new SolidColorBrush(Colors.Blue);

      15:         else if (valor <= 3000)

      16:             return new SolidColorBrush(Colors.Yellow);

      17:         else

      18:             return new SolidColorBrush(Colors.Red);

      19:     }

      20:  

      21:     public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

      22:     {

      23:         throw new NotImplementedException();

      24:     }

      25:  

      26:     #endregion

      27: }

A forma de aplicação é a mesma do exemplo anterior :

1) Cria-se a classe em uma silverlight class library

2) Inclui-se o converter como um resource na interface

3) Utiliza-se o converter em um binding, neste caso entre a propriedade background e uma propriedade que contenha o valor em questão.

Pode-se usar esse exemplo de value converter em um binding com o background de uma célula da datagrid, por exemplo.