Cidadão Carioca

VS 2012 : Code Map

noreply@blogger.com (Dennes) — Wed, 08 May 2013 01:29:00 +0000

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 …. :

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

noreply@blogger.com (Dennes) — Tue, 02 Apr 2013 03:06:00 +0000

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

Testabilidade em WebForms : Fazendo Mocks de Request

noreply@blogger.com (Dennes) — Tue, 26 Mar 2013 11:37:00 +0000

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.

Erro 417 : Expectation Failed–Solução

noreply@blogger.com (Dennes) — Wed, 13 Mar 2013 02:42:00 +0000

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>

Nuget x TFS : Access Denied to MainCollection

noreply@blogger.com (Dennes) — Thu, 07 Mar 2013 05:58:00 +0000

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

Validações em HTML 5 : Personalizando as mensagens

noreply@blogger.com (Dennes) — Wed, 06 Mar 2013 05:34:00 +0000

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.

Compreendendo os TraceFlags

noreply@blogger.com (Dennes) — Mon, 04 Mar 2013 09:24:00 +0000

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

SSIS : Rodar pacotes de 32 bits em um ambiente de 64 bits

noreply@blogger.com (Dennes) — Tue, 26 Feb 2013 03:47:00 +0000

Eventualmente rodar pacotes SSIS em 32 bits pode ser necessário, mesmo tendo um ambiente de 64 bits. Isso pode acontecer por causa do uso de alguns drivers ISAM que não irão rodar em 64 bits, tal como para troca de dados com excel.

Garantir que o pacote seja rodado em 32 bits irá depender da forma de execução do pacote, tendo assim diversas variações.

BIDS

Para a execução no BIDS, devemos ir nas propriedades da solution, debugging, Run64BitRuntime e marcar essa opção como true.

Duplo clique no dtsx

Isso dispara o Package Execution Utility, que já é de 32 bits, portanto não é um problema.

Servidor SSIS

Vale a configuração do BIDS

Job do SQL Server Agent (SQL Server 2008)

Nas propriedades do step, marque a opção “Use 32 bit runtime”

Job do SQL Server Agent (2005)

Não existe a opção “Use 32 bit runtime”. Neste caso é necessário utilizar o step do tipo cmdexec e montar uma instrução chamando do dtexec da versão que desejamos.

Uma sugestão para montar a instrução de execução é utilizar o Execute Package Utility.

Presente da Microsoft : Thank You Gift pelo VS 2012

noreply@blogger.com (Dennes) — Sun, 17 Feb 2013 21:25:00 +0000

Recebi há alguns dias atrás um presente da Microsoft : Um Thank You Gift por ter auxiliado no processo de criação do VS 2012.

É um presente simples, mas muito importante pelo que representa. Utilizei o Visual Studio durante o periodo de beta test, fiz sugestões, indiquei bugs, algumas sugestões que fiz foram implementadas (pelo menos de forma próxima ao que sugeri).

É muito legal ser reconhecido por ter participado do desenvolvimento deste grande produto.

Resposta : Desafio de SQL Server

noreply@blogger.com (Dennes) — Fri, 01 Feb 2013 03:18:00 +0000

Há algumas semanas propus um desafio de SQL, com um prêmio para quem acertasse a questão. Podem ver a questão original em http://www.bufaloinfo.com.br/ExibeNoticias.aspx?entryid=1357079492327179156 . Infelizmente ninguém acertou.

Então é chegado o momento da verdade : A Resposta !!

A explicação do problema começa no fato de estarmos utilizando transações distribuidas no framework .NET (transactionScope). Essas transações, devido a uma visão muito conversavadora, elas assumem por default um transaction isolation level como serializable.

Isso ocorre por uma suposição de que o desenvolvedor não saiba o que são exatamente os transaction isolation levels, então assume-se a opção mais segura para o funcionamento – e mais prejudicial para a performance.

Essa característica pode ser uma novidade para muitos, mais ainda não explica claramente a situação – por que um único procedimento, ao ser executado por duas pessoas, estava gerando deadlock ?

O procedimento em si era composto por um select e um update, ambos na mesma tabela.

A impressão geral seria : quando uma execução pegar um lock, as demais param no mesmo ponto, então nunca daria deadlock, certo ? Errado.

Assim como todos os isolation levels, o serializable muda o comportamento dos locks sobre os selects. O que ele faz ? É como se ele aplicasse um holdLock no select. Por padrão um select causa lock shared, com o uso de holdlock o lock shared será mantido até o fim da transação.

Ora, locks shared são compatíveis com locks shared, então várias execuções podem pegar lock shared ao mesmo tempo sobre os mesmos objetos.

