Visual Studio OnLine

Olá pessoal,

Hoje a Micfrosoft liberou de forma definitiva e para todos, o Visual Studio Online. E o que vem a ser isto, talvez você esteja se perguntando ?

Há algum tempo atrás, a Microsoft começou com uma iniciativa para colocar o Team Foundation Server, sua plataforma de ALM, na nuvem, e desta assim nasceu o que chamamos hoje de Visual Studio Online, que você pode acessar no site: http://www.visualstudio.com/. Com esta ferramenta você pode ter uma versão do Team Foundation Server completo sem a necessidade de nenhum tipo de servidor em sua empresa.

O que você ganha com isto ? Rapidez, facilidade, e principalmente escala, ou seja, como é um serviço em nuvem, ele pode crescer a medida que sua empresa também cresce. E quanto isto custa ?

Se você já desenvolve para Microsoft Azure, o Visual Studio Online pode ser integrado ao seu serviço de nuvem e fazer Continuous Delivery (entrega contínua), ou seja, a partir de um checkin no código fonte do seu projeto, um processo de build é disparado na nuvem e a sua aplicação é automaticamente atualizada, sem nenhuma intervenção manual.

O preço para até 5 usuários é simplesmente DE GRAÇA, isto mesmo Free!!! Veja aqui os outros planos para mais usuários: Preços do Visual Studio Online

Agora você pode ter, na sua empresa, todas as funcionalidades do TFS, tais como: Gerenciamento de Projetos, Versionamento de Código (inclusive com GIT), gerenciamento de tarefas, Scrum, Dashboards, gerenciamento de Builds, entre outras funcionalidades, simplesmente utilizando o serviço em nuvem.

Eu estou utilizando desde as primeiras versões e posso garantir que o produto tem crescido muito e recebido novas funcionalidades frequentemente, ou seja, vale muito a pena utilizar!!!

Então, o que você está esperando ? É a sua chance de ter um controle completo de seus projetos agora mesmo. Crie sua conta de avaliação no site do Visual Studio Online: http://www.visualstudio.com/ e faça um teste, você vai se surpreender…

Abraços e até a próxima.
Carlos dos Santos.

DevChamps-EntityFramework6

Pessoal,

Acabei de fazer uma apresentação sobre Entity Framework 6 e uma breve introdução ao uso de EF com MVC e WebAPI para grupo DevChamps da Microsoft. Este é grupo seleto com grandes empresas do mercado e me sinto muito honrado e feliz por ter esta oportunidade!

Nesta apresentação falei de algumas novidades do Entity Framework 6, e mostrei como utilizar o Scaffold em aplicações MVC e webAPI para integração com o EF. Os feedbacks foram muito legais e positivos!

Agradeço a Microsoft pela confiança e espero estar em breve participando novamente!

Abraços e até a próxima,
Carlos dos Santos

E-book sobre criação de Aplicações reais para Azure

Pessoal,

Acabou de sair um E-book do Scott Guthrie’s sobre como criar aplicações reais para nuvem usando o Windows Azure. Este livro tem um material excelente e sem dúvida irá ajudá-los no desenvolvimento de aplicações para nuvem.

Eu tive a felicidade de participar do processo de revisão deste material e vale a pena conferir.

Para conferir o livro, clica aqui.

Abraços e até a próxima,
Carlos dos Santos.

Capturando a tela em Windows Forms

Olá pessoal,

Hoje vou demonstrar como é possível capturar a tela ou até mesmo o conteúdo de um controle e salvá-lo como um Bitmap. Imagine que você tem uma solução de atendimento ao cliente e em algum momento precise capturar a tela do seu usuário e depois anexá-la a algum requisito do software ou tratamento de um bug.

Claro que existem várias ferramentas prontas para captura de tela, mas vamos ver como é possível, através de um código em C# usando o recurso de Interop e acessando a API do Windows, criar um método reusável que pode ser utilizado para capturar vários tipos de tela no Windows.

Criando o projeto

Vamos criar um projeto no Visual Studio 2013 do tipo Windows Forms (você pode utilizar qualquer outra versão do Visual Studio):

SNAGHTML29cbc21f

Para deixar o nosso código de captura reutilizável, vamos criar uma nova classe chamada Tela.cs. Nesta classe iremos criar todo o código de captura, iniciando pelas referências a API do Windows. Esta API é muito rica e possui centenas de métodos muito interessantes, mas vamos nos concentrar basicamente nas rotinas de captura de tela.

