Programação do dia 13/09/2010

13:45 – 15:00

Título: Dicas, truques do Visual Studio 2010 e novas funcionalidades do Visual Basic e C# 
Palestrante (s): João Paulo Clementi, Renato Haddad,
Sala: Cantareira 5
Público: Desenvolvedores / Profissionais de TI

15:30 – 16:45

Título: Desenvolvimento com C# no mundo moderno 
Palestrante (s): Alfred Myers,
Sala: Cantareira 5
Público: Desenvolvedores / Profissionais de TI

17:15 – 18:30

Título: Scrum Process Template para TFS 2010: Seja ágil de verdade! – 150 min 
Palestrante (s): André Dias, Giovanni Bassi,
Sala: Cantareira 5
Público: Desenvolvedores / Profissionais de TI

Programação do dia 14/09/2010

09:00 – 10:15

Título: Novidades e razões para migrar para o Microsoft .Net Framework 4 
Palestrante (s): Diego Blanco, João Paulo Clementi,
Sala: Cantareira 5
Público: Desenvolvedores / Profissionais de TI

10:45 – 12:00

Título: Meu site anda meio lento… e eu não sei mais o que fazer! 
Palestrante (s): Vinicius Canto Xavier,
Sala: Cantareira 3
Público: Desenvolvedores / Profissionais de TI

13:45 – 15:00

Título: O Projeto Mono: Aplicações .NET para sistemas não-Windows 
Palestrante (s): Alessandro Binhara,
Sala: Santana 1
Público: Desenvolvedores / Profissionais de TI

15:30 – 16:45

Título: Implementando Serviços RESTful usando o Microsoft .NET Framework 
Palestrante (s): Israel Aece,
Sala: Cantareira 5
Público: Desenvolvedores / Profissionais de TI

17:15 – 18:30

Título: Aumentando a produtividade através da Geração de Código no Visual Studio  
Palestrante (s): Otavio Pecego Coelho,
Sala: Cantareira 5
Público: Desenvolvedores / Profissionais de TI

Programação do dia 15/09/2010

09:00 – 10:15

Título: Um mergulho no ADO.NET Entity Framework 4 
Palestrante (s): Renato Haddad,
Sala: Cantareira 5
Público: Desenvolvedores / Profissionais de TI

10:45 – 12:00

Título: Como e onde devo utilizar o Managed Extensibility Framework (MEF)  
Palestrante (s): Rogério Moraes de Carvalho,
Sala: Jardim São Paulo
Público: Desenvolvedores / Profissionais de TI

13:45 – 15:00

Título: Discutindo sobre: Linq to Sql, Entity Framework Versus Stored Procedures 
Palestrante (s): Luciano Condé,
Sala: Cantareira 6
Público: Desenvolvedores / Profissionais de TI

15:30 – 16:45

Título: Paralelismo no .Net 4.0: Patterns, dicas e truques 
Palestrante (s): Otavio Pecego Coelho,
Sala: Jardim São Paulo
Público: Desenvolvedores / Profissionais de TI

17:15 – 18:30

Título: Explorando as ferramentas de arquitetura do Visual Studio 2010 
Palestrante (s): Daniel Oliveira,
Sala: Cantareira 5
Público: Desenvolvedores / Profissionais de TI

Reusar código é uma boa idéia, então provavelmente seria uma boa idéia reaproveitar códigos em uma dll que forneça serviços por exemplo.Normalmente nós desenvolvedores reusamos uma dll construida com funções básicas. Desde .net 1.1 é possível compartilhar dlls entre aplicações usando o global cache assembly. Este espaço existe em qualquer maquina com o framework instalado, para começar a usar é necessário que o assembly a ser registrado possua um “Nome forte” que entre outras coisas é responsável por identificar de maneira única o assembly.

Criando um nome forte para o assembly

Após a configuração veja que foi gerado um arquivo com extensão .snk

Adicionar assembly na aba referêncy do Visual Studio

Após esta configuração temos um assembly com o nome forte, agora falta registrar o mesmo no GAC.Antes de registrar vamos mover o assembly para a pasta:

%Program Files%\Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies

Com o assembly nesta pasta o visual studio reconhece nossa dll como uma dll do .NET, assim fica mais facil adicionar referências.

Registrando o assembly

Para registrar o assembly vamos usar o utilitário gacutil. o comando é gacutil /i nomedoassembly.dll