Assim, voltando ao procedimento : As duas execuções simultâneas passariam pelo select sem problema algum, ambas pegariam lock shared na tabela. Porém, ao chegar no update, ficariam esperando que a outra execução liberasse o lock shared para que o update pudesse prosseguir. Temos então duas execuções, uma esperando pela outra. Resultado : Deadlock!!

Criando um botão HOME

noreply@blogger.com (Dennes) — Thu, 31 Jan 2013 02:29:00 +0000

Criar um botão HOME é tarefa necessária em aplicações que envolvam navegação por várias telas ou funcionalidades.

O enum NavigationCommands define um Command chamado BrowseHome, porém o objeto Frame não implementa esse command.

Podemos fazer uma definição personalizada do command BrowseHome para o objeto Frame. A forma mais prática de fazermos isso é criando um Behavior para o Frame que faça essa definição personalizada.

Veja como fica o código :

    public class HomeBehavior : Behavior<Frame>
    {

        void BrowseHomeExecuted(object target, ExecutedRoutedEventArgs e)
        {
            while (this.AssociatedObject.CanGoBack)
                this.AssociatedObject.GoBack();
        }
        void BrowseHomeCanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
              e.CanExecute = this.AssociatedObject.CanGoBack;
        }

        protected override void OnAttached()
        {
            base.OnAttached();
            this.AssociatedObject.CommandBindings.Add(new System.Windows.Input.CommandBinding(NavigationCommands.BrowseHome,
                                        BrowseHomeExecuted, BrowseHomeCanExecute));

        }
}

Como funciona : Através da coleção de CommandBindings adicionamos um novo CommandBinding, que fará com que o frame compreenda o command BrowseHome

Veja como fazemos para anexar esse behavior no frame :

       <Frame x:Name="_mainFrame" NavigationUIVisibility="Hidden" Grid.Row="1">
            <i:Interaction.Behaviors>
               <vm:HomeBehavior />
          </i:Interaction.Behaviors>
       </Frame>

É necessário acrescentar na tag Window 2 importações de namespaces, uma para o seu namespace, onde irá criar o HomeBehavior, outra para System.Windows.Interactivity :

       xmlns:vm="clr-namespace:MeuNamespace;assembly=Meuassembly"
       xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

Veja agora como fica um botão Home, inserido na mesma janela onde está o frame :

            <Button Style="{StaticResource estiloHome}" Width="80" 
                        CommandTarget="{Binding ElementName=_mainFrame}"  Command="BrowseHome" 
                    />

Publicamos recentemente uma dica que mostra como vincular o CommandTarget de um botão dentro de uma página ao frame que contém a página, assim o botão Home poderia também estar dentro de uma página contida no frame.

Diferença de AsNoTracking e AutoDetectChanges no Entity Framework

noreply@blogger.com (Dennes) — Tue, 29 Jan 2013 02:43:00 +0000

