ASP.NET SignalR – Introdução e Utilização

O ASP.NET SignalR é uma biblioteca open-source que facilita a implementação de comunicação em tempo real, atualizações/notificações de forma assíncrona em uma aplicação.

Foi desenvolvido por dois funcionários da Microsoft – Damian Edwards e David Fowler, todo o código fonte do projeto está disponível no GitHub

Há um certo tempo foi incorporado pela plataforma ASP.Net, sendo:

ASP.Net SignalR

Funciona através de uma biblioteca Server Side (ASP.Net) e uma Client Side (Javascript), é suportado em aplicações do tipo Silverlight, Windows Phone 7 e 8 e WinRT. Veja a lista completa de plataformas suportadas aqui.

Quem já precisou desenvolver uma aplicação real-time conhece as dificuldades de manter um certo volume de conexões do servidor, manipular a maneira que o servidor trata as requisições, garantir que o client esteja exibindo as informações no tempo certo e enfim.

Existem alguns meios de implementar uma comunicação em tempo real (Long Polling, WebSockets, Node.js) todas essas técnicas/tecnologias possuem sua complexidade ou limitação técnica, o SignalR propõe a facilitar a implementação da comunicação real-time em sua aplicação.

O que é uma aplicação real-time?

É uma aplicação onde a informação chega em tempo real, imagine um chat ou um ticker de cotação da bolsa de valores, essas informações estão sendo distribuídas em tempo real para todos os clientes consumidores da aplicação.
Para se desenvolver uma aplicação em tempo real é necessário que o servidor seja capaz de sensibilizar todos os clientes conectados assim que uma informação chegar.

Como funciona?

O ASP.Net SignalR é uma abstração de uma conexão, ele trabalha por baixo dos panos definindo o melhor tipo de transporte em dois níveis diferentes de abstração o que ocasiona uma impressão de uma conexão persistente.

ASP.Net SignalR

Transportes

Um dos grandes pontos do ASP.Net SignalR é sua capacidade de gerenciar a escolha do tipo de transporte a ser utilizado.

Como mostra a figura existem quatro tipos de transportes disponíveis:

  1. WebSockets
  2. Long Polling
  3. Server Sent Events
  4. Forever Frame

Lendo a documentação do ASP.Net SignalR iremos entender que fica a cargo dele encontrar o transporte mais eficaz entre um server/client, dando sempre preferência por WebSockets quando disponível e caso não esteja disponível parte para Long Polling e os demais em sequência.

WebSocket é uma tecnologia que permite a comunicação bidirecional por canais full-dulplex sobre um único soquete Transmission Control Protocol (TCP). Ela foi projetada para ser executada em navegadores e servidores web que suportem o HTML5, mas pode ser usado por qualquer cliente ou servidor de aplicativos. A API WebSocket está sendo padronizada pelo W3C e o protocolo WebSocket está sendo padronizado pelo IETF.

Sendo assim apesar de termos tipos de transportes variantes o código fonte é sempre o mesmo, a responsabilidade de escolher o tipo de transporte fica por conta do SignalR, porém existe disponível uma maneira de definir o uso de um transporte específico.

Comunicação com PersistentConnection e Hubs

O ASP.Net SignalR oferece dois níveis de abstração de comunicação entre clientes e servidores, sendo o Hubs de alto nível e PersistentConnection de baixo nível.

PersistentConnection representa um endpoint de comunicação com um único destinatário, agrupamentos ou mensagens de broadcast.
É necessário a configuração de uma rota customizada dentro do arquivo Global.asax.

A API de conexão (representada em código .Net pela classe PersistentConnection) dá ao desenvolvedor acesso direto a comunicação de baixo nível que o SignalR expõe, similar a forma de trabalhar com Sockets. O modelo de comunicação PersistentConnection será familiar para os desenvolvedores que usam API’s baseadas em conexão como o Windows Communcation Foundation – WCF.

Hubs é um pipeline de mais alto nível construído sobre a API PersistentConnection  e que permite que o cliente e servidor chamem métodos entre si diretamente.
O SignalR lida com o envio através dos limites da máquina, permitindo que o cliente chame os métodos no servidor tão facilmente como métodos locais e vice-versa.
Se o seu aplicativo usa diferentes tipos de mensagens é recomendável que você use a classe Hub, de modo que você possa chamar métodos no client em vez de enviar uma mensagem explícita que precisa ser recebida, interpretada e posta em prática. Usando o modelo de comunicação Hubs será familiar para os desenvolvedores que usam API’s de invocação remota como. NET Remoting.

A escolha de um modelo de comunicação

A maioria dos aplicativos deve usar o modelo Hubs.
PersistentConnections podem ser utilizados nas seguintes circunstâncias:

  • O formato da mensagem enviada necessita de ser controlado.
  • O desenvolvedor prefere trabalhar com um modelo de envio de mensagens ao invés de um modelo de invocação remota.
  • Um aplicativo existente que usa um modelo de mensagem está sendo portado para usar SignalR.

Como começar?