Agora já é possível criar aplicativos que possuem como referência um assembly registrado no GAC. Para adicionar a referência basta procurar na aba .NET do visual studio.

E quando eu alterar o assembly adicionado no GAC?

Quando um assembly do GAC for alterado será necessário registrar novamente o mesmo e reiniciar o visual studio para que ele atualize a sua referência de desenvolvimento. Como no projeto que surgiu a necessidade de usar o GAC estamos constantemente editando o projeto adicionado nós criamos um script para execução no Build Events do projeto. Se alguem precisar so script pode comentar aqui que eu explico como funciona.

Validação apenas no client side
Este modelo é inviável para uma aplicação enterprise, pois toda a regra de execução está no layout, se uma nova interface fosse criada regras teriam que ser copiadas e adicionadas ao novo projeto. Com o tempo aprendi que a validação client-side(app web) é apenas para melhorar a interação do cliente com a aplicação e que uma validação no lado servidor é necessária para segurança da aplicação.

Validação client-side e server side
Desta maneira temos a validação client-side para melhorar a interface com o usuário e ainda temos a validação do lado servidor capaz de validar a execução. Neste modelo a validação server side pode ser reaproveitada em outros projetos de interface. No entanto já tive problemas com duplicação de código de validação que era difícil de manter.

Validação client-side e server side *(usando façades)
Usando o último modelo decidi por criar uma camada de validação usando um Validation facade, tentando assim isolar código de validação da minha regra de negócio efetivamente. Cheguei a usar com sucesso o modelo de validação até que chegou a integração asp.net mvc+ data annotations

Validação usando Data annotations(client side e server side)
Usando data annotations é possível manter informações de validação na propria entidade(classe) e ainda reaproveitar o código tanto para client-side  e server side. Ai tudo parecia perfeito! mas e quando eu criar um novo projeto de interface sem suporte ao data annotations? deveria escrever um código para funcionar com data annotations em outra interface como uma app WCF. então..

Validação usando Data annotations+ enterprise library 5.0
A versão 5.0 do enterprise library tem suporte ao data annotations, então agora poderia reaproveitar o data annotations para projetos mvc usando a estrutura que já existe e ainda poderia usar data annotations em outras interfaces através do entlib e ter a mesma qualidade /padrão de informar dados inválidos(nome do campo+mensagem). E se quiser poderia usar a validação do mvc com o entlib.

Novo modelo proposto com Data annotations + enterprise library 5.0 + code contracts
Estou na fase de definição do modelo de validação de um novo projeto, estou pensando em adotar o último modelo adotado quando estiver trabalhando com métodos que recebem entidades como parâmetros que podem ser validadas. Nos casos de métodos que apenas recebem parâmetros vou usar code contracts para definir e alertar quais validações devem ser realizadas para a execução ocorrer com sucesso.

Questões sobre o modelo proposto

Eu ainda estou estudando algumas opções neste modelo, o que fazer por exemplo quando o usuário passa uma  id que deveria ser da tabela pessoa e o ID não existe? a interface de usuário deveria possibilitar a seleção correta do id? como o negócio deveria se comportar? lançando uma exceção?

   1: string name = default(String);

   2: string nickName = default(String);

Exemplo 1:

   1: if (name != nickName)

   2:     Console.WriteLine("Diferentes");

Exemplo 2:

   1: if (!name.Equals(nickName))

   2:     Console.WriteLine("Diferentes");

Exemplo 3:

   1: if (!nickName.Equals(name))

   2:     Console.WriteLine("Diferentes");

Qual o resultado? é a mesma coisa?

O problema!

Interface de repositório

   1: /// <summary>

   2: /// Repositorio para o tipo ObjectSummary

   3: /// </summary>

   4: public interface IObjectSummaryRepository

   5: {

   6:     /// <summary>

   7:     /// Recupera um objectSummary de acordo com o cdObj

   8:     /// </summary>

   9:     /// <param name="cdObj"></param>

  10:     /// <returns></returns>

  11:     ObjectSummary GetObjectSummary(Int32 cdObj);

  12: }