Só para conhecimento, todos os controle do Windows são tratados como uma janela e como tal, possuem um identificador único de janela, ou um WindowsHandle. Para acessarmos qualquer informação de uma janela ou controle usando a API do Windows, precisamos deste identificador.

Trabalhando com Interop

Para começar a nossa classe, vamos colocar todo o código de Interop com a API do Windows. Eu não vou explicar em detalhes o que cada método faz, mas você pode acessar um site muito bom chamado PInvoke.net que contém referências, explicações e exemplos para a API do Windows.

O código abaixo faz uma referência para um método da API do Windows e o deixa acessível para nós no C#:

   1: public class Tela

   2:     {

   3:         [DllImport("user32.dll", EntryPoint = "GetDC")]

   4:         static extern IntPtr GetDC(IntPtr ptr);

   5:         [DllImport("user32.dll", EntryPoint = "ReleaseDC")]

   6:         static extern IntPtr ReleaseDC(IntPtr hWnd, IntPtr hDc);

   7:         [DllImport("gdi32.dll", EntryPoint = "DeleteDC")]

   8:         static extern IntPtr DeleteDC(IntPtr hDc);

   9:         [DllImport("gdi32.dll", EntryPoint = "CreateCompatibleDC")]

  10:         static extern IntPtr CreateCompatibleDC(IntPtr hdc);

  11:         [DllImport("gdi32.dll", EntryPoint = "CreateCompatibleBitmap")]

  12:         static extern IntPtr CreateCompatibleBitmap(IntPtr hdc, int nWidth, int nHeight);

  13:         [DllImport("gdi32.dll", EntryPoint = "SelectObject")]

  14:         static extern IntPtr SelectObject(IntPtr hdc, IntPtr bmp);

  15:         [DllImport("gdi32.dll", EntryPoint = "BitBlt")]

  16:         static extern bool BitBlt(IntPtr hdcDest, int xDest, int yDest, int wDest, int hDest, IntPtr hdcSource, int xSrc, int ySrc, int RasterOp);

  17:         [DllImport("user32.dll", EntryPoint = "GetDesktopWindow")]

  18:         static extern IntPtr GetDesktopWindow();

  19:         [DllImport("gdi32.dll", EntryPoint = "DeleteObject")]

  20:         static extern IntPtr DeleteObject(IntPtr hDc);

  21:

  22:         const int SRCCOPY = 13369376;

  23:         public struct SIZE

  24:         {

  25:             public int cx;

  26:             public int cy;

  27:         }

Entendo um pouco a API do Windows

DC – Device Context, ou Dispositovo de Contexto, é um identificador para um objeto no Windows, por exemplo uma janela ou controle.

GetDC() – devolve o identificador para uma janela.

ReleaseDC() – restaura o identificador para o Windows. Isto é muito importante, todo identificador que for utilizado, deve ser devolvido.

DeleteDC() – quando nós criamos o DC, ao invés de pegá-lo do Windows, precisamos deletá-lo para liberar o recurso.

CreateCompatibleDC() – cria um DC, no nosso caso iremos criar para manipular o Bitmap.

CreateCompatibleBitmap() – cria um Bitmap compatível com um DC.

SelectObjec() – seleciona um objeto, no nosso caso vincula o DC ao Bitmap.

BitBlt() – faz a cópia do conteúdo de um identificador para outro, e no nosso caso, o identificador de destino será um Bitmap.

GetDesktopWindow() – retorna um identificador para a janela principal do Windows (Desktop).

DeleteObject() – deleta um objeto, liberando o recurso alocado.

Criando a rotina que captura a tela

Agora que já entendemos um pouco da API do Window, vamos criar o método da nossa classe que irá fazer as capturas de tela. Para isto vamos adicionar o código abaixo a nossa classe Tela.cs:

   1: public static Bitmap RetornaImagemControle(IntPtr controle, Rectangle area)

   2:         {

   3:             SIZE size;

   4:             IntPtr hBitmap;

   5:

   6:             IntPtr hDC = GetDC(controle);

   7:             IntPtr hMemDC = CreateCompatibleDC(hDC);

   8:

   9:             size.cx = area.Width - area.Left;

  10:             size.cy = area.Bottom - area.Top;

  11:

  12:             hBitmap = CreateCompatibleBitmap(hDC, size.cx, size.cy);

  13:

  14:             if (hBitmap != IntPtr.Zero)

  15:             {

  16:                 IntPtr hOld = (IntPtr)SelectObject(hMemDC, hBitmap);

  17:                 BitBlt(hMemDC, 0, 0, size.cx, size.cy, hDC, 0, 0, SRCCOPY);

  18:                 SelectObject(hMemDC, hOld);

  19:                 DeleteDC(hMemDC);

  20:                 ReleaseDC(GetDesktopWindow(), hDC);

  21:                 Bitmap bmp = System.Drawing.Image.FromHbitmap(hBitmap);

  22:                 DeleteObject(hBitmap);

  23:                 return bmp;

  24:             }

  25:             else

  26:             {

  27:                 return null;

  28:             }

  29:         }

O nosso método recebe como parâmetro um IntPtr, que pode representar qualquer controle ou janela do Windows, e recebe também uma estrutura que representa a área que iremos capturar, pois poderemos querer apenas uma parte do nosso controle transformado em uma imagem.

Iniciamos pegando os identificadores necessários (linhas 6 e 7) e em seguida calculamos o tamanho do nosso Bitmap de captura (linhas 9 e 10), para depois já criarmos este Bitmap (linha 12). Caso consigamos criar o Bitmap, então vamos fazer o vínculo do Bitmap (linha 16), e finalmente iremos executar o método que faz toda a mágica, ou seja, que copia o conteúdo do controle para o nosso Bitmap (linha 17).

Após isto iremos liberar os recursos utilizados (linhas 19 e 20), criamos finalmente o nosso Bitmap (linha 21) e liberamos o último recurso alocado. Ufa! Agora é só retornar o Bitmap com o resultado.

Utilizando a classe para capturar uma informação:

Agora que já temos a classe, vamos voltar para o nosso Windows Forms e mostrar como ele irá funcionar. Para isto adicione um controle Button e também um PictureBox, de maneira que a tela fique parecida com a seguinte:

image

Vamos adicionar o código para o botão “Capturar Desktop”:

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

   2:         {

   3:             imagemCapurada.Image = Tela.RetornaImagemControle(IntPtr.Zero, Screen.PrimaryScreen.WorkingArea);

   4:         }

Este código tem um truque bem interessante. Como eu falei no início deste post, iríamos capturar uma tela e toda tela no Windows possui um identificador, sendo assim, o nosso Desktop tem a identificação ZERO, ou seja, informando IntPtr.Zero como o nosso controle a ser capturado, iremos capturar o Desktop do Windows, e para conseguirmos capturar toda a tela, eu utilizei a propriedade PrimaryScreen.WorkingArea, que retorna o tamanho do nosso Desktop.

Para finalizar, iremos implementar um outro botão que irá capturar a nossa própria tela, para isto adicione um novo botão ao formulário e acrescente o código a seguir:

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

   2:         {

   3:             imagemCapurada.Image = Tela.RetornaImagemControle(this.Handle, new Rectangle(0,0,this.Width,this.Height));

   4:         }

   5:

Veja que agora estamos informando o identificador do nosso form e também o seu tamanho, mas você pode informar o identificador de qualquer controle e qualquer tamanho, e talvez capturar uma parte do controle original.

Veja como fica a tela capturada:

image

Conclusão:

Este post mostra duas coisas bem interessantes: como interoperar com a API do Windows e como capturar o conteúdo de uma janela do Windows.

Espero que tenham gostado e que principalmente seja útil no seu dia a dia.

Um grande abraço e até a próxima.

Carlos dos Santos.

Entity Framework–CodeBase Configuration (Interception)

Olá pessoal,

Uma das novidades do Entity Framework 6 é a possibilidade de fazermos as configurações do nosso modelo usando código ao invés dos tradicionais arquivos de configuração (app.config/web.config). Além disto, temos agora muitas outras configurações que podem ser modificadas através da classe DbConfiguration.

Dentre as várias opções de configuração que temos através do DbConfiguration, existe uma chamada Interception (veja mais aqui), onde podemos interceptar várias operaçoes que são enviadas ao banco de dados pelo Entity Framework. Neste exemplo iremos interceptar o envio de comandos para o banco de dados e gerar um arquivo texto de log.

Criando o projeto de exemplo:

Para começar, vamos criar um projeto do tipo Console usando o Visual Studio 2013 e em seguida iremos adicionar o Entity Framework através do NuGet:

image

Adicionando o Entity Framework Code First:

Após criado o projeto, vamos adicionar o Entity Framework através do NuGet. Para isto abra o menu Tools/Library Package Manager/Package Manager Console e depois digite o comando abaixo:

PM> Install-Package EntityFramework

Neste exemplo estou utilizando também o Entity Framework PowerTools,  pois vamos fazer uma engenharia reversa do banco de dados NorthWind, que é disponibilizado pela Microsoft aqui. O recurso de engenharia reversa permite que possamos pegar um banco de dados existente e gerar as classes para o Entity Framework a partir dele.

Para fazer a engenharia reversa, clique com o botão direito do mouse em cima do nome da sua solution e no menu de contexto escolha: Entity Framework/Reverse Engineer Code First, conforme a figura abaixo:

image

Este comando irá abrir uma janela solicitando as informações do banco de dados. Complete com as suas informações, no meu caso a tela é a seguinte:

SNAGHTML5372fbd

Iniciando a implementação do Interception

Agora que já temos o banco de dados mapeado, vamos implementar a classe de configuração. Adicione ao projeto uma nova classe chamada Configuracao.cs e vamos colocar o código abaixo:

   1: public class Configuracao : DbConfiguration

   2:     {

   3:         public Configuracao()

   4:         {

   5:             

   6:         }

   7:     }

Esta é a classe base para a configuração. Nenhum código é necessário para chamar esta classe, pois o Entity Framework irá identificá-la desde que esteja no mesmo Assembly da aplicação, ou seja, você não precisa chamar esta classe diretamente em nenhuma parte do seu código.

Como vamos interceptar os comandos enviados para o banco de dados e iremos gerar um log, vamos implementar a nossa classe que irá gerar os logs. Para isto vamos criar uma outra classe chamada InterceptaSQL, veja o código abaixo:

   1: public class InterceptaSQL: IDbCommandInterceptor

   2:     {

   3:  

   4:         private string arquivoLog;

   5:         public InterceptaSQL()

   6:         {

   7:             string caminho = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetModules()[0].FullyQualifiedName);

   8:             arquivoLog = Path.Combine(caminho, "Log.txt");

   9:         }

  10:  

  11:         private void EscreveLog(string s)

  12:         {

  13:             StreamWriter log = File.AppendText(arquivoLog);

  14:             log.WriteLine(string.Format("{0} - {1}n", DateTime.Now.ToString(), s));

  15:             log.Close();

  16:         }

  17:         public void NonQueryExecuting(

  18:             DbCommand command, DbCommandInterceptionContext<int> interceptionContext)

  19:         {

  20:             GravaLog("Executando SQL",command, interceptionContext);

  21:         }

  22:  

  23:         public void NonQueryExecuted(

  24:             DbCommand command, DbCommandInterceptionContext<int> interceptionContext)

  25:         {

  26:             GravaLog("SQL executado",command, interceptionContext);

  27:         }

  28:  

  29:         public void ReaderExecuting(

  30:             DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)

  31:         {

  32:             GravaLog("Executando Reader",command, interceptionContext);

  33:         }

  34:  

  35:         public void ReaderExecuted(

  36:             DbCommand command, DbCommandInterceptionContext<DbDataReader> interceptionContext)

  37:         {

  38:             GravaLog("Reader executado",command, interceptionContext);

  39:         }

  40:  

  41:         public void ScalarExecuting(

  42:             DbCommand command, DbCommandInterceptionContext<object> interceptionContext)

  43:         {

  44:             GravaLog("SQL Scalar executando",command, interceptionContext);

  45:         }

  46:  

  47:         public void ScalarExecuted(

  48:             DbCommand command, DbCommandInterceptionContext<object> interceptionContext)

  49:         {

  50:             GravaLog("SQL Scalar executado",command, interceptionContext);

  51:         }

  52:  

  53:         private void GravaLog<TResult>(string TipoComando,

  54:             DbCommand command, DbCommandInterceptionContext<TResult> interceptionContext)

  55:         {

  56:             if (interceptionContext.Exception != null)

  57:             {

  58:                 EscreveLog(string.Format("ERRO - Comando SQL: {0},  falhou com exceção: {1}",

  59:                     command.CommandText, interceptionContext.Exception));

  60:             }

  61:             else

  62:             {

  63:                 EscreveLog(string.Format("{0}: {1}",TipoComando, command.CommandText));

  64:             }

  65:         }

  66:     }