É necessário o Visual Studio 2010 SP1 ou o Visual Studio 2012

  • Inicie um projeto ASP.Net MVC
  • Instale o ASP.Net SignalR através do Nuget:
Install-Package Microsoft.AspNet.SignalR
  • Adicione um Controller vazio
public class ChatController : Controller
{
    public ActionResult Index()
    {
        return View();
    }
}
  • Crie uma View
@{
    ViewBag.Title = "Chat Básico";
}
<label for="apelido" >Seu Apelido:</label><input type="text" name="apelido" id="apelido" /><br />
<label for="mensagem" >Mensagem:</label><input type="text" name="mensagem" id="mensagem" maxlength="100" />
<div id="chatWindow" style="width: 100%; height: 300px; overflow: scroll; border: 1px solid grey"></div>

<!-- Referenciando os scripts adicionados ao Bundle -->
@Scripts.Render("~/bundles/jquery")
@Scripts.Render("~/bundles/SignalR")

<!-- Referencia para o script de Hub criado automaticamente -->
<script src="/signalr/hubs" type="text/javascript"></script>

<script type="text/javascript">
    $(function () {
        // Declarando um proxy de referencia ao Hub
        var chatHub = $.connection.chat;

        // Criando a função que será chamada pelo Hub para distribuir as mensagens aos clientes.
        // Por convenção as chamadas aos métodos são feitas em "camelCase"
        chatHub.transmitirMensagem = function (apelido, msg) {

            // Area do chat
            var chatWin = $("#chatWindow");

            // Publicando a mensagem no chat
            chatWin.html(chatWin.html() + "<b>" + apelido + "</b>: " + msg + "<br />");
        };

        // Iniciando a conexão com o Hub
        $.connection.hub.start();

        // Validando o botão enter
        $(document).keypress(function (e) {
            if (e.which == 13) {

                // Chamando o método de transmissão de mensagem no Hub
                chatHub.enviarMensagem($("#apelido").val(), $("#mensagem").val());

                // Limpando o texto da mensagem.
                $("#mensagem").val("");
            }
        });
    });
</script>
  • Crie um Hub
public class Chat : Hub
{
    public void EnviarMensagem(string apelido, string mensagem)
    {
        Clients.TransmitirMensagem(apelido, mensagem);
    }
 }

Este exemplo está disponível para download aqui.

Ao executar o projeto abra uma segunda instância de um browser (experimente browsers diferentes) e teste a conversação do chat.

ASP.Net SignalR

É incrivelmente fácil, não é mesmo?
O client chama métodos no Hub (server) como se fossem métodos locais e os métodos no server chamam métodos no client como se fossem métodos no servidor.

Quero conhecer e aprender mais!

Leia estes dois sites:

Assista este ótimo vídeo que foi gravado no TechEd 2012 por um dos desenvolvedores do  ASP.Net SignalR.

Leia este Free eBook do MVP JM Aguilar, eu já li e recomendo (inglês)

Mais exemplos para baixar:

Baixou o código fonte e teve alguma dúvida? Colocou a mão na massa e quer conhecer algum detalhe mais profundamente? Os desenvolvedores do ASP.Net SignalR respondem, eles ficam disponíveis neste chat, eu dei meu alô para eles e fui respondido:

ASP.Net SignalR

O exemplo do chat é o mais simples e clássico para usar na comunicação em tempo real, porém as possibilidades de utilização são inúmeras, adicione o ASP.Net SignalR em seu conhecimento técnico e faça proveito.

Este foi um post introdutório, falarei muito mais deste assunto em outros artigos, estou preparando uma aplicação especial para disponibilizar na comunidade utilizando ASP.Net SignalR e também tem minha palestra no Visual Studio Summit 2013 (será gravada e disponibilizada aqui).

Dê seu feedback e tire suas dúvidas nos comentários abaixo.
Gostou deste artigo? Compartilhe 😉

Referências

ASP.Net MVC – Validando e-mail com DataAnnotations

Olá pessoal,

Recentemente passei por um problema e gostaria de compartilhar a solução neste artigo.

Irei utilizar um projeto padrão do tipo MVC 4 – Internet Application do Visual Studio, este projeto já vem por padrão com o registro de usuários e controle do login com FormsAuthentication implementado.

Neste projeto temos uma área de registro de novos usuários e irei customizar para que o nome de usuário seja um e-mail, para isso é necessário que haja a validação no momento da criação do novo usuário.

Aqui está a Model AccountModels.cs original:

using System.ComponentModel.DataAnnotations;

public class RegisterModel
{
    [Required]
    [Display(Name = "User name")]
    public string UserName { get; set; }

    [Required]
    [StringLength(100, ErrorMessage = "The {0} must be at least {2} characters long.", MinimumLength = 6)]
    [DataType(DataType.Password)]
    [Display(Name = "Password")]
    public string Password { get; set; }

    [DataType(DataType.Password)]
    [Display(Name = "Confirm password")]
    [Compare("Password", ErrorMessage = "The password and confirmation password do not match.")]
    public string ConfirmPassword { get; set; }
}

