Archive for the ‘C#’ Category.

MVA Student to Business–Desenvolvimento de Sistemas

Olá pessoal,

Recentemente eu gravei um vídeo sobre o Visual Studio 2015 para o programa Student to Business. Neste vídeo eu dou uma visão geral do Visual Studio e da Plataforma .Net, mostro também algumas das plataformas e o que é possível fazer com ela.

Se você é um iniciante na ferramenta ou até mesmo quer entender melhor o que ela faz, recomendo que você assista ao vídeo clicando aqui.

Este é um treinamento do MVA, e tem outros conteúdos, então você pode assistir aos vídeos e também fazer as provas.

Abraços,
Carlos dos Santos.

TechEd 2015

Este foi um evento sensacional, uma tela gigante no keynote e palestrantes incríveis, como o chefe do Microsoft Research (Rico Malvar), que é um brasileiro e fez uma demonstração ao vivo do Skype Translator em Português. Bom também foi rever os amigos e principalmente ser palestrante em duas sessões deste que foi o maior evento de tecnologia da América Latina. Tivemos também uma participação especial do maestro João Carlos Martins, uma pessoa com uma história de vida e superação incríveis!

Sem palavras para expressar a emoção de estar falando para salas cheias, com muitas perguntas sobre os conteúdos. Neste evento falei sobre o Application Insights, uma ferramenta sensacional para telemetria e também, junto com o Giovanni Bassi, falamos do novo compilador C# (projeto Roslyn) e também um pouco do nosso projeto CodeCracker.

E sabe qual a melhor parte do evento ? Fazer networkink, rever os amigos, conhecer gente nova, trocar experiências! Então se você não foi a este evento, faça o possível para participar do próximo!!!

Aqui estão os Slides das minhas palestras:
Application Insights
Entendendo o Impacto do Roslyn no C# e no Visual Basic

E para você que não pode ir, veja aqui as fotos do evento.

Foi um prazer estar no evento e obrigado a todos que assistiram as minhas palestras!

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

Hangout Projeto CodeCracker

Pessoal,

hoje fizemos mais um hangout sobre o projeto CodeCracker que estamos trabalhando desde novembro de 2014. Este projeto trata da criação de analisadores estáticos de código e fixers utilizando o novo compilador Roslyn. É um projeto totalmente open source e está hospedado no GutHub.

Se você está interessado em aprender como o compilador funciona e escrever analisadores de código, nós estamos procurando você Smile

Assista ao vídeo que conta um pouco do que está acontecendo no projeto e também onde mostramos as várias formas de contribuição, mesmo que você não entenda muito de GitHub, porque isto podemos ensinar par você.

Visite o site do projeto no GitHub e assista ao vídeo.

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

Build Tour São Paulo

Na semana passada tivemos o Build Tour em São Paulo, uma versão compacta do evento americando. Neste evento foram mostradas várias novidades do Windows 10 e da nova plataforma de desenvolvimento, a Windows Universal Apps.

no dia seguinte ao evento, eu e mais dois MVPs fomos convidados a comentar o evento na sede da Microsoft. Esta nossa conversa foi transmitida ao vivo e agora está disponível no site para quem não pode assisir. Então se você não conseguiu acompanhar as novidades do Build, acesse a gravação e veja nossos comentários!

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

C# 6

Fala pessoal,

Na última sexta-feira (27/02) eu fiz uma palestra online no Codificando Night Week sobre as novidades do C# 6. O vídeo da minha apresentação já está no Youtube e pode ser baixado aqui. Disponibilizei também os PPT no Slideshare e você pode obter neste link.

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

Visual Studio 2015 e C# 6–Algumas Novidades

Olá, como todos já devem saber a Microsoft liberou na última quarta-feira (12/11) a versão Public Preview do Visual Studio 2015 e também uma versão free agora chamada de Visual Studio 2013 Community. Junto com o Visual Studio 2015 temos agora o novo C# 6. Neste post vou falar sobre algumas das novidades da IDE e também do C# 6.

Novidades da IDE:

Code Fixer: identifica problemas no código e mostrar possíveis soluções:

image

Ao encontrar um possível problema no código, é mostrada uma pequena “lâmpada amarela” que ao ser clicada mostra os fixers disponíveis. O mais interessante é que você tem um preview do seu código com a aplição do Fixer:

image

Após isto é só escolher o fixer que mais lhe agrada e aplicá-lo. Nem precis dizer que isto aumenta exponencialmente a sua produtvidade!!!