Nesta classe estamos implementando todos os métodos da interface IDbCommandInterceptor, e também o nosso método para a geração do arquivo texto com o log (linhas 11 a 16). Neste exemplo eu escolhi gravar o arquivo de log no mesmo diretório da aplicação e para isto eu peguei o diretório dentro do assembly usando reflection (linha 7). A gravação do log é bem simples e armazenamos a data/hora, o tipo da operação e o comando executado. Você pode modificar o método GravaLog() e tratar qualquer outra informação que achar necessária.

Ativando a Interceptação

Agora que já implementamos a nossa classe para interceptar os comandos, precisamos informar ao Entity Framework da existência desta classe. Para isto vamos voltar a nossa classe Configuracao.cs e adicionar o código abaixo ao construtor:

   1: public class Configuracao : DbConfiguration

   2:     {

   3:         public Configuracao()

   4:         {

   5:             this.AddInterceptor(new InterceptaSQL());

   6:         }

   7:     }

O método AddInterceptor() informa ao Entity Framework que iremos interceptar as operações descritadas na classe InterceptaSQL.

Testando a implementação

Para testamos a nossa classe, vamos executar algumas operações no Entity Framework. Veja abaixo o código que utilizamos em Program.cs:

   1: static void Main(string[] args)

   2:         {

   3:             var db = new NorthwindContext();

   4:  

   5:             foreach(var p in db.Products)

   6:             {

   7:                 Console.WriteLine(p.Category.CategoryName+", "+p.ProductName);

   8:             }

   9:  

  10:             var altera = db.Products.Where(p => p.ProductID == 1).FirstOrDefault();

  11:             if(altera != null)

  12:             {

  13:                 altera.UnitPrice = 10;

  14:                 db.SaveChanges();

  15:             }

  16:         }

