Acabou de ser publicado meu segubndo artigo no www.codeproject.com, onde mostro como criar um controle que realiza uma pesquisa nos itens de um menu.

Veja o post: Improving user experience using WPF and LINQ

No WPF é possivel criar estilos para todo controle visual. Hoje quero mostrar como fazer um estilo que fará com que o controle onde ele está aplicado faça um fade ao ser carregado. Ou seja, qdo a Window abrir, seus controles irão surgir aos poucos. O style pode ser definido como a seguir:

<Page.Resources>
       <Style x:Key="FadeIn" TargetType="FrameworkElement">
           <Style.Triggers>
               <EventTrigger RoutedEvent="FrameworkElement.Loaded">
                   <BeginStoryboard>
                       <Storyboard>
                           <DoubleAnimation
               Storyboard.TargetProperty="(FrameworkElement.Opacity)"
               From="0.0" To="1.0" Duration="0:0:3"/>
                       </Storyboard>
                   </BeginStoryboard>
               </EventTrigger>
           </Style.Triggers>
       </Style> 
</Page.Resources>

Nota: aqui coloquei o estilo em um resource da página que estou usando, mas é totalmente indicado que se crie arquivos de resource para essas situações.

Para utilizar esse estilo:

<TextBlock Name="Message" Text="This is a test." Margin="5,5,5,5"  Style="{StaticResource FadeIn}"/>

<TextBlock Name="Message2" Text="This is a test2." Margin="5,5,5,5"  Style="{StaticResource FadeIn}"/>
<TextBox Width="100" Height="30" Margin="5,5,5,5"  Style="{StaticResource FadeIn}"/>
<Button Content="Fade" Margin="5,5,5,5"  Style="{StaticResource FadeIn}"/>

Como nosso style tem como target o tipo FrameworkElement, podemos aplicá-lo até mesmo em um stackpanel e automaticamente todo seu conteúdo sofrerá o fade:

<StackPanel Orientation="Horizontal" Grid.Row="0" VerticalAlignment="Center" Style="{StaticResource FadeIn}">
            <TextBlock Name="Message" Text="This is a test." Margin="5,5,5,5"  />
            <TextBlock Name="Message2" Text="This is a test2." Margin="5,5,5,5"  />
            <TextBox Width="100" Height="30" Margin="5,5,5,5"  />
            <Button Content="Fade" Margin="5,5,5,5" />
</StackPanel>

Fica aí a dica!

Atualmente estou trabalhando com WPF… e uma das coisas que mais gosto é o mecanismo de DataBinding… simplesmente fantástico!

Mas

para que seus objetos de negócio possam ser utilizados adequadamente pelo databinding, é necessário que sejam implementadas algumas interfaces…

São elas:

• INotifyPropertyChanged – Notifica as mudanças de valores em propriedades
• IEditableObject – Permite que um objeto se torne “editável”, podendo desfazer alterações
• IDataErrorInfo – Adiciona recursos de validação aos objetos, permitindo que a UI seja notificada disso e possa apresentar adequadamente essa situação

Deixo aqui pra vcs a minha implementação disso tudo. Essas classes são utilizadas por mim como base de meus objetos… espero que ajudem a todos que estejam começando com esse incrível framework que é o WPF.

Infelizmente não consigo entrar no SkyDrive… acho que é Telefônica… mas fiz o upload para o Rapidshare:

Baixem aqui!!!

Abraço!

Vale, e muito, assistir!

Todos sabemos que manter um relacionamento MxN é chato. E claro que ao utilizar uma ferramenta ORM podemos minimizar essa dor de cabeça.  Imaginem que em seu banco de dados exista a seguinte situação:

Nosso modelo de objetos está da seguinte forma:

Observe que em nenhum momento temos alguma classe que representa a tabela associativa TURMA_X_ALUNO. É no mapeamento das classes que vamos indicar a existência dessa tabela e informar ao NHibernate que a coleção Turmas e Alunos devem utilizá-la. Vamos ver primeiramento o mapeamento da classe Aluno.

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Dominio"  namespace="Dominio" >
  <class name="Aluno" table="ALUNO" >
    <id name="Id" column="ID_ALUNO" type="Int32" unsaved-value="0">
        <generator class="hilo"/>
    </id>
    <property name="Nome" column="NOME" type="string" length="100" not-null="true" />
    <idbag name="Turmas" table="TURMA_X_ALUNO" generic="true" lazy="true" cascade="save-update" inverse="true">
      <collection-id type="Int32" column="ID_TURMA_X_ALUNO">
        <generator class ="hilo"/>
      </collection-id>
      <key column="ID_ALUNO" />
      <many-to-many class="Turma" column="ID_TURMA"/>
    </idbag>
  </class>