InLine Rename: renomeia o seu código e mostrando o que será modificado em destaque

image

Ao clicar com o botão direito do mouse sobre o nome “Funcao” e escolher Rename, todas os locais já são identificados e o rename é feito diretamente no editor, digitando sobre o nome em destaque e tem mais, você pode renomear até o que em comentários, basta configurar a janela abaixo, que aparece no canto direito do seu editor.

image

Novo Gerenciador de Pacotes NuGet:

Você já deve utilizar o NuGet para instalaer componentes em seus projetos, eu mesmo já demonstrei isto em vários outros posts aqui no blog. Mas agora é possível gerenciar e instalar os pacotes através de uma nova janela bem mais simples, que você abre clicando com o botão direito do mouse em Referentes na sua Solution:

image

Isto abre a nova janela o NuGet:

image

Esta janela tem uma grande novidade que é permitir você escolher a versão do pacote que quer instalar. Mas você ainda pode continuar instalando seus pacotes pelo gerenciador de linha de comando.

Novidades do C# 6:

Formatando Strings:

Hoje para formatarmos uma string, utilizamos String.Format():

var X = 10; 

var Y = 20;

var str0 = string.Format("Valor de X: {0} e Y: {1}", X,Y);

Mas com o C# 6, podemos fazer isto desta forma:

var X = 10; 
var Y = 20; 

var str1 = "Valor de X: \{X} e Y: \{Y}";

Aqui nos simplesente montamos a string e no local onde queremos os valores, nós os colocamos precedidos de uma barra invertida e dentro de colchetes.

Usando operadores nulos (?.):

É muito comum durante o desenvolvimento você verificar se algum tipo objeto não é nulo, para assim chamar algum método ou valor. Normalmente faríamos assim:

var conexao = new SqlConnection("data source=(local); initial catalog=northwind; integrated security=true"); 
var cmd = new SqlCommand("select CompanyName from customers where CustomerID='AAAA'", conexao); 
conexao.Open(); 

var retorno = cmd.ExecuteScalar(); 
if(retorno != null) 
{    
     var dados = retorno.ToString(); 
} 
conexao.Close(); 
 

Agora podemos fazer assim:

dados = retorno?.ToString(); 
 

Isto informa ao compilador que é para ele executar o ToString() somente se a variável retorno for diferente de null. Simples não!!!

Exception Filters:

Você certamente trata os erros em sua aplicaçao através de Try…Catch…Finally, algo como o código abaixo:

try 
{
}
catch (SqlException ex)
{
}
finally 
{ 
} 

Agora imagine que você queira que a excecão SqlException disparasse somente se houvesse uma condição para isto acontecer:

try 
{ 
} 
catch (SqlException ex) if(ex.Server == "MeuServidorLocal") 
{ 
} 
finally 
{ 
} 

No nosso exemplo, a exceção só dispara se o nome do servidor for “MeuServidorLocal”

Novo compilador Roslyn (.Net Compiler Platform)

Esta é sem dúvida alguma a maior de todas as novidades, pois muito do quev acabei de escrever acima só é possível graças ao novo compilador. No meu post anterior eu falei brevemente sobre o novo compilador e também sobre um projeto Open Source da qual eu estou fazendo parte.

É isto aí pessoal, a idéia deste primeiro post sobre o Visual Studio 2015 e C# 6 é só para você sentirem o que está vindo por aí! Leiam, estudem, aproveitem!!!

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

Carlos dos Santos

C# Roslyn e Projeto Open Source–CodeCracker

Esta semana a Microsoft anunciou o novo Visual Studio 2015 e junto com ele o C# 6 com seu novo compilador, anteriormente conhecido como Roslyn e agora oficialmente chamado de .Net Compiler Platform.

Com o Roslyn possível termos acesso a estrutura do compilador, sua árvore sintática e também mudar o seu comportamento através de componentes chamados Analyzers.

Na semana passada, quando eu estava na sede da Microsoft em Redmond/USA, participei de um hackaton com o time do compilador Roslyn, onde eu e diversos outros MVPs tivemos a oportunidade de escrever alguns analyzers juntamente com o time do Roslyn e durante este mesmo evento surgiu a idéia de criarmos um projeto Open Source contendo diversos analyzers, totalmente aberto e free, disponível para toda a comunidade de desenvolvedores, nascia então o projeto CodeCracker, naquele momento criamos o time inicial, composto por mim, Giovanni Bassi e o Elemar Junior, todos MVPs de C#. Subimos então os primeiros analyzers e agora estamos trabalhando nest projeto.