Ao executarmos o programa o seguinte arquivo Log.txt é gerado (apenas uma parte do arquivo foi colada aqui):

   1: 29/12/2013 23:51:38 - Executando Reader: select serverproperty('EngineEdition')

   2:  

   3: 29/12/2013 23:51:38 - Reader executado: select serverproperty('EngineEdition')

   4:  

   5: 29/12/2013 23:51:39 - Executando Reader: SELECT 

   6:     [Extent1].[ProductID] AS [ProductID], 

   7:     [Extent1].[ProductName] AS [ProductName], 

   8:     [Extent1].[SupplierID] AS [SupplierID], 

   9:     [Extent1].[CategoryID] AS [CategoryID], 

  10:     [Extent1].[QuantityPerUnit] AS [QuantityPerUnit], 

  11:     [Extent1].[UnitPrice] AS [UnitPrice], 

  12:     [Extent1].[UnitsInStock] AS [UnitsInStock], 

  13:     [Extent1].[UnitsOnOrder] AS [UnitsOnOrder], 

  14:     [Extent1].[ReorderLevel] AS [ReorderLevel], 

  15:     [Extent1].[Discontinued] AS [Discontinued]

  16:     FROM [dbo].[Products] AS [Extent1]

  17:  

  18: 29/12/2013 23:51:39 - Reader executado: SELECT 

  19:     [Extent1].[ProductID] AS [ProductID], 

  20:     [Extent1].[ProductName] AS [ProductName], 

  21:     [Extent1].[SupplierID] AS [SupplierID], 

  22:     [Extent1].[CategoryID] AS [CategoryID], 

  23:     [Extent1].[QuantityPerUnit] AS [QuantityPerUnit], 

  24:     [Extent1].[UnitPrice] AS [UnitPrice], 

  25:     [Extent1].[UnitsInStock] AS [UnitsInStock], 

  26:     [Extent1].[UnitsOnOrder] AS [UnitsOnOrder], 

  27:     [Extent1].[ReorderLevel] AS [ReorderLevel], 

  28:     [Extent1].[Discontinued] AS [Discontinued]

  29:     FROM [dbo].[Products] AS [Extent1]