Anteriormente publiquei dicas sobre o uso do AsNoTracking (http://www.bufaloinfo.com.br/dicas.aspx?cod=1106) e do AutoDetectChanges (http://www.bufaloinfo.com.br/dicas.aspx?cod=1115), ambos úteis para otimizações no entity framework.

Porém observei que existe uma certa confusão entre o uso dos dois. Quando usar um, quando usar outro. Então vejamos uma descrição um pouco melhor de como isso funciona.

Contexto e Entidades

Quando buscamos entidades da através do entity framework, este guarda as entidades no contexto, fazendo um processo que é chamado de tracking das entidades. É este tracking, o fato das entidades estarem no contexto, que permite posteriormente que possa ocorrer uma atualização destas entidades.

Porém o simples tracking não é suficiente para que uma atualização ocorra. No momento em que pedimos que atualizações sejam salvas, o entity framework irá consultar entre as entidades das quais está fazendo tracking quais encontram-se marcadas como alteradas e então sim, enviar as alterações para o servidor.

Portanto, para que uma gravação ocorra, além do tracking estar sendo realizado, é necessário que a entidade esteja marcada como alterada.

DetectChanges

O processo pelo qual mudanças são detectadas é simples : Ao carregarmos entidades, é criada uma cópia delas, um snapshot, em memória. O contexto possui um método chamado DetectChanges que compara as entidades que carregamos com o snapshot guardado em memória. Se forem diferentes, uma mudança ocorreu.

AutoDetectChanges

O AutoDetectChanges significa detectar automaticamente a ocorrência de mudanças. Isso significa que, de forma vinculada a alguns eventos, o método DetectChanges será automaticamente chamado, sem precisarmos fazer nada, marcando as entidades como alteradas.

O problema disso está no fato de que cada vez que chamamos o DetectChanges ele precisa percorrer todas as entidades do contexto. Quanto mais entidades envolvidas, maior o tempo gasto.

AsNoTracking x AutoDetectChanges

Utilizar o AsNoTracking significa que as entidades serão lidas da origem de dados mas não serão mantidas no contexto. Com isso não poderão ser atualizadas posteriormente.

É claro que ao usar o AsNoTracking o AutoDetectChanges também não se aplicará sobre essas entidades, é uma consequencia. Porém o AsNoTracking é uma forma radical de resolver o problema para situações apenas de leitura de dados.

Exemplo do AsNoTracking :

var resultado=(from x in ne.Customers
where x.CustomerID==cliente
select x).AsNoTracking();

Imagine porém situações em que você precisará fazer muitos inserts ou updates nas entidades. O AsNoTracking não pode ser utilizado, porém por serem muitas entidades o AutoDetectChanges causa uma perda de performance. Assim podemos otimizar muitos inserts e updates no contexto de uma forma simples :

Desliga-se o autodetectchanges

Realiza-se as mudanças

Chama-se o método detectchanges para fazer a detecção de mudanças

Exemplo de AutoDetectChanges :
 context.Configuration.AutoDetectChangesEnabled = false;

// Realiza-se as mudanças aqui

context.ChangeTracker.DetectChanges();
Desta forma otimiza-se consideravelmente o código

Resumindo

Veja o quadro abaixo as diferenças entre os dois :

Está no Contexto Permite atualizações Identifica Mudanças Automaticamente Quando utilizar

AsNoTracking Não Não Não Somente leitura de dados

AutoDetectChanges=true Sim Sim Sim Leitura e gravação de registros individuais

AutoDetectChanges=false Sim Sim Não Atualizações em lote

Referência

http://blog.staticvoid.co.nz/2012/5/7/entityframework_performance_and_autodetectchanges

Desafio de SQL : DeadLocks

noreply@blogger.com (Dennes) — Tue, 08 Jan 2013 02:02:00 +0000

Esbarrei com essa questão em um ambiente e quebrei a cabeça nela por alguns minutos até identificar o problema, não é nada óbvio. Então vai como um desafio para vocês. Respondam nos comentários.

Eis uma motivação :

O primeiro que explicar a resposta certa leva 1 mês gratis de acesso na PluralSight

Introdução da pergunta

Deadlocks são assuntos conhecidos pelos DBA’s, a causa e resolução, apesar de difícil de achar, é clara : Dois processos, x e y, estão realizando transações com acessos em ordem invertida nos objetos de banco.

Por exemplo : X acessa a tabela clientes e funcionários, nesta ordem, enquanto que y acessa a tabela funcionários e clientes, nesta ordem. Os dois podem gerar deadlocks entre si.

O conhecimento geral aceito é que um mesmo processo ( x ) pode lockar a si mesmo quando executado simultaneamente por vários usuários, mas não causar deadlock.

PERGUNTA

Em um ambiente com ocorrência de Deadlocks, você utiliza o DeadlockGraph do profiler e se espanta ao analisar o resultado e ver que o deadlock está sendo causado por um único processo e não 2.

Os processos estão desenvolvidos em .NET utilizando transações distribuidas (System.Transactions).

Então : O que faz com que um único processo cause deadlock com ele mesmo ? O que está causando deadlock neste cenário ?

Aguardarei por 15 dias ou umas 10 tentativas de resposta nos comentários, o que vier primeiro, então darei a resposta. BOA SORTE ! ;-)

Substitua Updates por Bulk Inserts

noreply@blogger.com (Dennes) — Sun, 11 Nov 2012 22:29:00 +0000

Esbarrei com essa possibilidade de otimização durante processos de importação de dados. Qualquer processamento em banco, especialmente quando envolvendo tabelas temporárias, pode ter essa possibilidade.

Problema : Instruções UPDATE são instruções full-logged, gravadas em detalhes no log de transações. Quando executadas em um grande volume de dados tem um impacto considerável no tempo de execução de um batch.

Solução : Substituir instruções UPDATE intermediárias de processamento por SELECT INTO criando tabelas temporárias. SELECT INTO é uma instrução que realiza BULK INSERT e por isso, exceto quando o banco estiver com recovery model full (o que pode ser mudado apenas para execução do batch) será minimamente logada.

Na sequencia abaixo farei um exemplo com instrução UPDATE e gerando um resultado equivalente com SELECT INTO, podendo comparar o tempo de execução. Utilize um banco de dados de teste com um bom tamanho disponível.

Criar a tabela :