</hibernate-mapping>

Destaquei em azul a parte que nos interessa. Veja que utilizamos uma idbag para representar a coleção de  Turmas. Ela foi utilizada porque nossa tabela associativa possui uma chave primária própria, que está mapeada na tag colection-id. Em vermelho estão destacadas coisas importantes também. Definimos que a tabela que mantém a coleção de Turmas é nossa tabela associativa e informamos ao NHibernate que não é por aqui que vamos realizar as associações. Isso quer dizer que não vamos adicionar turmas aos alunos mas sim, alunos às turmas existentes. Então se eu fizer algo assim:

Aluno.Turmas.Add(novaTurma);

Essa nova associação não será salva, porque a marcamos com inverse=true. Depois dizemos que essa mesma associação é many-to-many, informando também de qual classe. Dessa forma, automaticamente o NHibernate já sabe como preencher a lista Turmas.   Quanto ao mapeamento de Turma, é semelhante, veja.

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" assembly="Dominio"  namespace="Dominio" >
  <class name="Turma" table="TURMA" >
    <id name="Id" column="ID_TURMA" type="Int32" unsaved-value="0">
      <generator class="hilo"/>
    </id>
    <property name="Descricao" column="DESCRICAO" type="string" length="100" not-null="true" />

    <idbag name="Alunos" table="TURMA_X_ALUNO" generic="true" lazy="true" cascade="save-update">
      <collection-id type="Int32" column="ID_TURMA_X_ALUNO">
        <generator class ="hilo"/>
      </collection-id>

      <key column="ID_TURMA" />
      <many-to-many class="Aluno" column="ID_ALUNO"/>
    </idbag>
  </class>
</hibernate-mapping>

A diferença é que não especificamos aqui a tag inverse=true  é porque é por aqui que vamos realizar as associações. Veja um teste feito:

            Configuration cfg = new Configuration();
            cfg.Configure();
            cfg.AddAssembly(typeof(Aluno).Assembly);
            ISessionFactory factory = cfg.BuildSessionFactory();
            ISession session = factory.OpenSession();
            ITransaction transaction = session.BeginTransaction();

            Aluno objAluno1 = new Aluno();
            objAluno1.Nome = "Paulo Quicoli";

            Aluno objAluno2 = new Aluno();
            objAluno2.Nome = "Sem Nome";

            session.Save(objAluno1);
            session.Save(objAluno2);

            Turma objTurma = new Turma();
            objTurma.Descricao = "Teste de MxN";

            objTurma.Alunos.Add(objAluno1);
            objTurma.Alunos.Add(objAluno2);

            session.Save(objTurma);
            try
            {
                transaction.Commit();
                session.Flush();
            }
            catch
            {
                transaction.Rollback();
            }
            finally
            {
                session.Close();
                Console.ReadLine();
            }

É muito simples manter esse tipo de relacionamento com o NHibernate, o detalhe como sempre, é acertar no mapeamento.   Observe também que não estou usando mais ids do tipo identity, após recomendação do meu último post…

Abraço a todos…

Hoje Tuna Toksoz fez um post interessante no site do NHibernate. Ele explica porque evitar o uso do Identity. Vou resumir o post aqui.