Para que haja a validação é necessário decorar a propriedade do campo usuário (UserName), caso você pesquise na internet irá encontrar várias referências orientando a fazer a validação desta forma:

    [Required]
    [Display(Name = "User name")]
    [DataType(DataType.EmailAddress, ErrorMessage = "E-mail em formato inválido.")]
    public string UserName { get; set; }

No momento do registro não irá funcionar a validação do formato de e-mail, ou seja, um usuário com nome “Teste” será registrado sem ser barrado pela validação.

Explicação:
Aparentemente seria essa a proposta do atributo DataType, mas não, o atributo DataType é usado apenas para formatação e não validação.

No .Net Framework 4.5 há um novo atributo System.ComponentModel.DataAnnotations.EmailAddressAttribute, que é um tipo de atributo utilizado justamente para validação, sua aplicação inclusive é mais fácil:

    [Required]
    [Display(Name = "User name")]
    [EmailAddress(ErrorMessage = "E-mail em formato inválido.")]
    public string UserName { get; set; }

Utilizei o parâmetro ErrorMessage para definir a frase de erro a ser exibida, em outros casos basta usar o parâmetro [EmailAddress] que a validação será feita:

Lembrando que ainda existe a possibilidade de fazer a validação utilizando expressões regulares:

    [Required]
    [Display(Name = "User name")]
    [RegularExpression(@"b[A-Z0-9._%-]+@[A-Z0-9.-]+.[A-Z]{2,4}b", ErrorMessage = "E-mail em formato inválido.")]
    public string UserName { get; set; }

É isso pessoal, uma dica simples mas que pode salvar algum tempo do seu trabalho 🙂

Até a próxima.

C# – Para Iniciantes – Parte 7 – Generics C#

Olá Pessoal, Vamos falar sobre Generics C#.

Atendendo a um pedido de um leitor que segue a série C# para iniciantes, faremos aqui uma abordagem simples para entender sobre o tal Generics 🙂

Os Generics (Genéricos) foram incluídos no .Net Framework na versão 2.0 (isso foi em 2005), portanto é novidade apenas para quem está começando agora, hoje em dia os Generics são fundamentais, então sugiro que entendam bem o conceito.

Os Generics foram criados para eliminar o “casting“, facilitar a criação de classes e métodos e diminuir a quantidade de boxing (entenda o que é boxing).
Genérics representa uma coleção (lista, array, como preferir…) de objetos fortemente tipados. Uma collection de generics fornece métodos para pesquisar, ordenar e manipular através de um índice.

Fortemente tipados, pois é uma coleção de um tipo, (int, string, etc… ou T), sendo “T” nesse caso um tipo definido pelo próprio programador.

Para utilizar o generics é necessário fazer uso do namespace System.Collections.Generic

Exemplo, uma lista de int:

    List<int> listaInteiros = new List<int>();

Certo?
Agora dada a classe:

    public class Pessoa
    {
        public string Nome { get; set; }
        public int Idade { get; set; }
        public string Sexo { get; set; }

        // Construtor para facilitar a criação de uma nova pessoa.
        public Pessoa(string nome, int idade, string sexo)
        {
            Nome = nome;
            Idade = idade;
            Sexo = sexo;
        }

        // Construtor vazio para permitir uma instância vazia da classe Pessoa
        public Pessoa()
        {
        }
    }

A classe Pessoa foi escrita pelo programador, não é um tipo do .Net, nesse caso para montar uma lista de N pessoas, seria assim:

    // Criando uma lista do tipo pessoa.
    List<Pessoa> listaPessoas = new List<Pessoa>();

    // Adicionando novas pessoas na lista.
    listaPessoas.Add(new Pessoa("Eduardo",30,"M"));

    listaPessoas.Add(new Pessoa("Enzo", 7, "M"));

    listaPessoas.Add(new Pessoa("Juliana", 21, "F"));

    // Obtendo o total de pessoas na lista
    int totalPessoas = listaPessoas.Count(); // totalPessoas = 3 pessoas

Fazendo a mesma coisa, só que de forma diferente:

    // Criando uma lista do tipo pessoa.
    List<Pessoa> listaPessoas = new List<Pessoa>();

    // Criando um objeto pessoa vazio.
    Pessoa pessoaTeste = new Pessoa();

    // Preenchendo um objeto pessoa.
    pessoaTeste.Nome = "Eduardo";
    pessoaTeste.Idade = 30;
    pessoaTeste.Sexo = "M";

    // Adicionando a pessoa na lista.
    listaPessoas.Add(pessoaTeste);

Escrevendo um método que recebe uma lista genérica de Pessoas e trabalha os dados da lista:

    public static void MetodoAumentaIdade(List<Pessoa> listaPessoas)
    {
        foreach(Pessoa pessoa in listaPessoas)
        {
            // Aumenta 1 ano de idade.
            pessoa.Idade++;
        }
    }

