VS 2012 : Code Map

 

O Visual Studio 2012 nos traz um novo recurso muito interessante para o entendimento de códigos complexos : O Code Map.

Basta clicarmos com o botão direito em nosso código e encontramos as opções referentes ao funcionamento do Code Map. Implementei um pequeno trecho de código em um webform para fazer um teste.

Veja o código :

        protected void Button2_Click(object sender, EventArgs e)
        {
            ListBox1.DataSource = Dados();
            ListBox1.DataBind();
        }

        private List<int> Dados()
        {
            List<int> l = new List<int>();
            for (var i = 0; i <= 10; i++)
            {
                l.Add(i);
            }

            return l;
        }

        protected void Button3_Click(object sender, EventArgs e)
        {
            ListBox1.DataSource = null;
            ListBox1.DataBind();
        }

O objetivo do Code Map é, claro, lidar com códigos bem mais complexos que esse, porém isso nos ajudará a analisarmos o resultado.

Com o cursor em Button2_Click, cliquei com o botão direito e selecionei “show on code map”

O resultado é extremamente simples :

Clicando em “Show related Itens”  selecionei “Show fields this references”. Como resultado, visualizamos a listbox no Code Map :

Novamente em “Show Related Items”, cliquei em “Show methods this calls”. Como resultado temos o método “Dados” e a indicação “External” (referente ao databind), veja :

Ainda no “Show Related Items”, cliquei em “Show containing type”, veja o resultado :

 

O click em “Find all references”, ultimo item do “Show Related Items”, não gerou nada novo no gráfico, o que já era esperado. Ocorre que todos os itens estão sendo executados para o objeto circulado de amarelo – o objeto selecionado que é o método click do button2.

Desta vez selecione a listbox e utilizei “Find all references” do “Show related items”. Temos então o Button3_click adicionado no gráfico :

É importante destacar que o gráfico não é estático : Conforme navegamos no código uma seta aponta para nós exatamente o ponto em que estamos no gráfico.

O gráfico apenas se completa conforme pedirmos. Por exemplo, não há ainda uma indicação de que o método Dados faz chamada externa. Se utilizarmos o “Show methods this calls” com o Dados selecionado, teremos isso no gráfico.

Clicando sobre um dos itens, vemos um menu flutuante com mais opções para manipularmos o gráfico. Podemos, por exemplo, criar comentários :

O agrupamento se mostra útil, mas deve ser utilizado com moderação, já que os relacionamentos para fora do grupo partem do grupo, não dos itens individuais, dificultando a leitura da imagem :

As opções para criação de flags, criação de novos itens e novas associações que não existem no código também podem ser úteis, mas especialmente esses dois últimos devem ser utilizados com moderação.

Sem dúvida, um excelente novo recurso para o Visual Studio.

Veja um outro exemplo de gráfico criado sobre o webform do exemplo em …. :

>> Não acabou não, mané, tem mais ai, clica e contine lendo ...<<

Onde foi parar o Create Unit Test no Visual Studio 2012 ?

 

O Visual Studio 2012 tem muitas novidades em relação a testes unitários, mas nem tudo são flores. A Microsoft está evoluindo o Visual Studio para suportar vários frameworks de teste, tal como NUnit, deixando de estar “preso” apenas com o framework de teste do visual studio.

Se por um lado isso é bom, deram também um grande passo atrás : eliminaram da interface do Visual Studio 2012 a instrução “Create unit test…” que era acessível pelo menu de contexto dos métodos.

Isso é muito ruim, pois faz com que os testes unitários tenham que ser criados do zero, algo muito desagradável.

A instrução, na verdade, ainda existe internamente no Visual Studio, apenas sumiu da interface. Uma alternativa que temos é adicionar novamente a instrução na interface do visual studio.

Isso pode ser feito com os seguintes passos :

1) Abra a janela Tools –> Options –> Environment –> KeyBoard

2) Em “Show Commands Containing” digite “createunit” para localizar facilmente a instrução correta.

3) Selecione a opção “Text Editor” em “New Shortcut”

4) Clique na caixa “Press shortcut keys” e pressione a combinação de teclas que deseja.

Em meu VS atribui a instrução ao CTRL+T, assim sendo posso utilizar essa combinação para disparar a criação de um novo unit test.

Para saber mais sobre as mudanças, veja um WalkThrough sobre Unity Tests no VS 2012 : http://msdn.microsoft.com/en-us/library/ms182532.aspx

>> Não acabou não, mané, tem mais ai, clica e contine lendo ...<<

Testabilidade em WebForms : Fazendo Mocks de Request

A classe Page, base para todo webform, possui propriedades Request, Response, Session, Server e Application que são frequentemente utilizadas no ASP.NET para manipularmos a comunicação, sessão e obtermos informações do servidor.