Como o projeto é Open Source está no GitHub, todo desenvolvedor que tiver interessde em participar, codificar junto com a gente, basta entrar em contato que adicionamos ao projeto, afinal queremos criar muitos analyzers e fixes!!!

Falando um pouco do que são os analyzers, vou explicar mostrando como eles funcionam, sendo assim, imagine então que você pode condicionar o compilador a validar o código fonte e apontar possíveis melhorias, ja fazendo as correções necessárias, tudo isto no editor de código fonte.

Vamos então a um pequeno exemplo de código:

image

Este é um típico código onde o desenvolvedor não fez o tratamento da exceção. Agora com um dos Analyzers, o compilador já sugere uma correção:

image

E ao clicar na opção para corrigir, o código já é modificado:

image

Esta é a idéia dos analyzers e fixers que estamos construindo no projeto. Se você achou útil, pode começar a utilizar agora mesmo a versão alfa através do Nuget abaixo:

Se você achou demais a idéia e quer escrever analyzers, fale com a gente e participe do projeto open source!

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

Dapper–Um Micro ORM muito interessante

Olá pessoal,

Eu utilizo muito EntityFramework nos projetos da empresa, pois trabalhar com classes e objetos é muito mais simples do que utulizar acessio a dados tradicionais. Mas recentemente comecei a utilizar o Dapper, que pode ser chamado de um micro ORM, pois ele possui algumas funcionalidades bem pontuais para trabalharmos com acesso a dados.

Então vamos pensar em um cenário onde você precisa consultar um banco de dados qualquer, e colocar o resultado desta consulta em um objeto. Você logo pensaria em criar uma classe, fazer um mapeamento para um contexto, etc. Sim, este seria o caminho normal para um ORM, mas não para o Dapper.

O Dapper trabalha com extension methods para a sua conexão, ou seja, você irá inicialmente criar uma conexão para o seu banco de dados, como se fosse utilizar ADO.Net, por exemplo: SqlConnection, OracleConnection, MySqlConnection, etc. No caso do Dapper, você também é o responsável por abrir e fechar a sua conexão.

Como ele trabalha com métodos de extensão sobre a conexão, o que temos a fazer é instalar o Dapper via NuGet, criar a nossa conexão e começar a utilizar.

Para começaramos a utilizar, vamos criar um projeto console no Visual Studio:

SNAGHTML115102b5