Conclusão

O novo recurso de interceptação de comandos do Entity Framework pode ser bastante útil para você fazer depurações e análises dos comandos enviados ao banco de dados, inclusive testes de performance, já que gravamos a data/hora do início da execução e também do final.

Logicamente que este é um log bem mais aprofundado do que eu já mostrei neste outro post, mas a idéia principal é você entender o novo mecanismo de configuração do Entity Framework, que abre muitas possibilidades, incluindo a que acabamos de explorar.

Baixe o código fonte do exemplo.

Um grande abraço e até a próxima,

Carlos dos Santos.

Melhorando o tempo de carga do Entity Framework com NGEN

A partir do Entity Framework 6, todos os componentes do EF estão dentro da DLL EntityFramework.dll e não mais divididas entre vários componentes do .Net Framework. Sendo assim, a DLL do EF não está otimizada para o JIT (Just in Time) do computador onde está sendo rodado, assim como o .Net está.

Nós podemos melhorar isto executando o comando Ngen.exe, que pré-compila a DLL e elimina este processo durante a carga da DLL. Assim o tempo de carga fica menor e podemos ganhar alguns segundos na carga da nossa aplicação.

Para fazer isto, abra um prompt de comandos do Visual Studio Studio, ele fica dentro das opções de instalação do Visual Studio, com um nome parecido com este: “Developer Command Prompt for VS 20xx”. No meu caso estou usando o VS 2013, então o prompt está como “Developer Command Prompt for VS2013”.