Segue uma implementação SQL do Repositório

   1: internal class ObjectSummarySQLRepository : IObjectSummaryRepository

   2: {

   3:     private const string TABLE = "ObjectSummary";

   4:     QueryManager queryManager;

   5:  

   6:     public ObjectSummary GetObjectSummary(int cdObj)

   7:     {

   8:         StringBuilder sbSQL = new StringBuilder();

   9:         sbSQL.AppendLine("SELECT cdObj, dsTitle, dsSubtitle, obsSummary, nmFile, idLstRecipient, cssClassLogoClientCover,");

  10:         sbSQL.AppendLine(" cssClassLogoASKCover, cssClassLogoClientDetail,cssClassLogoASKDetail, footer, flgShowFooterInCover, idGru");

  11:         sbSQL.AppendLine(" FROM ObjectSummary WITH(NOLOCK) where cdObj=@cdObj ");

  12:         String sqlCommand = sbSQL.ToString();

  13:  

  14:         NameValueCollection sqlParams = new NameValueCollection();

  15:         sqlParams.Add("@cdObj", cdObj.ToString());

  16:         return ConvertRowToEntity(queryManager.FetchSingleObject(sqlCommand, sqlParams).Rows[0]);

  17:      }

  18: }

Uma implementação fake do repositório para testar em memória

   1: public class ObjectSummaryFakeRepository : IObjectSummaryRepository

   2:    {

   3:        public ObjectSummary GetObjectSummary(int cdObj)

   4:        {

   5:            if (cdObj == 1)

   6:            {

   7:                ObjectSummary objectSummary = new ObjectSummary();

   8:                objectSummary.ObjectSummaryID = 1;

   9:                objectSummary.CssClassLogoASKCover = "CssClassLogoASKCover";

  10:                objectSummary.CssClassLogoASKDetail = "CssClassLogoASKDetail";

  11:                objectSummary.CssClassLogoClientCover = "CssClassLogoClientCover";

  12:                objectSummary.CssClassLogoClientDetail = "CssClassLogoClientCover";

  13:                objectSummary.FileName = "FileName";

  14:                objectSummary.Footer = "Footer";

  15:                objectSummary.GroupID = 1;

  16:                objectSummary.ListRecipientID = 1;

  17:                objectSummary.ShowFooterInCover = true;

  18:                objectSummary.SubTitle = "SubTitle";

  19:                objectSummary.Summary = "Summary";

  20:                objectSummary.Title = "Title";

  21:                return objectSummary;

  22:            }

  23:            return null;

  24:        }

  25:    }

Alguns testes:

   1: [TestFixture]

   2: public class TestObjectSummaryRepository

   3: {

   4:     private IObjectSummaryRepository objectSummaryRepository;

   5:  

   6:     [SetUp]

   7:     public void SetUp()

   8:     {

   9:         objectSummaryRepository = new ObjectSummaryFakeRepository();

  10:     }

  11:     [Test]

  12:     public void TestGetGetObjectSummary_NonExistent()

  13:     {

  14:         Assert.IsNull(objectSummaryRepository.GetObjectSummary(2));

  15:     }

  16:     [Test]

  17:     public void TestGetGetObjectSummary_ShouldReturnValueObject()

  18:     {

  19:         Assert.IsNotNull(objectSummaryRepository.GetObjectSummary(1));

  20:     }

  21: }

Como vocês podem ver os testes não trazem ROI algum! Qual o sentido de testar se existe um objeto no contexto fake? esses são tipos de testes para o ego.

Melhores opções

1-Podemos escrever os testes usando transações, inserindo dados para os testes no SetUp e excluindo-os no TearDown. Desta maneira estaremos ao menos testando o código SQL. O problema é o tempo que os testes vão levar..

2-Podemos usar as coleções em memória apenas para testar relacionamentos entre os objetos.

Continuação da discussão

Este assunto é debatido no grupo DNA

Considere o simples xml abaixo:

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <entities>

   3:   <entity>

   4:     <name value="Carlos"></name>

   5:   </entity>

   6: </entities>

Temos o seguinte XSLT com algumas chamas a funções:

   1: <xsl:stylesheet version="2.0"

   2:   xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

   3:   xmlns:fo="http://www.w3.org/1999/XSL/Format"

   4:   xmlns:xhtml="http://www.w3.org/1999/xhtml"

   5:   xmlns:xslFunctions="urn:MyXslExtensions"

   6: >

   7:   <xsl:template match="entities/entity">

   8:     <xsl:value-of select ="xslFunctions:WriteMyContent()"/>

   9:     -

  10:     <xsl:value-of select ="xslFunctions:WriteEntityName(.)"/>

  11:   </xsl:template>

  12:  

  13: </xsl:stylesheet>