CREATE TABLE [dbo].[tabTeste](

    [id] [int] IDENTITY(1,1) NOT NULL Primary Key,

    [valor1] [varchar](30) NOT NULL,

    [valor2] [varchar](50) NOT NULL,

    [varlor3] [varchar](30) NOT NULL,

Preencher com dados :

insert into tabTeste values ('x','a','b')

insert into tabTeste values ('b','x','a')

insert into tabTeste values ('a','x','b')

insert into tabTeste values ('a','b','x')

insert into tabTeste values ('b','a','x')

insert into tabTeste values ('x','b','a')

go 60000

O GO multiplica a execução da instrução, populando a tabela. O número, porém, precisará ser alterado conforme seu servidor para criar um volume relevante.

Instrução update :

begin transaction
update tabteste set valor2='z'
Utilize Rollback Transaction para cancelar o update e continuar os testes

Limpar o cache :

Entre uma execução e outra é importante limpar o cache para garantir a exatidão na medida do tempo de execução
CHECKPOINT
DBCC DROPCLEANBUFFERS

Instrução Select INTO :

begin transaction

select id, valor1, 'z' as valor2, varlor3 into #tabtemp from tabteste

Resultado

Em meus testes a execução com update levou 4 seg, enquanto que a execução com select into não chegou a consumir 1 seg., demonstrando assim o quanto é mais rápida.

A possibilidade de substituir um pelo outro depende do resultado final desejado, em meio a um processamento batch, lidando com tabelas temporárias, isso é bem possível sim.

ASP.NET WebForms 4.5–Palestra no BaixadaTech

noreply@blogger.com (Dennes) — Wed, 31 Oct 2012 05:03:00 +0000

No dia 20/10 estive em Santos palestrando no BaixadaTech 2012, mais um grande evento organizado pelo Dinart na UniSanta.

Você pode baixar o projeto de demonstração e os PPTs aqui

Os tópicos que apresentei no BaixadaTech irão aos poucos virar pequenos (ou não tão pequenos assim) artigos.

Vejam alguns que já estou publicando :

VS 2012 : Configuração Inicial de Projeto

Neste escrevi algumas recomendações sobre a configuração inicial de uma Empty ASP.NET Application

Model Binding no Webforms 4.5 com Camadas de Negócio

Neste mostro como realizar o Model Binding com um componente de negócio ao invés de deixar o código todo no code-behind. Um artigo maior sobre Model Binding está por vir

Veja como estar atento as novidades

Mande um e-mail para devaspnet-subscribe@yahoogrupos.com.br para se inscrever na lista de discussão

Mande um e-mail para devSQL-subscribe@yahoogrupos.com.br para se inscrever na lista de discussão

Acesse http://www.facebook.com.br/devASPNet e curta o grupo para receber sempre as novidades

Acesse http://www.facebook.com.br/devSQL e curta o grupo para receber sempre as novidades

VS 2012 : Configuração inicial de Projeto ASP.NET

noreply@blogger.com (Dennes) — Wed, 31 Oct 2012 04:27:00 +0000

Os templates de projeto contidos no Visual Studio 2012 já incluem várias configurações e instalações de packages nuget que, iniciando por um projeto em branco, precisamos reproduzir para iniciarmos o desenvolvimento.

Veja algumas recomendações do que instalar/configurar em uma Empty ASP.NET Application.

Instalação de Packages Nuget

Microsoft.AspNet.Web.Optimization
- Permite uso de Bundling e Minification
Microsoft.AspNet.Web.Optimization.WebForms
- Permite uso de um web control para acessar os bundlings
EntityFramework
- Instala a versão atual do Entity Framework

Outros Packages

Muito provavelmente você precisará também dos packages de JQuery e JQuery UI.

Configuração no Web.Config

O seguinte trecho deve ser inserido dentro da tag <pages> no web.config :

<namespaces>
<add namespace="System.Web.Optimization" />
</namespaces>

Essa configuração habilita a chamada dos bundlings na página utilizando Scripts.Render

Entity Framework : Versões e Instalações

noreply@blogger.com (Dennes) — Tue, 30 Oct 2012 14:56:00 +0000

Com a quase mas não total independência do Entity Framework em relação ao Framework .NET suas versões e formas de instalação ficaram um pouco confusas. Vamos analisar em mais detalhes.

ObjectContext x DBContext

A principal diferença entre as versões é o uso de ObjectContext ou de DBContext como objeto de contexto de um modelo EDMX. O DBContext surge para substituir totalmente o ObjectContext, com várias vantagens em sua síntaxe simplificada, mas exigindo cuidado na adoção, pois afinal estamos falando de uma síntaxe diferente.

E.F. Versão 4.x : Utiliza principalmente ObjectContext
E.F. Versão 5.0 : Utiliza principalmente DBContext

Code Generation Item

O EDMX permite que você adicione um Code Generation Item no modelo. O efeito dessa adição é que você substitui a geração de código padrão do Visual Studio para o EDMX pelo uso de um modelo T4 que irá determinar a forma como o código será gerado.

Assim sendo, tanto na versão 4.x podemos utilizar um Code Generation Item para gerar o DBContext como na versão 5.0 podemos usar um Code Generation Item para gerar o ObjectContext.

Assim sendo as versões não prendem o uso a um ou a outro, usar DBContext ou usar ObjectContext continua sendo uma escolha.

Visual Studio 2010 x Visual Studio 2012

A versão 5.0 do E.F. é distribuida como um pacote Nuget e pode ser instalada em ambos os Visual Studios, tanto o VS 2010 como o VS 2012.

Porém a diferença entre os 2 visual studios está justamente no designer do EDMX, que faz parte do Visual Studio.

VS 2010 : O Designer gerar ObjectContext por padrão. São necessários Code Generation Itens contidos na Visual Studio Galery para gerar DBContext

VS 2012 : O designer gera DBContext por padrão usando um template T4. Existe Code Generation Itens já instalados que podem ser usados para gerar ObjectContext

Veja alguns Code Generation Itens disponíveis para o VS 2010 :

DBContext Object Generator EF 4.x

DBContext Object Generator EF 5.0

DBContext Object Gerator + DataContract

Framework 4.0 x Framework 4.5

Uma parte das funcionalidades do Entity Framework encontra-se acoplada ao Framework .NET. Assim sendo, mesmo instalando o E.F. 5.0 no VS 2010, não teremos as funcionalidades completas do E.F. 5.0, apenas uma parte.

Desta forma o E.F. 5.0 vai realmente se comportar de forma diferente quando estivermos usando o Framework 4.0 (VS 2010) ou quando estivermos usando o Framework 4.5 (VS 2012).

Exemplo :

No VS 2010 não é permitido marcar um atributo alterado com modifed false. A mesma funcionalidade é permitida no VS 2012.

Importante : O Framework 4.5 ficou famoso por substituir DLL’s do framework 4.0, realizando uma estranha mesclagem em que aplicações feitas para o framework 4.0 estarão usando parte do 4.5. Porém isso não altera essa diferença de funcionalidades no EF 5.0. O Visual Studio utilizado para desenvolver a aplicação determina essas alterações.

Observação : Já que o Visual Studio é um componente opcional no desenvolvimento, vale uma pesquisa mais detalhada sobre essas DLL’s do framework x EF. Por enquanto, porém, consideraremos essas afirmações.

ModelBinding no WebForms 4.5 com Camada de Negócios

noreply@blogger.com (Dennes) — Mon, 29 Oct 2012 04:04:00 +0000

A utilização de ModelBinding com os WebForms é uma das grandes novidades do ASP.NET 4.5, porém todos os exemplos que encontramos na web atualmente mostram o código inserido dentro do code-behind da página.

Porém inserir lógica de negócios no code-behind da página nunca é uma boa idéia. Normalmente desejamos que a lógica fique em uma camada de negócios, uma classe e eventualmente até projeto separado.

Para podermos fazer isso basta programarmos um evento nos webcontrols que irão consumir os dados : OnCallingDataMethods

Veja um exemplo :

        protected void FormView1_CallingDataMethods(object sender, CallingDataMethodsEventArgs e)
        {
            e.DataMethodsObject = new libBLL.ClientesBLL();
        }

Neste exemplo temos uma classe ClientesBLL que possui os métodos para acesso aos dados.

Existe ainda uma alternativa : Os métodos contidos no objeto poderiam ser do tipo static. Neste caso o código que devemos aplicar no evento será um pouco diferente :

        protected void FormView1_CallingDataMethods(object sender, CallingDataMethodsEventArgs e)
        {
            e.DataMethodsType = typeof(libBLL.ClientesBLL);
        }

Model Validation

Criando os métodos de acesso dentro de uma class library não poderemos ter acesso ao ModelState para verificar a validade.

Porém podemos utilizar outros métodos para garantir que o model esteja válido. Independente de não usarmos o ModelState na class library, um validator summary consegue exibir as mensagem de erro de ModelState normalmente, só precisamos garantir que a class library não execute tarefas quando o modelo não estiver válido.

Veja como checar isso com o entity framework :
            if (ne.GetValidationErrors().Count() != 0)
                return;
Utilizando o método GetValidationErrors podemos identificar que existem erros de validação no modelo e desta forma impedir que a camada de negócios execute as operações, como atualização de dados. A camada de interface se encarregará de mostrar os erros de ModelState através, por exemplo, de um ValidationSummary.

SQL Server Repair falhando

noreply@blogger.com (Dennes) — Tue, 17 Jul 2012 02:20:00 +0000

Mais um problema no mínimo curioso

Problema

A realização de um repair na instância do SQL Server falha com a seguinte mensagem de erro :

“Error 1316.A network error occurred while attempting to read from the file
G:\1033_ENU_LP\x64\setup\SSCERuntime_x86-enu.msi”

Causa

Parece ser um bug no processo de repair do SQL Server, esse bug está devidamente registrado no connect em http://connect.microsoft.com/SQLServer/feedback/details/588703/senior-developer

Ocorre que o repair está buscando um arquivo que não existe no DVD, até porque está buscando com o nome errado – busca o arquivo x86 para fazer um repair de ambiente x64.

Solução

Copie todo o conteúdo do DVD para uma pasta no HD

Troque o nome do arquivo G:\1033_ENU_LP\x64\setup\SSCERuntime.msi para SSCERuntime_x86-enu.msi

Rode o rapair a partir da pasta no HD

ASP.NET Universal Providers

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

Os recursos básicos do asp.net, tal como membership, rolemanager, session e outros, baseados em providers, estão disponíveis independente do formato de interface (MVC ou WebForms), porém os providers padrões que acompanham o framework são dedicados ao SQL Server.

Com a popularidade do SQL Azure e SQL Compact, foram criados os Universal Providers. Com um único provider podemos fazer conexão a um SQL Server, ao SQL Server Compact ou ao SQL Azure.

Espera-se que os Universal Providers sejam incluidos por padrão no Visual Studio 2012, mas isso ainda não está confirmado.

Veja um comparativo de providers padrões do framework e os universal providers :

Classes de Provider SQL	Classes do Universal Provider
`System.Web.Security.SqlMembershipProvider`	`System.Web.Providers.DefaultMembershipProvider`
`System.Web.Profile.SqlProfileProvider`	`System.Web.Providers.DefaultProfileProvider`
`System.Web.Security.SqlRoleProvider`	`System.Web.Providers.DefaultRoleProvider`

Instalação com o package manager no VS 2010 :

Passei nas Provas de SQL Server 2012 !

noreply@blogger.com (Dennes) — Tue, 19 Jun 2012 06:04:00 +0000

Fazer provas beta é sempre um desafio : Quase ninguém fez aquela prova antes, não existem comentários ou detalhes sobre o conteúdo.

Quando foram disponibilizadas as provas beta de SQL Server 2012, tive basicamente 2 semanas para realiza-las e isso em meio aos preparativos do SQL Saturday no Rio (que foi um grande sucesso!)

Esperava ganhar experiência com as provas, passar em 2, quando muito 3. Eis então minha grande surpesa quando, nos últimos dias, descobri que passei em todas as 7 provas de SQL Server !!

Com isso me torno MCSA e MCSE, tanto em Data Platform como Bussiness Inteligence.

Escrevi um pouco sobre as novas certificações em SQL Server 2012

Novas Certificações de SQL Server

noreply@blogger.com (Dennes) — Tue, 19 Jun 2012 05:36:00 +0000

O SQL Server 2012, lançado em março deste ano, trouxe com ele novas provas de certificações. Muito mudou nas certificações de SQL Server. Veja as principais mudanças :

Ao todo, são 7 provas de certificação
As provas se dividem em 2 áreas : Data Plataform e Bussiness Intelligence
As certificações possuem 2 níveis : MCSA e MCSE
Ao contrário do antigo System Enginneer, MCSE significa Microsoft Certified Solution Expert
MCSA, por sua vez, significa Solution Associate

Provas para obter o MCSA

461 – Queryng Microsoft SQL Server 2012

462 – Administering Microsoft SQL Server 2012

462 – Implementing Data Warehouse com Microsoft SQL Server 2012

Provas para obter o MCSE

Data Plataform Bussiness Intelligence

Possuir o MCSA Possuir o MCSA

464 – Developing Microsoft SQL Server Databases 466 – Implementing Data Models and Reports with Microsoft SQL Server 2012

465 – Design Database Solutions for Microsoft SQL Server 2012 467 – Design Bussiness Intelligence Solutions With Microsoft SQL Server 2012

Destaques e pontos polêmicos

MCSA e MCSE são siglas que estão sendo re-utilizadas e irão confundir departamentos de RH em todo o mundo
A certificação mais básica (MCSA) foca em administração e já possui uma prova de data warehouse
A certificação é mais voltada para generalistas do que para especialistas

Conheça os treinamentos de SQL Server 2012 da Búfalo Informática

JQuery e a GridView

noreply@blogger.com (Dennes) — Mon, 18 Jun 2012 07:36:00 +0000

Implementar pequenos exemplos com seletores jQuery pode parecer simples, mas implementa-los em aplicações web reais junto a tecnologias de servidor pode envolver muitos truques.

Vamos então nesse pequeno post fazer um passo-a-passo que demonstre os problemas pelos quais esbarrará ao fazer uma aplicação de um efeito simples em linhas de uma GridView.

Problema

Implementar um efeito de mouseover sobre as linhas do corpo de uma GridView.

A Página

A página que usuaremos para demonstração do problema terá duas GridViews, cada uma com cabeçalho, paginador e rodapé

A Solução Trivial

A solução trivial para o problema seria implementar o seguinte código :

$(document).ready( function () { $(“tr”).hover(function () { $(this).addclass(“overclass”) },

function () { $(this).removeclass(“overclass”) })

})

Porém o resultado trará vários problemas :

Ambas as gridviews serão afetadas

Linhas de rodapé e cabeçalho serão afetadas

Se houvesse outras tabelas meramente para layout, seriam afetadas

Afetando apenas uma GridView

Existem duas alternativas para selecionar apenas uma gridview :

Selecionar pelo ID da GridView
Selecionar por uma classe aplicada apenas naquela GridView

Selecionar pelo ID da GridView

O ID da GridView é preenchido no servidor, porém no client ele pode mudar devido as formas de nomenclatura de objetos no client.

As alternativas são as seguintes :

No .NET 4.0 em diante, alterar o clientIDMode da gridview para static para que o clientID fique fixo.

Passar o ClientID do servidor para o client, para o código jQuery. Você pode ler sobre como isso é feito em ….

Filtrar por parte do ID, já que o ClientID é formato pelo ID do servidor e mais alguns trechos montados pelo ASP.NET. O seletor ficaria $(“table[id*=’iddoservidor’]”)

Selecionar por uma Classe

A GridView possui a propriedade CSSClass. Basta preencher com um nome de classe. De fato, a classe não precisa nem ao menos existir, ela funcionará como um “marcador” que permitirá ao jQuery selecionar a tabela.

Assim o selector fica $(“table.classe”) ou até mesmo $(“.classe”)

Resolvendo o primeiro problema

Opção 1 : $(“table.classe tr”)

Opção 2 : $(“table[id*=’iddoservidor’] tr”)

Essas são as opções mais simples.

Cabeçalho e Rodapé ainda serão afetados

Ambos são linhas dentro da tabela, serão naturalmente afetados. Uma solução trivial seria a seguinte :

$(“table.classe tr:not(tr:first,tr:last)”)

ou

$(“table[id*=’iddoservidor’] tr:not(tr:first,tr:last)”)

Porém essa não é uma solução versátil : Uma gridview pode ter além do rodapé um paginador inferior, assim como também pode possuir um paginador superior. Duas linhas em cada extremidade da grid que não deveriam ser afetadas.

Para resolver esse problema podemos utilizar tags que indiquem a função das linhas na gridView : thead, tbody e tfoot. É necessário uma pequena configuração da gridview para que ela gere essas tags, vejam detalhes no artigo em TFOOT, THEAD e TBODY com a GridView

Com a gridview gerando essas tags, naturalmente mudamos o seletor do jquery para :

$(“table[id*=’iddoservidor’] tbody tr”)

Porém não teremos o efeito desejado : O paginador ainda será afetado.

Solucionando o problema do paginador

Ocorre que o paginador da gridview é formado por uma 2a tabela que é criada dentro da linha do paginador. Mesmo não existindo uma tag TBODY explicita, o browser considera a presença de um tbody implicita e seleciona o TR da 2a tabela.

A questão é que ao utilizar “table[id*=’iddoservidor’] tbody tr” no seletor estamos pedindo TR’s que estejam dentro de um TBODY que esteja dentro da nossa grid. O TBODY do paginador está dentro da nossa grid, com isso ele também é afetado.

Solução : Indicar que desejamos apenas o TBODY que está no nível imediatamente abaixo da nossa tabela.

O seletor fica : “table[id*=’iddoservidor’] > tbody tr”

Como o TBODY do paginador não está imediatamente abaixo da nossa tabela – está em uma 2a tabela dentro de uma linha do rodapé da nossa tabela – ele deixa de ser afetado por esse novo seletor que finalmente atinge o objetivo.

A seleção por classe também pode ser utilizada : “table.classe > tbody tr”

SQL Server, APPCompat e sqlenginedbstartconfigaction_install_configrc_Cpu64

noreply@blogger.com (Dennes) — Sat, 19 May 2012 17:45:00 +0000

Eis a solução de um problema no mínimo estranho.

Ambiente

SQL Server instalado no Windows 7

Sintomas

Não é possível conectar ao SQL Server. A conexão pelo SSMS simplesmente não responde, sem nenhuma mensagem de erro, permanece tentando conectar, sem gerar resposta.

Nenhuma mensagem significativa no event viewer.

Tentantivas de instalar ou desinstalar o SQL Server travam o processo de instalação no momento em que o setup processa o sqlenginedbstartconfigaction_install_configrc_Cpu64

Causa

O SQL Server possui problemas de compatibilidade com o Windows 7, é necessária uma chave de registry específica para que a conexão seja possível, do contrário esse erro ocorrerá.

Não está muito claro o que pode fazer com que a chave em questão fique com valor errado.

Solução

Utilizando o regEdit, abra o seguinte caminho no registry :

HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\AppCompat

Defina o valor SbEnable para 1

Windows 8–Primeiras Impressões

noreply@blogger.com (Dennes) — Tue, 15 May 2012 00:34:00 +0000

Nesta última semana tive a oportunidade de participar de um treinamento de um dia para desenvolvedores sobre o Metro Style no Windows 8 e gostaria de compartilhar aqui as primeiras impressões.

Importante notar que foi apenas um dia e voltado a desenvolvimento, então algumas informações podem ter ficado mal entendidas/interpretadas. Corrigirei conforme novidades surgirem.

A Interface

A interface do Windows 8 é tão diferente que no primeiro impacto você se perde, não sabe como encontrar as coisas : Até mesmo abrir o notepad fica complicado.

O Windows levou muitos anos para criar uma interface consistente na qual todos conseguem se encontrar. Essa mudança irá gerar um impacto radical e impactará na adoção dele nas empresas.

Desenvolvimento

O desenvolvimento no sistema pode ser feito em duas vertentes : HTML5/Javascript ou XAML/C#. Outra mudança radical, já que o XAML, apesar de presente no mercado desde 2006, ainda não conquistou o espaço que merece.

Forçar o desenvolvimento nesse formato em uma nova versão do windows vai ser muito impactante, por isso mesmo os treinamentos para desenvolvedores tem sido realizados o quanto antes.

Modelo de Execução de Aplicações

O modelo de execução de aplicações está sendo levado do Windows Phone para o Windows 8, ou seja, do mobile para o desktop. É um modelo rígido ao qual os desenvolvedores desktop não estão totalmente adaptados.

Aplicações em Background

Eventualmente faço uma aplicação para processar alguma coisa, deixo rodando enquanto digito algum documento do word ou acesso a internet. No Windows 8 isso seria um perigo : O Windows 8 pode derrubar uma aplicação em background sem nenhum aviso.

Tarefas para rodarem em background precisam ser criadas especialmente na forma de uma background task, do contrário serão desativas/derrubadas pelo SO.

Isso é compreensível para um tablet ou celular, porém para uma máquina desktop significa um impacto absurdamente alto na compatibilidade com aplicações. Ainda busco mais confirmações sobre essa característica.

Instalação de Aplicações

A instalação de aplicações será feita através da Windows APP Store e apenas através da Windows APP Store.

No caso de distribuição de aplicações dentro da empresa, haverão recursos para criar uma private store onde a empresa poderá centralizar suas aplicações para distribuição sem depender de um meio externo.

Então significa que simplesmente copiar a aplicação para a máquina não permitirá que a aplicação rode ? Fim da pirataria ?

Conclusões

Essas foram as informações passadas durante o treinamento, porém são tão radicais que ainda estou cético sobre se isso valerá para as máquinas desktop (apesar de terem afirmado que sim).

Se estiver tudo correto, quantos anos levará para o Windows 8 conquistar um pequeno espaço de mercado nas empresas ? 3 anos ? 5 anos ?

A Microsoft parece estar apostando no fim das máquinas desktop, mas essa é uma mudança que poderá levar meia década para ocorrer e se a tecnologia for demasiadamente apressada pode resultar em uma perda de espaço do próprio Windows no mercado.

Afinal, não é a toa que o Windows XP ainda é o sistema mais usado do mercado e a MS parece ter dificuldade em mudar isso.

	Está no Contexto	Permite atualizações	Identifica Mudanças Automaticamente	Quando utilizar
AsNoTracking	Não	Não	Não	Somente leitura de dados
AutoDetectChanges=true	Sim	Sim	Sim	Leitura e gravação de registros individuais
AutoDetectChanges=false	Sim	Sim	Não	Atualizações em lote

Data Plataform	Bussiness Intelligence
Possuir o MCSA	Possuir o MCSA
464 – Developing Microsoft SQL Server Databases	466 – Implementing Data Models and Reports with Microsoft SQL Server 2012
465 – Design Database Solutions for Microsoft SQL Server 2012	467 – Design Bussiness Intelligence Solutions With Microsoft SQL Server 2012