Basicamente quando se usa o Identiy, o recurso de batching do NHibernate fica impossibilitado de ser aplicado. Ele mostra isso utilizando os seguintes códigos:

   1:  [Test]

   2:  public void Should_not_insert_entity_in_a_transaction_HiLo()

   3:  {

   4:      var post = new PostWithHiLo {Title = "Identity Generators Revealed"};

   5:      var postComment = new PostCommentWithHiLo { Post = post, Comment = "Comment" };

   6:      using (ISession session = factory.OpenSession())

   7:      using (var tran = session.BeginTransaction())

   8:      {

   9:          session.Save(post); //No commit here

  10:          session.Save(postComment);

  11:          long insertCount = factory.Statistics.EntityInsertCount;

  12:          Assert.That(insertCount, Is.EqualTo(0), "Shouldn't insert entity in a transaction before commit.");

  13:      }

  14:  }

  15:   

  16:  [Test]

  17:  public void Should_not_insert_entity_in_a_transaction_Identity()

  18:  {

  19:      var post = new PostWithIdentity {Title = "Identity Generators Revealed"};

  20:      var postComment = new PostCommentWithIdentity {Post = post, Comment = "Comment"};

  21:      using (ISession session = factory.OpenSession())

  22:      using (var tran = session.BeginTransaction())

  23:      {

  24:          session.Save(post);

  25:          session.Save(postComment);

  26:          long insertCount = factory.Statistics.EntityInsertCount;

  27:          Assert.That(insertCount, Is.EqualTo(0), "Shouldn't insert entity in a transaction before commit.");

  28:      }

  29:  }

No primeiro teste, que não utiliza Identity, nada é enviado para o banco. Já no segundo teremos 2 comandos INSERT enviados ao banco.  Isso significa que podemos enfrentar problemas de performance, já que o banco será acessado várias vezes.

Pra finalizar ele mostra um último exemplo:

   1:  using (ISession session = factory.OpenSession())

   2:  using (var tran = session.BeginTransaction())

   3:  {

   4:      for (int i = 0; i < 3; i++)

   5:      {

   6:          var post = new PostWithHiLo {Title = string.Format("Identity Generators Revealed {0}", i)};

   7:          session.Save(post);

   8:      }

   9:      tran.Commit();

  10:  }

Neste caso os três comandos INSERT que são gerados, só são enviados após o commit e de uma vez só ao banco. Se estivéssemos utilizando Identity, a cada Save teríamos um INSERT sendo enviado.

Para ver o post completo, acesse o link: http://nhforge.org/blogs/nhibernate/archive/2009/03/20/nhibernate-poid-generators-revealed.aspx

Até mais!

Antes que eu comece, talvez você esteja se perguntando o que é a sigla LOB. LOB são as iniciais de Line of Business. Quando é dito que uma aplicação é LOB, dizemos que ela segue a linha de uma aplicação comercial. Refazendo então a pergunta, o wpf está pronto para aplicações comerciais?.

Vamos rever um pouco a história. Tínhamos cartões perfurados, depois teclados, monitores de fósforo branco, depois verdes e até laranjados. O mouse então ganhou seu espaço…. lembram de um programa chamado DOSSHELL? Era uma espécie de windows explorer do DOS, muito legal para a época.

Hoje ainda temos o mouse, mas a interação do usuário com um sistema informatizado está mudando. Temos webcams, videos, sons, telas sensíveis ao toque, até ao multi-toque. Os monitores estão cada vez maiores, em alta definição, internet, GPS, wireless. A imersão do usuário em relação ao computador evoluiu em muito nos últimos 15 ou 20 anos.

Acredito que a Microsoft percebeu isso e viu algo no futuro, alguns anos a frente e decidiu apostar em algo novo, substituindo sua plataforma gráfica. Trocando o GDI pelo WPF. O GDI possui suas limitações, a principal que vejo é estar preso a pixels. O WPF por sua vez é independente de resolução e ainda pode utilizar o poder de processamento da placa gráfica instalada no micro para renderizar a interface de um aplicativo.

O WPF também oferece recursos necessários para se criar aplicações que satisfaçam as necessidades visuais dos usuários. Ainda temos aí o windowsforms e vamos continuar a tê-lo por um bom tempo. Mas até quando? Creio que aos poucos ele vai deixar de ser utilizado, mas não por determinação da Microsoft e sim pelas escolhas dos usuários finais.

Imagine que você vai comprar um carro. Você vê um Toyota e um Civic. Ambos são similares em qualidade, recursos e segurança e digamos, tem o mesmo preço. Qual você compraria? Com certeza o que você acha mais bonito. Com as aplicações vai acontecer a mesma coisa. Se você possui uma máquina razoável, e lhe é apresentado o mesmo sistema teoricamente só que um utilizando formulários comuns, e outro usando WPF, permitindo requintes de visualização que melhoram a interatividade com o usuário, com qual você ficaria?