Logo no cabeçalho podemos reparar uma nova definição:

   1: xmlns:xslFunctions="urn:MyXslExtensions"

Aqui estou definindo um novo namespace de nome xslFunctions e defino que ele será encontrado na urn:urn:MyXslExtensions

O arquivo MyXslExtensions está no mesmo namespace mas vocês vão ver que poderia estar em qualquer outro, segue a definição do arquivo:

   1: namespace XmlExtensionsUsingCSharp

   2: {

   3:     public class MyXslExtensions

   4:     {

   5:         public String WriteMyContent()

   6:         {

   7:             return "MyXslExtensionstext";

   8:         }

   9:         public String WriteEntityName(System.Xml.XPath.XPathNodeIterator node)

  10:         {

  11:             var entityElements = node.Current.SelectChildren("name", "").GetEnumerator();

  12:             String text = String.Empty;

  13:             while (entityElements.MoveNext())

  14:             {

  15:                 text += (entityElements.Current as XPathNavigator).GetAttribute("value", "");

  16:             }

  17:             return text;

  18:         }

  19:     }

  20: }

   1: XslTransform xsl = new XslTransform();

   2:  

   3:           //passando caminho do xslt

   4:           xsl.Load(AppDomain.CurrentDomain.BaseDirectory + "XsltFile.xslt");

   5:  

   6:           System.IO.MemoryStream memoryStream = new System.IO.MemoryStream();

   7:  

   8:           XmlWriter xmlWriter = new XmlTextWriter(memoryStream, System.Text.Encoding.Default);

   9:  

  10:           //Carregando as extensões customizadas

  11:           XsltArgumentList xsltArgumentList = new XsltArgumentList();

  12:           //adiciono uma extensão com a mesma urn definida no xslt

  13:           xsltArgumentList.AddExtensionObject("urn:MyXslExtensions", new MyXslExtensions());

  14:  

  15:           //Inicio a transformação

  16:  

  17:           XmlDocument xmlDocument = new XmlDocument();

  18:           xmlDocument.Load(AppDomain.CurrentDomain.BaseDirectory + "XMLFile1.xml");

  19:           xsl.Transform(xmlDocument, xsltArgumentList, xmlWriter, null);

  20:  

  21:           Byte[] buffer = new Byte[memoryStream.Length];

  22:           buffer = memoryStream.ToArray();

  23:           String content = System.Text.Encoding.Default.GetString(buffer);

  24:           lblValue.Text = content;

Voltando ao xslt podemos ver as chamadas para as funções customizadas:

   1: <xsl:value-of select ="xslFunctions:WriteMyContent()"/>

Apenas executamos uma função que retorna uma string

   1: <xsl:value-of select ="xslFunctions:WriteEntityName(.)"/>

Executamos uma função que recebe o nó corrente como parâmetro e navega no mesmo usando Xpath para obter o atributo value do elemento name que é filho do elemento entity(elemento corrente no momento da execução)

Grupo on-line de arquitetura
http://groups.google.com.br/group/dotnetarchitects

Coding-Dojo
http://rodrigovidal.net/?tag=dotnetarchitects

Reuniões técnicas e barchitects
http://twitter.com/NetArchitectsRJ

Fique de olho nas urls e nos blogs dos participantes que você vai ficar sabendo de todas as novidades.

Build
Significa o mesmo que compilar, apenas os arquivos alterados desde o ultimo build são processados.Este é o processo indicado.

Rebuild
Neste caso todos os arquivos alterados ou não são processados, deve ser utilizado quando existe necessidade de sincronia talvez por alterações no projeto.

Run
Todos os arquivos alterados são atualizados pelo VS e apenas os mesmos são processados

extra: Estava lendo um blog que dizia ser possível compilar apenas o arquivo corrente(sendo editado) usando o comando Ctrl+F7, não sei se meus atalhos estão diferentes mas a ferramenta não mudou nada.

fonte:

http://petesbloggerama.blogspot.com/2007/12/visual-studio-difference-between-build.html

fonte:

http://blogs.msdn.com/adonet/archive/2010/02/18/entity-framework-feature-ctp-3-now-available.aspx