Abra este prompt como administrador, vá até o diretório da sua aplicação e execute o comando NGen, como abaixo:

C:Meu Projeto>ngen install EntityFramework.dll

Após isto você verá uma tela parecida como esta:

image

Valeu pessoal e até a próxima,
Carlos dos Santos.

Visual Studio 2013–Novidades

Olá pessoal,

O Visual Studio 2013 será lançado no próximo dia 13/11/2013 (para assinantes do MSDN já está disponível) e junto com esta nova versão temos melhorias muito interessantes na IDE, que tornam o nosso dia a dia ainda mais produtivo.

Neste post vou mostrar algumas destas novas funcionalidades que eu particularmente uso a todo momento e que ajudam muito no desenvolvimento. Enão vamos lá:

Peek Definition (ALT F12)

Imagine que você está escrevendo um método qualquer e precisa verificar um método que está em outra classe, normalmente você pressionar o F2 e olha a classe, e depois volta para o seu código. Isto é bem funcional, mas tira o foco do código que você está trabalhando. Agora no Visual Studio 2013, você tem o Peek Definition, que é acionado pela tecla ALT + F12, onde o código é mostrado para você na mesma janela, em cima do método.

Eu criei um projeto bem simples, com Entity Framework 6 acessando o banco de dados NorthWind e neste projeto tem um método RetornaClientes() que simplesmente volta uma lista de clientes (A idéia aqui não é focar na funcionalidade do projeto e sim na IDE).

Veja o código abaixo:

image

Agora, com o mouse em cima do método RetornaClientes, pressione ALT F12:

image

É muito simples, agora você está vendo o código do método RetornaClientes() na mesma janela que estava trabalhando. E você pode pressionar o ALT F12 dentro desta janela também e ir navegando pelos códigos, sem precisar ficar alternando entre duas ou mais janelas.

Code Lens

Este é um recurso também muito útil, principalmente se você está trabalhando em um código de que você não conhece bem, mas como assim: quantas vezes você já precisou fazer uma busca no código para localizar a utilização de uma propriedade ou um método ? Quase sempre eu imagino! Isto toma muito tempo e abaca deixando um monte de janelas abertas na sua IDE.

O Code Lens pode te ajudar muito nisto. A idéia básica é que para cada classe, propriedade ou método, você tem uma referência logo acima do nome que indica quantas vezes ele está referenciado,ou seja, quem está utilizando esta classe, propriedade ou método.

Veja no mesmo exemplo, onde temos o Entity Framework referenciando o banco de dados NorthWind, ao abrirmos o código fonte da classe NortwindContext.cs, temos o Code Lens acima dos nomes, veja:

image

Isto quer dizer, por exemplo, que a classe NortwindContext está sendo referenciada 5 vezes. E ao clicar sobre o número:

image

E ao passar o mouse sobre as referências, você consegue ver em que parte do código fonte ele está sendo usado:

image

Sem dúvida um recurso muito útil e que vai deixar o seu dia ainda mais produtivo.

Nova Scroll Bar

Agora você pode configurar a barra de scroll do seu editor de código para deixá-la mais interessante do que apenas rolar o código. Podemos transformar a barra do scroll em um visualizador de códigos que pode facilitar a navegação pelas linhas do seu programa.

Para ativarmos este recurso, basta clicar com o botão direito do mouse sobre a barra latera e escolher Scroll Bar Options:

image

E depois é só configurar:

image

Ative a opção “Show Preview Tooltip” e depois escolha o tamanho da barra de scroll. Após a configuração você verá uma nova barra de scroll, como esta:

image

Sua barra agora contem um resumo de todo o código fonte do arquivo e ao mover o mouse sobre a barra, você verá uma prévia do código fonte.

É isto aí pessoal, espero que as dicas sejam úteis e que todos comecem a utilizar o novo Visual Studio 2013.

Abraços e até a próxima,
Carlos dos Santos.