Agora vamos instalar o Dapper utilizando NuGet (Tools/NuGet Packager Manager/Packager Manager Console:

PM> install-package Dapper

Agora vamos escrever um código simples para um Select no banco de dados. No nosso exemplo vou utilizar o banco de dados NorthWind da Microsoft. Vou então fazer um select simples na tabela Customer:

 
using System; 
using System.Collections.Generic; 
using System.Data.SqlClient; 
using System.Linq; 
using System.Text; 
using Dapper;  

namespace ExemploDapper 
{     
     class Program
     {
         static void Main(string[] args)
         {
             SqlConnection conexao = new SqlConnection("data source=(local); initial catalog=northwind; integrated security=true;");
             conexao.Open();
             var dados = conexao.Query("select * from customers");
             foreach (dynamic linha in dados)
             {
                 Console.WriteLine("{0} - {1}", linha.CustomerID, linha.CompanyName);
             }
             conexao.Close();
         }
     }
 }

Veja que para utilizarmos o Dapper, depois de adicionado com o NuGet, basta colocar o “using Dapper” para que o método de extensão Query() apareça na nossa conexão. E para realizar a consulta, basta informarmos o comando SQL e depois pegarmos o resultado. No exemplo acima, não utilizei uma classe como retorno e neste caso o Dapper retorna uma lista que podemos acessar com dynamic.

Vamos agora adicionar uma classe Customer ao nosso projeto, de acordo com o código abaixo:

using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ExemploDapper
{
    class Customer
    {
        public string CustomerID { get; set; }
        public string CompanyName { get; set; }
        public string City { get; set; }
    }
}

Neste exemplo estou adicionando somente alguns campos da classe. Agora vamos modificar nossa consulta utilizando a classe Customer:

var dados1 = conexao.Query<Customer>("select customerID, companyName, City from customers");
foreach (var linha in dados1)
{
     Console.WriteLine("{0} - {1}", linha.CompanyName, linha.City);
}

Vamos agora incrementar nossa consulta adicionando um filtro:

var dados2 = conexao.Query<Customer>("select CustomerID, CompanyName, City from customers where City = @City", new { City = "London" });

foreach (var linha in dados2)
{
   Console.WriteLine("{0} - {1}", linha.CompanyName, linha.City);
}

Veja como é bem simples, basta você criar o comando Select com o parâmetro e depois passar um objeto anônimo com os valores.

Vamos agora fazer uma inclusão na tabela Categories do banco NorthWind, veja como é simples:

conexao.Query("insert into Categories(CategoryName) values(@CategoryName)",new {CategoryName = "Teste"});

A idéia é a mesma da consulta com parâmetros, você insere os parâmetros e passa um objeto com os valores.

Ao final de tudo isto, talvez você esteja se perguntando qual a vantagem de utilizar o Dapper ? A resposta é simples: performance.

Veja a tabela abaixo, comparando a velocidade de consulta:

image

Ou seja, para consultas em massa, o Dapper é mais rápido!

Ops! Isto significa que devo abandonar meu ORM e utilizar somente o Dapper, claro que a resposta é NÃO! O que você pode fazer é complementar a sua aplicação utilizando o Dapper para inclusões de dados em massa por exemplo, onde ele é mais rápido.

Neste post eu procurei fornecer uma visão geral e também uma alternativa de ORM que você pode utilizar em sua aplicação. Se você quer se aprodundar um pouco mais no Dapper, recomendo visitar a página oficial do projeto no Github.

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

Carlos dos Santos.

EntityFramework-Lendo seu banco de dados com o Visual Studio 2013 Update 2

Olá pessoal,

Há algum tempo atrás eu fiz um post falando sobre como aproveitar seu banco de dados existente com o EntityFramework PowerTools, mas o modelo do PowerTools não permite escolher as tabelas ou views que você quer ler, e ás vezes isto é bem útil.

Com o lançamento do Update 2 do Visual Studio 2013 e também do EntityFramework 6.1, foi adicionada uma nova opção nas fontes de dados, que agora permite também fazer engenharia reversa com CodeFirst escolhendo quais tabelas e views serão lidas, a exemplo do que já era possível com o EntityFramework Designer.

Para demonstrar isto, vamos criar um novo projeto do tipo Console no Visual Studio 2013:

SNAGHTMLa64a79f

Agora vamos fazer a engenharia reversa, mas utilizando o novo recurso do Visual Studio 2013. Para isto, no seu projeto clique com o botão direito do mouse na solution e depois vá em Add/New Item:

image

Agora vamos adicionar um ADO.NET Entity Data Mode:

SNAGHTMLa676ebe

E veja que agora existe uma nova opção chamada “Code First from database” e com ela iremos ler um banco de dados já existente e criar todo o código para o CodeFirst.

SNAGHTMLa69ebd4

Vamos então escolher esta opção e colocar a conexão para o nosso banco de dados existente: (no meu exemplo estou usando o banco da Microsoft chamado Northwind)

SNAGHTMLa69538c

Agora você pode escolher as tabelas e views que quiser para o seu projeto do CodeFirst:

SNAGHTMLa6b3694

Feito isto, todas as classe serão geradas no CodeFirst, mas com uma grande diferença em relação ao PowerTools: as informações de mapeamento são geradas como DataAnnotations ao invés de FluentApi. Veja o exemplo da classe Products:

   1: public partial class Products

   2:     {

   3:         [Key]

   4:         public int ProductID { get; set; }

   5:

   6:         [Required]

   7:         [StringLength(40)]

   8:         public string ProductName { get; set; }

   9:

  10:         public int? SupplierID { get; set; }

  11:

  12:         public int? CategoryID { get; set; }

  13:

  14:         [StringLength(20)]

  15:         public string QuantityPerUnit { get; set; }

  16:

  17:         [Column(TypeName = "money")]

  18:         public decimal? UnitPrice { get; set; }

  19:

  20:         public short? UnitsInStock { get; set; }

  21:

  22:         public short? UnitsOnOrder { get; set; }

  23:

  24:         public short? ReorderLevel { get; set; }

  25:

  26:         public bool Discontinued { get; set; }

  27:

  28:         public virtual Categories Categories { get; set; }

  29:     }

Veja que a classe foi gerada e o DataAnnotations foi criado.

Agora é só utilizar o EntityFramework CodeFirst!

Abraços e até a próxima,

Carlos dos Santos.

Criando Índices no Entity Framework CodeFirst

Olá pessoal,

A partir da versão 6.1 do EntityFramework é possível criar índices no banco de dados, especificando isto diretamente nas classes no código fonte. Esta criação dos índices é feira através do atributo Index diretamente sobre o campo da classe. Mas atenção: isto só é possível utilizando o recurso Migrations do EntityFramework.

Para demonstrar este recurso, vamos criar um projeto do tipo Console no Visual Studio e vamos adicionar o EntityFramework CodeFirst usando o pacote NuGet.

Criando o Projeto Console:

 SNAGHTML4fb2cd3

Adicionando o EntityFramework CodeFirst com o NuGet Package (Tools/Nuget Package Manager/Package Manager Console) e iremos adicionar o pacote com o comando abaixo:

PM> Install-Package EntityFramework

Vamos agora adicionar a nossa classe de Contexto:

   1: public class Contexto : DbContext

   2: {

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

   4: }


E na sequência a classe Cliente:

   1: public class Cliente

   2:     {

   3:         public int ID { get; set; }

   4:         public string Nome { get; set; }

   5:         public string Cidade { get; set; }

   6:         public string UF { get; set; }

   7:     }

 

Criando os índices:

Vamos imaginar que você precise criar um índice para o campo Nome classe Cliente. Iremos usar então o atributo Index e também o MaxLength para determinarmos o tamanho máximo do campo. O atributo Index está no NameSpace: System.ComponentModel.DataAnnotations.Schema

   1: public class Cliente

   2:     {

   3:         public int ID { get; set; }

   4:         [Index]

   4:         [MaxLength(100)]

   5:         public string Nome { get; set; }

   6:         public string Cidade { get; set; }

   7:         public string UF { get; set; }

   8:     }

 

Veja que é bem simples, basta adicionar o atributo Index em cima do campo que você quer o índice! Você pode também dar um nome para o índice e, caso seja um índice composto (mais de um campo) indicar qual a posição do campo no índice.

Para nomear o índice, basta informar, por exemplo: [Index(“MeuIndice”)] e se você quiser informar também a posição, basta adicionar logo após o nome. Você ainda pode indicar se o índice é Clustered ou Unique. O nome do índice não é obrigatório.

Lembrando o que falei no início do post, a criação do índice é feita usando o Migrations e agora vamos adicioná-lo ao nosso projeto utilizando a Package Manager Console novamente:

PM> Enable-Migrations

Agora já podemos começar a enviar os comandos do migrations para criar ou atualizar nosso banco de dados. Começamos então adicionando um checkpoint para o migrations:

PM> Add-Migration CriacaoBanco

Se você verificar o código gerado pelo Migrations, verá a criação do índice (neste exemplo eu dei o nome “MeuIndice” para o índice):

   1: public partial class CriacaoBanco : DbMigration

   2:     {

   3:         public override void Up()

   4:         {

   5:             CreateTable(

   6:                 "dbo.Clientes",

   7:                 c => new

   8:                     {

   9:                         ID = c.Int(nullable: false, identity: true),

  10:                         Nome = c.String(maxLength: 100),

  11:                         Cidade = c.String(),

  12:                         UF = c.String(),

  13:                     })

  14:                 .PrimaryKey(t => t.ID)

  15:                 .Index(t => t.Nome, name: "MeuIndice");

  16:             

  17:         }

  18:         

  19:         public override void Down()

  20:         {

  21:             DropIndex("dbo.Clientes", "MeuIndice");

  22:             DropTable("dbo.Clientes");

  23:         }

  24:     }

 

Veja o comando .Index(t => t.nome, name: “Meu_Indice”). Ele é quem irá criar o índice quando aplicarmos a alteração no banco de dados, mas antes de criarmos o banco de dados não podemos esquecer da string de conexão de deve estar no app.config ou web.config (no caso de aplicações web). Vamos adicionar a linha com a conexão:

   1:  

   2:   <connectionStrings>

   3:     <add name="Contexto" 

   4:          connectionString="data source=(local); initial catalog=EFIndice; user id=teste; password=teste" 

   5:          providerName="System.Data.SqlClient"/>

   6:   </connectionStrings>

   7:   

   8:   

 

Agora vamos criar o banco de dados com o índice executando o comando Update-Database:

PM> Update-DataBase

Pronto, nosso banco foi criado com o índice que determinamos. Vejam a tela do Management Studio:

image

Ao invés de criar o banco diretamente, você também pode adicionar o parametro –Script ao Update-Database para assim, gerar o script do seu bando de dados.

Agora você já pode adicionar a criação de índices ao seus projetos do EntityFramework e assim, melhorar a performance de suas consultas.

Abraços e até a próxima,

Carlos dos Santos.