Estes exemplos mostraram como criar uma lista genérica.
Agora que sabemos como criar e popular uma lista genérica, vou dar alguns exemplos de como trabalhar dados em listas:

    // Criando uma nova lista e ordenando por nome decrescente
    List<Pessoa> novaListaPessoas;
    novaListaPessoas = listaPessoas.OrderByDescending(x => x.Nome).ToList();

    // Varrendo e exibindo nomes ordenados
    novaListaPessoas.ForEach(n => Console.Write(n.Nome));

    // Criando uma nova lista baseada em pessoas selecionadas por um critério
    List<Pessoa> listaPessoaSelecionada =
                (from Pessoa p in novaListaPessoas where p.Nome == "Eduardo"
                select p).ToList();

    // Somando todas as idades das pessoas da lista
    int totalIdades = novaListaPessoas.Sum(x => x.Idade);

Notem que estou fazendo bastante uso de Expressões Lambdas.
Existem várias abordagens possíveis para trabalhar uma lista genérica, nesta documentação da Microsoft é possível estudar todas e aprender quando e de que forma podemos facilitar nosso trabalho utilizando Generics.

É isto pessoal, utilizem os comentários para participar ou tirar dúvidas.

Até mais 😉

O que é POCO?

Olá pessoal, O que é POCO? O que seria uma classe POCO?

Hoje em dia utilizar um ORM como Entity Framework ou NHibernate é bem comum, aplicar conceitos do DDD também vem sido bem abordados e discutidos e em todas essas abordagens acaba surgindo o uso de POCO. Afinal o que é POCO?

Tentar decifrar esse nome vai ser bem difícil, POCO significa Plain OLD CLR Object, tentando traduzir isso eu gosto de chamar POCO de “Bom e velho objeto do CLR”.
POCO é um acrônimo de POJO Plain OLD Java Object, criado por Martin Fowler (um expert em OOP) como ele vem de Java acabou dando esse nome, então os especialistas em .Net fizeram uma pequena mudança para trazer esse conceito ao nosso mundo e surgiu o POCO (mas é o mesmo conceito, não muda nada).

Legal, mas ainda não entendi o que é POCO?

É fácil de entender, POCO é uma classe que segue o ideal do OOP, pois tem estado e comportamento, porém não depende e não conhece nenhum recurso externo além do Framework .Net.

Uma classe POCO é utilizada como classe de domínio (negócio) da sua aplicação, o que chamo de Modelo de Domínio. Um Modelo de Domínio é formado pelas classes que compõem a estrutura de negócio do mundo real.

Nós não desenvolvemos sistemas apenas baseados no Framework .Net, quase sempre necessitamos de uma ferramenta externa, por exemplo um ORM, que por sua vez impõe o uso de referências como classes, interfaces, decorações nos métodos etc…

Construir uma classe POCO é escrever uma classe que contenha atributos, construtores e métodos mas que não dependam de nada mais do que o próprio .Net Framework forneça.

Quem já utilizou o Entity Framework na forma Database First já viu como que fica a bagunça de uma classe? Acabamos gerando um único arquivo EDMX com muitas dependências, herdando de um objeto ObjectContext. Geralmente esse código é bastante poluído e dificíl de estender.

    [EdmEntityTypeAttribute(NamespaceName="SistemaOS.Model", Name="Pessoas")]
    [Serializable()]
    [DataContractAttribute(IsReference=true)]
    public partial class Pessoas : EntityObject
    {
        [EdmScalarPropertyAttribute(EntityKeyProperty=true, IsNullable=false)]
        [DataMemberAttribute()]
        public global::System.Int32 id_pessoa
        {
            get
            {
                return _id_pessoa;
            }
            set
            {
                if (_id_pessoa != value)
                {
                    Onid_pessoaChanging(value);
                    ReportPropertyChanging("id_pessoa");
                    _id_pessoa = StructuralObject.SetValidValue(value, "id_pessoa");
                    ReportPropertyChanged("id_pessoa");
                    Onid_pessoaChanged();
                }
            }
        }
    }

Ou seja, estamos amarrados ao Entity Framework se deixarmos ele criar nossas classes de entidades.

Um exemplo simples de classe POCO:

    public class Pessoa
    {
        public string Nome { get; set; }
        public string Sobrenome { get; set; }
        public int Cpf { get; set; }

        public string NomeCompleto()
        {
            return Nome + " " + Sobrenome;
        }
    }

Veja que neste exemplo não dependemos de nada, é apenas uma classe, tratando de DDD o nosso domínio não pode depender de tecnologia, afinal a minha camada de domínio pode ser adaptada a um outro sistema que não utilizará o Entity Framework e tudo bem! Afinal minha classe POCO não depende disso.

Acredito que a vantagem de usar POCO é exatamente essa, podemos modelar nossas classes de domínio e portá-las para onde quiser, sem a dependência de nenhuma ferramenta externa.

Por isso recomendo que utilizem ferramentas que dê suporte a POCO, e isso não é difícil, por exemplo Entity Framework, NHibernate, WCF permitem trabalhar com POCO.