Palestra de Windows Azure–Cesumar

Pessoal,

Ontem (18/09/2013) fiz uma palestra sobre Windows Azure no Cesumar em Maringá, onde mostrei as funcionalides do Azure e como é possível criar e migrar aplicações para a nuvem.

Gostaria de agradecer ao Clodoaldo Assis pelo convite, ao Cesumar pela oportunidade e principalmente pelas pessoas presentes e pela excelente interação que tivemos ao final da palestra.

Para baixar a apresentação, acesse aqui e para ver as fotos do evento, acesse minha págiina no facebook.

Abraços e até a próxima,
Carlos dos Santos.

Entity Framework 6–Gerando Log dos comandos SQL

Olá,

O Entity Framework 6 RC já foi lançado! Agora é a hora de começar a trabalhar na migraçãoda versão 5 para a 6 e ver as novas funcionalidades. As especificações sobre as novas funcionalidades podem ser encontradas aqui.

Dentre as muitas novidades, que vamos explorar nos post seguintes, hoje vou destacar uma que acho bem interessante: o log dos comandos enviados ao banco de dados.

Um ORM (Object-Relational Mapping), ou simplesmente um Mapeamento Objeto-Relacional traduz comandos de uma linguagem de programação, no nosso caso C# e LINQ, para comandos de banco de dados. A eficiência do ORM está diretamente relacionada a como os comandos para o banco de dados são gerados, ou seja, pegar os comandos escritos em C# e convertê-los em comandos SQL.

Na versão 6 do Entity Framework foi introduzido um novo objeto que nos permite interceptar os comandos que estão sendo enviados para o banco de dados e assim podemos ver o que acontece “por baixo dos panos”. Isto também podem ser feito colocando uma ferramenta de profiler de banco de dados. No caso do Microsoft SQL Server esta ferramenta é o SQL Server Profiler, mas existem vários outros.

No caso do nosso exemplo, vamos executar um método para cada operação em LINQ que será executada no Entity Framework, e para iniciarmos o nosso exemplo, vamos criar um projeto do tipo Console Application usando o .Net 4.5 (o uso do .Net 4.5 é importante para suportar todas as funcionalidades do Entity Framework 6).

Criando um novo projeto do tipo Console Application:

SNAGHTML476eb602

Criado o nosso projeto, vamos adicionar o Entity Framework através da janela do  Nuget, que está em Tools/Library Packager Manager/Packager Manger Console e dentro dele iremos executar o comando abaixo:

PM> Install-Package EntityFramework –Pre

Veja que a opção “-Pre” é quem irá instalar o Entity Framework 6 RC, visto que ele ainda não foi liberado oficialmente e ainda é um release candidate.

Agora vamos criar um contexto bem simples com uma classe Cliente. Para isto adicione uma nova classe e chame-a de Contexto, como no exemplo abaixo:

   1: public class Contexto : DbContext

   2: {

   3:     public DbSet<Cliente> Cliente {get; set;}

   4:  

   5: }

Agora vamos adicionar a classe Cliente:

   1: public class Cliente

   2:     {

   3:         public int ID { get; set; }

   4:         public string Nome { get; set; }

   5:     }

E por fim vamos modificar o arquivo App.Config para direcionarmos o local e o nome do banco de dados a ser criado: (isto é somente um exemplo e o seu arquivo poderá ficar diferente)

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

   2: <configuration>

   3:   <connectionStrings>

   4:     <add name="Contexto" connectionString="data source=(local); initial catalog=EFLog; integrated security=true;" providerName="System.Data.SqlClient"/>

   5:   </connectionStrings>

   6: </configuration>

Agora vamos ao que interessa, ou seja, vamos adicionar o LOG do SQL. Para isto, no Program.cs vamos inserir os seguintes comandos:

   1: class Program

   2:     {

   3:         static void Main(string[] args)

   4:         {

   5:             var db = new Contexto();

   6:             db.Database.Log = GravaLog;

   7:  

   8:             var cli = new Cliente() { Nome = "Carlos" };

   9:             db.Cliente.Add(cli);

  10:             db.SaveChanges();

  11:  

  12:             var consulta = from c in db.Cliente

  13:                            select c;

  14:             foreach(var c in consulta)

  15:             {

  16:                 Console.WriteLine(c.Nome);

  17:             }

  18:         }

  19:  

  20:         public static void GravaLog(string sql)

  21:         {

  22:             Console.WriteLine("Comando SQL: "+sql);

  23:         }

  24:     }