Nos EUA já existe uma grande adoção pela tecnologia. Até mesmo a própria Microsoft a está adontando, como prova de sua estabilidade e segurança. Sabe a nova versão do Windows Live Messenger? É feita com WPF. Até mesmo o Dynamics, um CRM/ERP da Microsoft, já possui módulos em WPF. Essa adesão está tomando lugar.

Outro ponto que me chama a atenção está por parte da comunidade de usuários. Em suas listas de discussão muito se fala em como fazer  a coisa certa. Separar as camada de interface da camada de lógica. Um padrão de projeto, utilizado no desenvolvimento do Blend, é divulgado e espalhado pela comunidade, o MVVM (Model-View-ViewModel). Quando você viu algo assim no início do windowsforms?

Por isso digo, sim. O WPF está pronto para o desenvolvimento de aplicações comerciais. Temos o suporte de uma comunidade muito ativa, componentes, mesmo que de terceiros. Contudo isso não significa que vamos sair migrando tudo, mas, se você têm um projeto para os próximos 3 ou 5 anos, comece já em WPF. Isso porque a oferta desenvolvedores nessa área estará maior, creio eu.

Agora existe um ponto importante. Você desenvolvedor, que não é designer… não fique preso apenas aos recursos visuais que o WPF oferece. Ou, contrate algum designer para fazer a interface pra você. Com WPF isso é facilmente possível. Acredito que cada um deve estar no seu lugar. Um exemplo de uma aplicação WPF é o próprio Windows Live Messenger. Une uma boa interface com uma usabilidade legal. Agora, um exempo de um não tão bom programa WPF para o usuário final é o *Chirp, ou agora chamado Blu. Ele é um cliente twitter, segue o link pra vocês baixarem: http://www.thirteen23.com/experiences/desktop/blu/

Mas porque ele não é bom? Veja a Figura abaixo. O primeiro programa é o Blu. O segundo é o TwitterFox.

Bem, não dá nem pra comparar o visual não é? Mas e a experiência do usuário, a usabilidade da coisa? Em seu blog, Tamir Khason apresenta uma lista dos problemas do Blu:

• Utiliza 140MB  de memória;
• Não é possivel ocultá-lo 
• Não notifica novo twitters sem ter que exibir a janela principal do programa
• É necessário presscionar um botão update para ser notificado 
• If you not finished typing, you can either dismiss all text of post it.
• Não é possível digitar mais de 140 caracteres. Se você cola um texto maior, o texto é truncado.
• Para operar o programa, é exigido o mouse
• Não existe uma scrollbar para a lista de twitters exibidos, ou seja, você não pode correr para o último. É preciso passsar um a um.

Vamos ao TwitterFox:

• 10MB de RAM apenas
• Ao clicar no “X” ou pressionar ESC, ele é ocultado 
• Oferece recurso que notifica de novos twitters sem ter que abrir a tela principal
• Once focused text are become active, expanded automatically and ready to write
• Você pode digitar mais de 140 caracteres, contudo ele avisa qdo o limite é excedido permitindo que você ajuste o texto.
• Pode ser operado via teclado.

Para mais detalhes dos problemas funcionais do blu acesse este post: http://khason.net/blog/line-of-business-vs-beautifulness-or-two-dogmas-comparison-as-exemplified-by-two-twitter-applications/ .

Portanto, uma coisa é fato. A beleza de uma aplicação não é tudo… o WPF veio literalmente unir o útil ao agradável. Uma boa aparência com uma grande usabilidade.

Pensem nisso, e comentem, sintam-se à vontade.

Se você está desevolvendo em WPF, segue aqui um ótimo exemplo:

Essa aplição é fruto de um treinamento acontecido lá fora (USA) explicando o padrão M-V-VM e como utilizá-lo de forma eficiente. Mais detalhes a respeito deste demo, acesse o site do Jaime Rodriguez.

Os links pra download:

Apresentação

Código Fonte

Em breve darei minhas considerações sobre o uso do WPF em aplicações comerciais….

O grupo DevMedia, responsável por várias revistas técnicas de informática, incluindo a .NET Magazine, está promovendo um concurso muito legal.

Você pode escrever um artigo técnico, seja C#, Java, Delphi, SQL… o que você souber de melhor, e envia para a DevMedia.  Os melhores autores ganharão vários prêmios… (leiam aí um PS3 !!!)

Não percam!!!!!

Mais detalhes aqui