No Entity Framework, por exemplo, podemos trabalhar da forma Code First, ou seja, escrevemos primeiro classes POCO e no final a modelagem da base de dados é criada conforme a modelagem do nosso domínio.

Então uma classe POCO é uma classe anêmica?
– Não! Uma classe anêmica pode até ser uma classe POCO, mas nada diz que uma classe POCO deve ser anêmica, afinal ela pode possuir atributos e métodos.
Uma classe anêmica não possui métodos, e por alguns é considerada um anti-pattern, pois fere o conceito de orientação a objeto, mas isso é assunto para um outro artigo. 🙂

Uma classe POCO é como se fosse uma DTO então?
– Não! Uma DTO “Data Transfer Object” é outra coisa, pense em DTO como uma “sacola de dados”, ou seja, em um objeto DTO podemos ter dados das classes Pessoa, Endereço, Empresa.
DTO é um outro pattern desenhado justamente para reduzir o número de chamadas e a quantidade de dados necessários para trafegar entre camadas de sistemas, por exemplo, entre uma aplicação web e um serviço.
Uma classe POCO é sua classe de domínio e um DTO é o objeto para transitar dados apenas, podem possuir dados de mais de uma entidade e não possuem métodos, portanto não é POCO.

Se minha classe herda de uma classe base então não tenho uma classe POCO?
– Depende, desde que a classe base não tenha nenhuma dependência com outras camadas da aplicação e ferramentas externas, ainda é uma classe POCO.

Referências:

Espero que tenham aproveitado, se você gostou compartilhe esse artigo, se tiver dúvidas ou quiser contribuir com algo faça um comentário.

Até a próxima!

C# – Para Iniciantes – Parte 6 – Syntactic Sugar

Olá pessoal, já ouviram falar de Syntactic Sugar ?

Syntactic Sugar, também usado como Syntax Sugar, é um termo utilizado para quando uma linguagem de programação oferece uma forma mais fácil de ser lida e escrita.

Usar syntactic sugar refere-se a escrever um código de forma alternativa ao modo tradicional, com a finalidade de escrever menos código e torná-lo mais expressivo.

O que acontece é que nem sempre conhecemos todos os modos de se escrever em uma linguagem e podemos nos deparar com um código “estranho”.

Vou abordar dois exemplos de Syntactic Sugar em C#.

Primeiro exemplo:

O que está acontecendo aqui?

    int? numero = null;
    numero = 12;

Colocar um “?” no final de um tipo significa dizer que ele é um “Nullable Type”.

Nullable Type são instâncias de System.Nullable<T> struct. Ou seja, um int por exemplo pode receber valores entre -2147483648 a 2147483647 mas nunca um “null”, um int? além de receber valores entre -2147483648 a 2147483647 também pode receber “null”.

Em algum determinado momento sua variável do tipo int poderia receber um dado nulo “null”, por exemplo, ao receber valores de uma tabela de um banco de dados onde a coluna estivesse vazia “null”.

Se você fizer isso terá um erro:

    int numero = null;
    numero = 12;

    //Cannot convert null to 'int' because it is a non-nullable value type

Usar “?” para descrever um “Nullable Type” é uma forma reduzida, pois originalmente é feito assim:

    System.Nullable<int> numero = null;
    numero = 12;

Legal, agora já aprendemos o que é um “Nullable Type” e como declarar um tipo desse de forma reduzida.

Segundo exemplo:

O que está acontecendo aqui?

    string NomePrincipal = null;
    string NomeAlternativo = "Eduardo";

    string Nome = NomePrincipal ?? NomeAlternativo;

Afinal o que são estes dois pontos de interrogação? (??)

O código acima é para testar se a variável NomePrincipal não é nula (null) e se caso for, então atribuir a variável NomeAlternativo para a variável Nome.

Este é mais um exemplo de syntactic sugar no C#, menos código escrito e mais simples de entender. O que está acontecendo no código acima poderia ser escrito assim:

    string NomePrincipal = null;
    string NomeAlternativo = "Eduardo";

    string Nome = NomePrincipal != null ? NomePrincipal : NomeAlternativo;

Agora deu para entender?
No exemplo acima utilizamos um operador ternário. O operador ternário já é uma forma de escrever menos código, porém não é syntactic sugar.

Note que o primeiro exemplo de código exibido não é um operador ternário, apenas foi escrito de uma forma “abreviada” (isto é syntactic sugar).

    string Nome = NomePrincipal ?? NomeAlternativo;

Note também que usar o “??” é valido apenas para testar se um valor é “null”, não pode ser aplicado para outros tipos de validações.

Veja como ficaria se estivéssemos escrevendo da forma mais básica:

    string NomePrincipal = null;
    string NomeAlternativo = "Eduardo";

    string Nome;

    if (NomePrincipal != null)
    {
        Nome = NomePrincipal;
    }
    else
    {
        Nome = NomeAlternativo;
    }

Muito mais código, maior o tempo para ler e compreender.