O método GravaLog() é atrbuído a propriedade Log do DataBase do Contexto, sendo assim, todos os comandos enviados para o banco de dados são também enviados para este método e dentro dele simplesmente chamamos o método Console.WriteLine() para mostrar os comandos na tela.

Ao executar o programa, você verá algo como a imagem abaixo:

SNAGHTML47817c48

Esta é uma implementação bastante simples da implementação do Log de comandos disponível agora na versão 6, mas com certeza você poderá utilizar de uma maneira bem mais elaborada em seus projetos.

Abraços e até a próxima,
Carlos dos Santos.

Entity Framework 6–Trabalhando com os Nightly Builds

Olá pessoal,

Voltando agora a escrever mais sobre o Entity Framework, estamos aguardando a nova versão 6 (ainda sem data definitiva para ser lançado) que trará melhorias muito significativas e vamos explorar algumas delas nos próximos artigos.

Antes de qualquer coisa é importante saber que o Entity Framework 6 ainda está em versão Alfa (isto mesmo ALFA), sendo assim não é recompendado utilizar em projetos que já estejam em produção, o que não nos impede de já ir testando algumas coisas bem legais.

A primeira coisa é como instalar o EF 6 em um projeto. Normalmente você usar o Nuget Package Console para adicionar o EF a um projeto seu, com o seguinte comando: (abra antes o Tools/Library Package Manager/Package Manager Console)

PM> InstallPackage EntityFramework

Mas irá instalar o EF 5 que é a última versão de produção, lançada juntamente com o Visual Studio 2012 e o .Net 4.5. Mas se você quer instalar o EF 6 em um projeto, terá que utilizar o seguinte comando:

PM> InstallPackage EntityFramework –Pre

Isto irá instalar a última versão publicada do EF 6, que atualmente é a Alfa 1. Legal, isto permite que você trabalhe com o EF 6 e explore algumas funcionalidades bem interessantes, mas não queremos isto, queremos as coisas legais ainda não publicadas.

Acessando os Builds Noturnos

O EF 6, como todos já devem saber, é Open Source e todo o seu código fonte, eu realmente disse todo o código fonte, pode ser baixado no endereço http://entityframework.codeplex.com. Eu recomendo que você baixe o código e dê uma olhada em como o projeto está estruturado, como são os testes unitários. O código fonte do EF é, sem dúvida alguma, uma excelente fonte de estudos.

Apesar do EF 6 ser totalmente open source, apenas a Microsoft libera as versões oficiais e também as chamadas Nightly Builds ou Build Noturnos, que nada mais são do que uma versão diária do que está sendo desenvolvido pela Microsoft e pela comunidade que está colaborando no projeto. Se você é, assim como eu, uma pessoa que gosta muito das novidades e fica ansioso por testá-las, estes builds noturnos nos dão isto.

Para ter acesso aos Nightly Builds você precisa configurar o Visual Studio para acessar o endereço onde eles são publicados diariamente. Vamos fazer isto acessando a configuração do NuGet em Tools/Library Package Manager/Package Manager Settings e depois em Package Source:

SNAGHTMLc0f2ab2

Clique no botão “+” e depois preencha os campos:

Name: Nightly Builds
Source: http://www.myget.org/F/aspnetwebstacknightly/

Salve clicando no OK. Agora que já configuramos, vamos criar um projeto do tipo Console para poder adicionar a última versão nortuna publicada. Para isto crie o projeto do tipo Console, escolhendo o .Net 4.5 pois alguns novos recursos só irão funcionar nesta versão do .Net.

Com o projeto criado, clique com o botão direito do mouse no nome da sua solução e depois escolha Manage Nuget Packages e você verá a imagem abaixo:

SNAGHTMLc1440a3

Veja que já temos os Nightly Builds na nossa janela, mas antes ainda precisamos indicar que queremos os “Pre Releases”, que são as versões ainda não oficiais. Você pode fazer isto clicando na opção “Stable Only” e mudando para “Include Prerelease”.

Feito isto vamos clicar em “Nightly Builds” e na janela de busca vamos digitar “Entity” e veja que você verá a última versão publicada, no meu caso do dia 18/08/2013:

SNAGHTMLc172099

Agora é só clicar em “Install” para instalar a última versão.

Uma lista da novas funciondalidades pode ser obtidas no endereço: http://entityframework.codeplex.com/wikipage?title=specs

Nos próximos post iremos explorar mais detallhadamente algumas destas novas funcionalidades!

Abraços e até a próxima,
Carlos dos Santos.