Para podermos executar testes unitários é absolutamente necessário que possamos fazer mocks dessas propriedades e desta forma rodar os testes sem a necessidade de rodar a página em um servidor.

Porém essas propriedades devolvem instâncias de tipos sealed, sem interfaces implementadas, impedindo a realização de mocks.

Para resolver esse problema surgiu no framework .NET a classe HttpContextWrapper e as classes “Base” : HttpRequestBase, HttpResponseBase e outras. Ao contrário das classes originais, essas classes “Base” são abstratar, permitindo facilmente o uso de mocks.

Devemos então re-implementar as propriedades Request, Response, Session, Server e Application de forma a retornar os novos tipos abstratos e não mais os antigos. Importante notar que não é possível fazer override, pois estaremos alterando o tipo da propriedade, então precisamos utilizar o “new”, que permite esconder uma implementação da classe pai.

Repare ainda que utilizamos “virtual” na criação das novas propriedades, pois isso as torna “mockaveis”.

Veja como fica o código :

        HttpContextWrapper cw;
        public new virtual HttpRequestBase Request
        {
            get
            {
                if (cw == null)
                {
                    cw = new HttpContextWrapper(Context);
                }
                return cw.Request;
            }
        }

        public new virtual HttpResponseBase Response
        {
            get
            {
                if (cw == null)
                {
                    cw = new HttpContextWrapper(Context);
                }
                return cw.Response;
            }
        }

        public new virtual HttpApplicationStateBase Application
        {
            get
            {
                if (cw == null)
                {
                    cw = new HttpContextWrapper(Context);
                }
                return cw.Application;
            }
        }

        public new virtual HttpSessionStateBase Session
        {
            get
            {
                if (cw == null)
                {
                    cw = new HttpContextWrapper(Context);
                }
                return cw.Session;
            }
        }

        public new virtual HttpServerUtilityBase Server
        {
            get
            {
                if (cw == null)
                {
                    cw = new HttpContextWrapper(Context);
                }
                return cw.Server;
            }
        }

Como esse código é extenso, o ideal é inserir esse código em uma classe que herde de Page e depois fazer com que todos os webforms herdem dela.

Veja um exemplo bem simples de código que depende dessa implementação para se tornar testável :

        protected void Button1_Click(object sender, EventArgs e)
        {
            Label1.Text = Request.AnonymousID;
        }

Utilizando o “Create Unit Test” do menu de contexto, geramos um novo projeto de teste para esse método, Button1_Click. Para fazer mock irei utilizar uma biblioteca chamada Moq, que podemos instalar na forma de um pacote Nuget (Manage Nuget packages permite isso).

Com o Moq instalado, podemos fazer o código do nosso método de teste. Veja como fica :

        [TestMethod()]
        public void Button1_ClickTest()
        {
            // Mock do RequestBase para controlar o anonymousID
            // Seria impossível sem o requestbase
            var rb = new Mock<HttpRequestBase>();
            rb.Setup<string>(x => x.AnonymousID).Returns("Teste");

            // Webform usa por default um private accessor
            var wf = new Mock<WebForm1>();
            wf.Setup<HttpRequestBase>(x => x.Request).Returns(rb.Object);
            WebForm1_Accessor target = new WebForm1_Accessor(new PrivateObject(wf.Object));

            //Controlando o label
            Label lbl = new Label();
            target.Label1 = lbl;

            target.Button1_Click(null, null);

            Assert.IsTrue(lbl.Text == "Teste", "Falhou");
        }

Claro que você, na prática, irá utilizar exemplos bem mais complexos do que esse, mas o principio é o mesmo.

Importante : No VS 2012 ocorreram mudanças no sistema de testes, esse exemplo não funcionará exatamente desta forma, funcionando apenas no VS 2010. Publicarei mais sobre o assunto.

>> Não acabou não, mané, tem mais ai, clica e contine lendo ...<<

Erro 417 : Expectation Failed–Solução

 

As vezes, quando acessamos alguns servidores utilizando o .NET, recebemos esse erro : Expectation Failed.

Recentemente tenho recebido muito esse erro no acesso a internet através de alguns servidores de proxy, porém pode acontecer em muitas outras situações.

O que significa ?

O .NET faz o envio de dados para os servidores em 2 etapas, implementando um padrão existente no HTTP 1.1. Primeiro envia apenas os headers para o servidor, esperando que o servidor responda se suporta esse envio ou não. Em seguida, com uma resposta positiva do servidor, envia os dados.

O erro “Expectation Failed” é justamente a resposta negativa do servidor.

Como Resolver

Simples : Podemos desativar esse envio em duas etapas através de uma configuração no Web.Config, veja :

    <system.net>
        <settings>
            <servicePointManager expect100Continue="false" />
        </settings>
    </system.net>