Vamos aumentar as possibilidades? Veja só:

    string NomePrincipal = null;
    string NomeAlternativo = null;
    string NomeQualquer = null;

    string Nome = NomePrincipal ?? NomeAlternativo ?? NomeQualquer ?? "Sem Nome";

    // Resultado: Nome = "Sem Nome"

Podemos usar quantos “??” quisermos em nosso código, experimente escrever isso da forma mais básica, seria chato né? 🙂

Usar os benefícios do syntactic sugar é legal, facilita nosso entendimento ao ler e agiliza na hora de escrever reduzindo o tempo de codificação.

Referências:

Se você gostou compartilhe esse artigo, se tiver dúvidas ou quiser contribuir com algo faça um comentário.

Até a próxima.

Exame para Certificação Microsoft Grátis.

Olá pessoal, boas novas – Exame para Certificação Microsoft Grátis.

A Microsoft liberou alguns PromoCodes para a realização de exames de certificação, tratam-se dos Beta Exam Process, ou seja, os novo exames de certificação que em breve serão lançados.

A categoria é Visual Studio 2012, segue abaixo a lista dos exames:

Exame
PromoCode
Expiração
71-481 – Essentials of Developing Windows Metro style Apps using HTML5 and JavaScript
FYT481
20/Agosto
71-482 – Advanced Metro style App Development using HTML5 and JavaScript
GXZ482
17/Agosto
71-483 – Programming in C#
JOK483
21/Agosto
71-484 – Essentials of Developing Windows Metro style Apps using C#
FTT484
05/Setembro
71-485 – Advanced Metro style App Development using C#
FTT485
07/Setembro
71-486 – Developing ASP.NET 4.5 MVC Web Applications
WWW486
17/Agosto
71-487 – Developing Windows Azure and Web Services
WWW487
04/Setembro

Os Exames Beta são um pouco diferentes, pois o resultado não sai na hora como um exame de certificação tradicional, normalmente a Microsoft divulga seu resultado em no máximo 30 dias.

Se passar no exame, ou seja, atingir 700 pontos ou mais, não é necessário realizar novamente o exame tradicional a certificação é dada pelos Exames Beta também.

Mais informações sobre Exames Beta em:
http://www.microsoft.com/learning/pt/br/certification/exam-dev.aspx#tab2 

É uma ótima oportunidade de colocar os novos conhecimentos em dia, dá tempo de estudar e fazer as provas.

Para agendar sua prova vá até o site http://www.register.prometric.com/ e escolha o centro de teste mais próximo a você. No momento do pagamento não precisa preencher os dados do cartão de crédito, basta clicar no botão Voucher / PromoCode e informar o código da prova escolhida.

A prova tem que ser agendada antes da data de expiração e a quantidade de exames é limitada, então corra e agende já o seu 🙂

Conselho:

  • Não marque a prova apenas para testar seu conhecimento. Estude! Como os exames são limitados dê a oportunidade de quem estudou realizar a prova.

Se você quer saber em primeira mão quando estas provas são liberadas acesse regularmente o site http://borntolearn.mslearn.net/

Boa sorte pessoal e espero que obtenham as novas certificações.

C# – Para Iniciantes – Parte 5 – Properties

Olá pessoal, Falaremos hoje sobre C# Properties.

Uma propriedade (Property) é um membro de uma classe que fornece um mecanismo flexível para ler, gravar ou calcular o valor de um dado em particular.
As propriedades permitem que uma classe exponha de uma maneira pública a obtenção e definição destes valores.

Por ex. Temos a classe Carro, uma propriedade de carro é sua cor, ou seja, Cor é um atributo (propriedade) de Carro.

Uma propriedade pode obter um valor de uma classe e também pode defini-lo, sendo assim temos propriedades Read/Write ou apenas Readonly. 
Um exemplo:


// Essa é sua variável interna (privada)
private string _cor;

// Essa é sua propriedade pública.
public string Cor
{
  get { return _cor; }
  set { _cor = value; }
}

Notaram que ao ler o valor (get) a propriedade retorna o valor da variável interna e ao gravar (set) a variável interna é alterada para um novo valor.


// Fazendo Get
string CorCarro = Carro.Cor;

// Fazendo Set
Carro.Cor = "Preto";

E se a propriedade for Readonly?


// Essa é sua variável interna (privada)
private string _cor;

// Essa é sua propriedade pública.
public string Cor
{
  get { return _cor; }
}

Viram? Internamente não implementa o recurso do Set, ou seja, apenas podemos ler o estado, sem alterá-lo.

Agora que já está entendido, mais novidade:
Desde o C# 3.0 (Já estamos no 5.0) foi incluído o recurso de Automatic Properties (Propriedades Automáticas), ou seja, não necessitamos mais declarar o Get nem o Set, aquela variável interna de controle também não (é gerenciado automático).

Então como fica?


// Essa é sua propriedade Read/Write.
public string Cor { get; set; }

// Essa é sua propriedade Readonly.
public string Cor { get; }

Menos código, mais agilidade 🙂