Pessoal, descobri hoje que a Telerik possui uma ferramenta ORM. O OPENACCESS, e o mais legal, possui uma versão free. Essa versão free possui todos os recursos da versão paga, a única “limitação” é trabalhar apenas com os seguintes bancos free: MS SQL Server Express, Oracle Express, MySQL e Firebird.

Alguns recursos:

• Assistentes integrados ao VS2008;
• Lazy Loading;
• Estratégias de cache;
• Estratégias de Fetching;
• Suporte ao Linq;
• Mapeamento a partir do seu modelo de classes ou a partir de um banco de dados.

Sou fã de carteirinha do NHibernate mas vou dar uma olhadinha nisso :)

Mais detalhes em: http://www.telerik.com/products/orm/features.aspx

Nesta semana está acontecendo na UNAERP, em Ribeirão Preto/SP, a 12ª semana da tecnologia. Ontem pude realizar uma palestra sobre NHibernate. Quero agradecer a todos que compareceram e à comissão organizadora.

Infelizmente o tempo não foi suficiente pra mostrar tudo o que gostaria, de qualquer forma, estou aqui para retirar qualquer dúvida.

obrigado!

Estou liberando aqui um pequeno exemplo que mostra como utilizar o NHibernate em um aplicação WPF, empregando o padrão M-V-VM. Além disso utilizo também uma implementação do padrão Repository e Unit of Work, ambos descritos pelo NHibernate FAQ. Este demo utiliza a versão Embedded do Firebird 2.1 e para rodar é necessário apenas um pequeno ajuste no arquivo aliases.conf, localizado na pasta debug da aplicação. O ajuste a ser feito é apenas informar o path correto da localização do banco de dados. Qualquer dúvida é só deixar um recado aqui.

PS.: Estou com o tempo curto, por isso não fiz um post explicando como tudo foi feito….

No último sábado pude participar de uma ótima reunião com o pessoal da DevMedia. Recebemos alí orientações sobre o processo editorial e tudo mais, aliás, souo o novo editor técnico da ClubeDelphi. Abaixo seguem algumas fotos, infelizmente aquele dia estava chuvoso, mas pude ver o quanto que o Rio de Janeiro é bonito.

Ao ler esta matéria no site do Baboo fiquei entusiasmado ao saber que a MS irá oferecer o programa Students to Business ao alunos da FATEC e ETE. Sou formado pela FATEC, unidade Taquaritinga, e hoje imagino como seria interessante participar desse programa.

Mas olhando mais longe e citando um colega aqui do trabalho, “A Microsoft está formando discípulos”. Se pararmos para pensar nessa declaração, realmente esse acordo tem o objetivo de angariar mais desenvolvedores para a plataforma .NET ou usuários das ferramentas MS.

Imagine quantos novos profissionais sairão para o mercado conhecendo a tecnologia .NET ? Ao longo dos anos eu acredito que grande parte dos sistemas que serão desenvolvidos utilizarão ASP.NET, ASP.NET MVC, WPF, WCF… porque a Microsoft irá “doutrinar” os futuros profissionais do mercado.

Agora temos que questionar algumas coisas:

• O quanto isso é bom para o mercado?
• O mercado não ficará saturado disso ?
• Existem outras plataformas e linguagens, como Java, Delphi, Ruby… com o crescimento de novos profissionais .NET, como ficará a procura por essas outras linguagens ?

Além de pensar nesse futuro uma coisa de hoje é fato. A microsoft tem investido muito em sua plataforma de desenvolvimento. Não digo investindo em propaganda, mas em qualidade. Posso dizer que ela está se reinventando nisso. Versões gratuitas, comunidades para  discutir engenharia, como a ALT.NET, maior atenção aos usuários de suas ferramentas, e muito mais…

É um bom momento pra imaginarmos como estará o mercado daqui 4 ou 8 anos e apostarmos nossas fichas. Pensem nisso!

Pessoal… fiquei supreso com esse abaixo assinado… tem gente importante na coisa …

olhem: http://efvote.wufoo.com/forms/ado-net-entity-framework-vote-of-no-confidence/

olha quem votou: http://efvote.wufoo.com/reports/entity-framework-vote-of-no-confidence-signatories/#public

É gente... só quem é desenvolvedor sabe como é isso....

Baixem aqui : VS2008 SP1