>> Não acabou não, mané, tem mais ai, clica e contine lendo ...<<

Nuget x TFS : Access Denied to MainCollection

 

Instalei um servidor NUGET esses dias em uma empresa e, ao utiliza-lo junto com o TFS tive essa infeliz surpresa : A instalação de pacotes NUGET conflita com o TFS e recebemos a estranha mensagem de Access Denied na MainCollection do TFS.

A solução acaba sendo simples : É necessário configurar o endereço do TFS nos endereços da intranet local, na configuração de segurança do IE.

Não importa se você não usa o IE, pois as configurações de segurança que normalmente são feitas no IE valem para todo o ambiente windows, tanto é que no Windows 7 elas podem ser encontradas no control panel, não mais apenas no IE.

Vamos fazer o passo-a-passo pelo IE mesmo, porém fica registrado que existem outras opções.

1) Abra o IE

2) Vá em Tools->Internet Options

3) Clique em Security e selecione Local Intranet

4) Clique no botão Sites

5) Clique em Advanced

6) Desmarque a opção “Require server verification (https) for all sites in this zone”

7) Adicione a URL do TFS

8) Dê Ok em tudo

9) Tente novamente

Fonte : http://blog.rthand.com/post/2011/08/26/Fixing-combination-of-NuGet-and-Team-Foundation-in-workgroup-configuration-401-Unauthorized.aspx

>> Não acabou não, mané, tem mais ai, clica e contine lendo ...<<

Validações em HTML 5 : Personalizando as mensagens

 

Publiquei uma dica sobre como usar o setCustomValidity para personalizar a mensagem de validação exibida automaticamente pelo HTML 5 na validação de formulários.

Isso já é um inicio para a personalização, porém existem situações mais complexas : Podem haver muitas causas para um erro de validação.

Por exemplo : Em um campo definido como numérico, ele pode estar inválido por não ter sido preenchido, pelo número estar abaixo do limite mínimo ou por estar acima do limite máximo. A mensagem, nesse caso, precisa ser personalizada.

Vamos considerar o seguinte campo :

               <input type="number" id="txtnome" required min="10" max="20" oninvalid="javascript:subinvalid(this)"  />

Observe que estou utilizando o evento oninvalid para chamar uma rotina em javascript e passando o próprio campo como parâmetro.

Veja como fica a rotina para personalizar a mensagem de erro :

    <script>

        function subinvalid(sender) {
            sender.setCustomValidity('');

            if (!sender.validity.valid) {
                if (sender.validity.valueMissing)
                    sender.setCustomValidity("Por favor, preencha o valor!");
                if (sender.validity.rangeOverflow)
                    sender.setCustomValidity("O valor pode ser no máximo " + sender.max);
                if (sender.validity.rangeUnderflow)
                    sender.setcCustomValidity("O valor deve ser no mínimo " + sender.min);
                }
        }
     </script>

Através do objeto validity ligado ao próprio campo podemos identificar exatamente que tipo de erro de validação ocorreu e desta forma personalizar a mensagem de acordo com o erro de validação.

>> Não acabou não, mané, tem mais ai, clica e contine lendo ...<<

Compreendendo os TraceFlags

 

TraceFlag é um mecanismo através do qual podemos alterar o comportamento do servidor SQL Server, habilitando algumas características adicionais do servidor.

Os traceflags são identificados numericamente, cada traceflag representa uma característica a mais do servidor que podemos habilitar. Existem traceflags documentados e não documentados.

Existem três tipos de traceflag :

Global : Uma vez habilitado, gera efeito em todas as sessões abertas com o servidor de banco

Sessão : Gera efeito apenas na sessão na qual foi habilitado

Global e Sessão : Pode ser utilizado das duas formas

Cada traceflag envolve funcionalidades complexas do banco que podem ter consequencias consideráveis em especial sobre performance e manutenção, então é importante estudar cuidadosamente os traceflags que deseja utilizar.

Para habilitar um traceflag de sessão :

DBCC TraceOn(3205)

Para habilitar um traceflag global :

DBCC TraceOn(3205,-1)

(O traceflag 3205 é de sessão e global)

Mesmo no caso do traceflag global, quando o serviço do SQL Server for reiniciado o traceflag estará desabilitado novamente. Para que isso não ocorra a ativação do traceflag deve se dar na forma de parâmetro do serviço, utilizando o parâmetro –T <traceflag>

Para isso entramos em “View Local Services” no windows, localizamos o serviço do SQL Server e adicionamos o parâmetro –T conforme a imagem abaixo :

 

Descobrir quais estão ativados

Para descobrir quais traceflags encontram-se ativados utilize a instrução DBCC TRACESTATUS

>> Não acabou não, mané, tem mais ai, clica e contine lendo ...<<