Tem mais uma novidade, através do Visual Studio (2008 ou superior) podemos escrever rapidamente muitas propriedades utilizando o atalho “prop”

É muito simples, Apenas digite prop e dê Tab duas vezes.
Abaixo um vídeo que produzi para ilustrar:

É isso ai pessoal, esse artigo abordou de forma simples sobre as properties, na abordagem sobre classes falaremos mais 🙂

No caso de dúvidas utilizem os comentários.

C# – Para Iniciantes – Parte 4 – Operadores Ternários

Olá Pessoal, O que são Operadores Ternários e como utilizá-los?

O operador ternário é bem simples, serve para validar uma condição (if / else) dada a condição retorna um true ou false.

Mas por que chama-se operador ternário?
Vamos lá:

Temos três tipos de operadores

  • Relacionais (==, !=, >,  <,  >=,  <=)
  • Lógicos (&&, ||, !)
  • Ternários.

Os operadores ternários são formados por três operandos (por isso chama-se ternário), e são separados pelos sinais ? e conforme estrutura abaixo:

condicao ? valor_se_verdadeiro : valor_se_falso

A condição é testada, caso verdadeira é retornado o valor_se_verdadeiro, caso a condição seja falsa é retornado o valor_se_falso.

    int valor1 = 10;
    int valor2 = 15;

    bool resultado = valor1 == valor2 ? true : false;

    // O Resultado foi: False.

Se não existisse o operador ternário como seria escrita essa validação?

    int valor1 = 10;
    int valor2 = 15;

    bool resultado;

    if (valor1 == valor2)
    {
        resultado = true;
    }
    else
    {
        resultado = false;
    }

    // O Resultado foi: False.

É uma economia de linhas de código e tanto não acham? 😉

Ahhh, um amigo meu de Visual Basic disse que em VB se faz com “IIf”.
Calma lá! muito cuidado com o IIf no VB, apesar dele fazer o mesmo trabalho ele não é um operador ternário, é uma função. O VB não possui esse operador.

Cuidado por que? Como trata-se de uma função, independente da sua condição os dois valores (true ou false) serão testados, ou seja, se for passado um tipo inválido teremos um erro em tempo de execução. Evitem o IIf do VB.

Como o papo aqui é C#, espero que tenham gostado, como puderam ver é muito fácil usar o operador ternário, acontece no começo de esquecer a sintaxe, nesse caso voltem aqui para relembrar 🙂

Até a próxima.

C# – Para Iniciantes – Parte 3 – Expressão Lambda

Olá Pessoal, Como utilizar uma Expressão Lambda?

De início elas podem assustar um pouco quem não as conhecem, mas basta entender o conceito para transformá-las em grandes aliadas no desenvolvimento de código bonito 😉

As expressões lambda foram introduzidas no .Net para dar suporte as consultas LINQ.

“LINQ – Language Integrated Query, foi introduzido no framework 3.5 para realizar consultas diretas a base de dados ou documentos XML, coleções de objetos e qualquer outra estrutura de dados. Sua sintaxe é parecida com a linguagem SQL”

As expressões lambda se comportam como um tipo de delegate (falaremos dele em breve). Entendemos que a expressão lambda é uma espécie de função, porém sem nome, elas realizam cálculos, filtros, e retornam um valor (ou uma coleção de valores).

Para criar uma expressão lambda é necessário fazer uso do operador lambda “=>” que podemos entender como “Vai para”.

Uma expressão lambda sempre consiste de duas partes (esquerda e direita) separadas pelo  “=>”. A parte à esquerda do “=>” contém uma lista de argumentos (de tipo não necessariamente definido, pois os tipos podem ser automáticamente indicados pelo compilador). O lado direito contém as instruções.

Esta é uma expressão lambda (linha 2):

    int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
    int oddNumbers = numbers.Count(n => n % 2 == 1);

O que está sendo feito?
Note que foi criado um Array de inteiros e atribuído a ele alguns elementos numéricos.
A expressão lambda está retornando os elementos do Array que são impares.

Como? Vamos ler da seguinte forma:
Está sendo retornado um array com apenas os números que satisfazerem a expressão   “n % 2 == 1”, nesse caso foram 5 dos 10 elementos numéricos.

Para quem não sabe x % y significa x módulo y, ou seja, o resto da divisão de x por y, qualquer número impar dividido por 2 resta 1, é assim que validamos números impares.

No final o método count totalizou os impares do array que foi retornado da expressão lamba.

Achou difícil? Vamos tentar esta:

    // O var é uma forma de declarar uma variável que irá assumir o tipo do dado que lhe for atribuido.
    var SelecoesMundiais = new ArrayList(new string[] {"USA", "Africa", "Mexico", "Brasil" });

    // Primeira forma de fazer um filtro usando WHERE
    var MelhorSelecao =
            from string p in SelecoesMundiais
            where p == "Brasil"
            select p;

    // Segunda forma de fazer um filtro usando WHERE
    var MelhorSelecao2 = SelecoesMundiais.Cast<string>().Where(p => p == "Brasil");

    // Aqui estamos fazendo a mesma coisa sem utilizar expressão lambda
    List<string> MelhorSelecao3 = new List<string>();

    foreach (var Selecao in SelecoesMundiais)
    {
        if (Selecao == "Brasil")
        {
            MelhorSelecao3.Add(Selecao.ToString());
        }
    }

Precisamos assumir que é mais fácil (e prático) usar expressões lambda 🙂
O último exemplo usando ForEach atende também, mas a quantidade de variáveis e de linhas de código é maior.

Segue mais um exemplo, a ideia desse código é receber uma lista com nomes duplicados, filtrar de forma que não se repitam e converter o nome para UPPER CASE.
Repare que esta sendo chamada uma função externa dentro de uma expressão lambda:

    List<string> ListaNomesDistintos = new List<string>();

    List<string> ListaNomes = new List<string>();

    // Adicionando nomes à lista
    ListaNomes.Add("Eduardo");
    ListaNomes.Add("Enzo");
    ListaNomes.Add("Edna");
    ListaNomes.Add("Juliana");
    ListaNomes.Add("Eduardo");
    ListaNomes.Add("Enzo");

    // Atribuindo para nova lista o retorno dos dados tratados pelo Distinct.
    // O Distinct no LINQ assim como no SQL é responsável por eliminar duplicações de informação.
    ListaNomesDistintos = ListaNomes.Distinct().ToList();

    // Utilizando o ForEach genérico com uma expressão lambda.
    // Basicamente está pegando cada elemento e jogando dentro da função TransformaUpperCase.
    ListaNomesDistintos.ForEach(n => TransformaUpperCase(n));

    // Aqui você pode verificar que os nomes não estão duplicados e foram transformados em UPPERCASE.
    public void TransformaUpperCase(string nome)
    {
        MessageBox.Show(nome.ToUpper());
    }

Com esse exemplo podemos entender o quanto podemos explorar a capacidade das expressões lambda.

Esse post é apenas uma pequena amostra dos recursos, recomendo a vocês que deixem as expressões lambda fazerem parte de seus códigos, as vantagens são diversas.
Pretendo mostrar a utilização de expressão lambda em cenários mais complexos em um próximo post.

Utilizem os comentários para tirar dúvidas 🙂

Referências:

C# – Para Iniciantes – Parte 2 – For – Foreach – While

Olá Pessoal, Como fazer Laço de repetição em C# dos tipos For – Foreach – While?

Se você não sabe ou tinha dúvida, vamos aprender hoje!
Os laços de repetição estão presentes desde as primeiras linguagens e até hoje são extremamente utilizados, basicamente o laço repete um bloco de instruções até que uma condição seja satisfeita.
Vamos lá:

A simulação de código foi feito em um projeto Windows Application.

Laço FOR

    for (int i = 0; i <= 10; i++)
    {
        MessageBox.Show("6 x " + i.ToString() + " = " + (i * 6).ToString());
    }

Leitura:
Para i (inteiro) igual a 0 até i menor igual a 10 acrescente i+1

Simples né?
Podemos fazer um For inverso, onde ele começa de um maior e regride:

    for (int i = 11 - 1; i >= 0; i--)
    {
        MessageBox.Show("6 x " + i.ToString() + " = " + (i * 6).ToString());
    }

Esse tipo de For é útil quando temos um Array de valores onde sabemos o tamanho total dele.

Laço FOR EACH

    foreach (Control item in this.Controls)
    {
        MessageBox.Show(item.Name);
    }

Funciona um pouco diferente, é muito utilizado para varrer tipos de objetos que estão contidos em uma coleção (array de objetos).

Por ex, neste código foi criado um item do tipo Control (controle de formulário tipo button, label). Esse item a cada laço do ForEach recebe um elemento da coleção de todos os controles do formulário.

Laço WHILE

int div = 1000;

while (div != 3)
{
     div = div / 2;
     MessageBox.Show("valor de número é: " + div.ToString());
}

Leitura:
Enquanto (condição esperada não ocorre) faça:
Em determinado momento a variável div sendo dividida por 2 vai ser igual a 3 e satisfará a condição do While, enquanto isso não ocorrer o laço continuará em Loop.
PS – Cuidado com o laço While, cometer um erro que resulta em loop infinito é fácil, nesse caso basta alterar para while (div != 2) e teremos um loop infinito 😉

Laço DO WHILE

    int num = 10;

    do
    {
        num += 5;
        MessageBox.Show("valor de número é: " + num.ToString());
    }
    while (num > 100);

É a mesma ideia do primeiro While, o que muda é que no primeiro a condição é testada no começo do laço e no Do While, é testada no final do laço. Isso é importante dependendo do que precisar fazer.

Essas são as estruturas de laço de repetição que temos no C#, procure memorizar e entender para qual cenário cada um é mais adequado.

Logo mais abordarei Expressões Lambda, que em determinados momentos podem substituir o uso de um ForEach.

Utilizem os comentários para tirar dúvidas.
Até a próxima.