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.

TypeScript – O superset de JavaScript

Olá pessoal, já ouviram / leram algo sobre TypeScript?

Sim, é uma novidade, estou escrevendo apenas 9 dia depois da Microsoft ter anunciado a release do preview do TypeScript.

O TypeScript é um superconjunto “superset” do JavaScript, logo escreve-se TypeScript da mesma forma que se escreve JavaScript, todo código JavaScript também é um código TypeScript.

  • O TypeScript não é um Dart, a Microsoft não está tentando substituir o JavaScript.
  • O TypeScript também não é uma resposta da Microsoft ao CoffeeScript, são propostas diferentes, o CoffeeScript é uma linguagem diferente e possui uma sintaxe própria.

Escrever grandes códigos JavaScript é complicado principalmente quando o assunto é ferramental “tooling”, a proposta do TypeScript é facilitar o desenvolvimento em JavaScript já que o TypeScript traz grandes benefícios, tais como:

  • Classes (chega de prototypes)
  • Módulos (ficou mais fácil exportar código)
  • Tipos definidos (são opcionais)
  • Navegação no código fonte (é possível renomear, encontrar referências e definições)
  • Interfaces
  • Refatoração.

Let’s try!
Veja nesse exemplo básico algumas coisas que nunca viu em JavaScript:

Código TypeScript

// Veja uma classe.
class Greeter {
	greeting: string; // Tipo estático
	constructor (message: string) { // Construtor
		this.greeting = message;
	}
	greet() {
		return "Hello, " + this.greeting;
	}
}

var greeter = new Greeter("world");

var button = document.createElement('button')
button.innerText = "Say Hello"
button.onclick = function() {
	alert(greeter.greet())
}

document.body.appendChild(button)

Código JavaScript gerado:

var Greeter = (function () {
    function Greeter(message) {
        this.greeting = message;
    }
    Greeter.prototype.greet = function () {
        return "Hello, " + this.greeting;
    };
    return Greeter;
})();
var greeter = new Greeter("world");
var button = document.createElement('button');
button.innerText = "Say Hello";
button.onclick = function () {
    alert(greeter.greet());
};
document.body.appendChild(button);

Resumindo

TypeScript ao meu ver é escrever JavaScript de uma forma melhorada e organizada, em conjunto com o Visual Studio ficou mais fácil navegar e refatorar o código, o resultado é maior produtividade.

O código TypeScript é escrito em um arquivo *.TS, porém ao publicar ou debugar uma aplicação com TypeScript o código TS será transformado em JS.
O ganho é produtividade mesmo, pois todo código produzido ao virar JavaScript não carrega com ele as melhorias citadas (classes, tipagem estática, etc), mas não tem problema, afinal o código a ser trabalhado vai ser sempre o TypeScript e esse permanece da forma que escrevermos.

Todo código TypeScript é JavaScript, podemos então copiar um código JS e colar num arquivo TS e funcionará normalmente, sem necessidade de migração, para projetos existentes esse comportamento é muito bacana, uma vez que ao colar o código JS num TS podemos fazer as melhorias que quisermos (ou nenhuma) e a vida segue normalmente.

O TypeScript é open source, no site oficial é possível brincar em um playground que transforma online TypeScript em JavaScript, podemos até rodar o código gerado (ótimo teste inicial).

Utilizando o TypeScript

A maioria dos desenvolvedores Microsoft tem como IDE de desenvolvimento o Visual Studio e para isso é necessário baixar e instalar um plugin.

O TypeScript funciona em outras plataformas em sistemas operacionais diversos, é suportado pelo Vim, Emacs e Sublime

Outro ponto importante, o Source Mapping, ao debugar um código JS ele é diretamente mapeado para o código TS, isso facilita muito a vida, outros geradores de JavaScript como o próprio CoffeeScript ainda não possuem esse recurso.

No Visual Studio podemos trabalhar com TypeScript criando um projeto HTML Application ou com MVC3 (não entendi por que não MVC4, logo abaixo demonstro como resolver isso).

Suporte para  HTML Application with TypeScript:

Suporte para um template MVC3:

O template “Typescript Internet Application” é apenas um template ASP.NET MVC 3 que permite compilar códigos TypeScript para JavaScript no processo de Build.
Esta configuração de build é feita no arquivo de projeto:

<None Include="Scriptsjquery.d.ts" />
    <TypeScriptCompile Include="Scriptssite.ts" />
    <Content Include="Scriptssite.js">
      <DependentUpon>site.ts</DependentUpon>
    </Content>
 <Target Name="BeforeBuild">
 <Exec
     Command="&amp;quot;$(PROGRAMFILES)
     Microsoft SDKsTypeScript\0.8.0.0tsc&amp;quot;
     @(TypeScriptCompile ->'&quot;%(fullpath)&quot;', ' ')" />
 </Target>

O TypeScript não fornece um template para MVC4, mas como mencionei acima, existe uma forma de resolver este problema. Basta criar um template MVC4 padrão e adicionar no arquivo de projeto “.csproject” o seguinte código:

<ItemGroup>
    <TypeScriptCompile Include="$(ProjectDir)***.ts" />
</ItemGroup>
  <Target Name="BeforeBuild">
   <Exec Command="&amp;quot;$(PROGRAMFILES)
   Microsoft SDKsTypeScript\0.8.0.0tsc&amp;quot;
  @(TypeScriptCompile ->'&quot;%(fullpath)&quot;', ' ')" />
  </Target>

Assim quando fizer o build do projeto o TypeScript vai ser compilado e o código JavaScript será gerado em arquivos JS automaticamente.

Primeiras impressões

Passei 4 dias aprendendo e utilizando TypeScript, eu gostei, consigo escrever um código mais bonito e organizado, de forma mais rápida e não precisei aprender uma outra linguagem ou sintaxe como seria no caso de utilizar o CoffeeScript.

Atenção ao versionar o código JS gerado, pois em um novo build ele será sobrescrito e ocasionará um erro, já que após versionar o arquivo se torna “read-only”.

Não é de hoje que diversas abordagens tentam esconder o JavaScript, o Google fez isso em 2011, o CoffeeScript faz, o WebForms do ASP.Net, todos geram JavaScript sem que nós nos preocupemos com isso, porém com TypeScript é a forma mais fácil que senti de trabalhar com JavaScript, afinal consigo debugar meu código original com o Source Mapping, mantenho atualizado meus conhecimentos em JavaScript e tenho uma visão mais clara do código que vai ser gerado, afinal JavaScript também é TypeScript.

Espero que tenham gostado, caso queira participar, dar um feedback ou tirar alguma dúvida faça um comentário 🙂

Links úteis

Referências

Bons estudos e até mais pessoal.

 

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.

Desenvolvimento Web com .Net – MVC x WebForms

Olá pessoal, o debate MVC x WebForms se tornou muito popular e pretendo abordar o tema aqui também.

Ambas tecnologias são para desenvolvimento Web.

ASP.Net WebForms:

  • Existe desde 2001 (foi o primeiro modelo de desenvolvimento Web com .Net)
  • Tomou o lugar do ASP3 (a maioria dos sites migraram de ASP para ASP.Net)
  • É até hoje o modelo mais utilizado em desenvolvimento ASP.Net.

O WebForms facilitou muito a vida de quem trabalhava com WindowsForms ou VB6, segue o conceito de “drag and drop”, controles muito ricos como o GridView por exemplo com um simples arrastar e soltar.

O WebForms faz sozinho boa parte do trabalho de desenvolver para Web:

  • Gera HTML e JavaScript sozinho.
  • Controla o estado dos controles (postback / viewstate)
  • Os controles fazem praticamente tudo que precisa sem programação extra.

Com tudo isso temos uma boa lista de prós para o WebForms:

  • É RAD (Muito rápido de desenvolver).
  • Controles ricos.
  • HTML e JavaScript automático. “sem necessidade de programar”.
  • Gerenciamento do estado abstraído.
  • Designer Visual.

Mas também temos os contras:

  • Não se tem muito controle do HTML e JavaScript gerado.
  • Alguns controles não estão em conformidades com o W3C.
  • Difícil integração com frameworks JavaScript.
  • A UI (user interface) é quase impossível de se testar.
  • Problemas para utilizar SEO
* Muitas melhorias ocorreram na versão 4.0 do WebForms.

Para entendermos melhor as diferenças vamos fazer uma comparação.

ASP.Net MVC:

  • Segue o padrão arquitetônico de Model View Controller.
  • Faz separação de responsabilidades (cada letra de MVC com a sua).

Para esclarecer, o conceito do MVC não foi criado pela Microsoft (foi pela Xerox em meados de 70), porém foi muito bem adotado e revitalizado.

Quais os prós de se usar MVC:

  • Separação de responsabilidades (cada camada com a sua).
  • Testabilidade.
  • Reusabilidade.
  • Escalabilidade.
  • Manutenção facilitada.
  • Total controle do HTML e JavaScript gerado.
  • Suporta TDD em todos os apectos.

Muito bom né? Agora vamos aos contras:

  • Não é tão RAD quanto o WebForms.
  • Não disponibiliza controle prontos “drag and drop” (mas existem muitos free).
  • A curva de aprendizado é maior, há mais coisas para aprender.
  • Mais coisas para controlar, por ex, sessão de usuário.
  • É necessário desenvolver mais código.

Certo, já deu para balancear?
O que o MVC tem em comum com WebForms:

  • Ambos são ASP.Net (rodam sob o mesmo runtime).
  • Geram páginas ASPX.
  • Rodam no IIS.
  • Acessam dados livremente (ADO.Net, LINQ, Entity Framework).
  • São desenvolvidos no Visual Studio (para MVC é necessário baixar um complemento dependendo da versão do Visual Studio).

Acredito que com base nesses conceitos e diferenças já dá para ter uma ideia de qual abordagem é mais indicada para determinados projetos.

Muitos estão afirmando que o WebForms virou o ASP3 (clássico) ou seja está caindo em desuso. “Quando muitos gurus da tecnologia começam a fazer esse tipo de afirmação a tendência é que se torne uma verdade.”

Afinal qual dos dois escolher para meu próximo sistema Web?

Desenvolver um sistema Web, ASP.Net, desenvolvido em WebForms, na maioria das vezes pode (e vai) atender meu cliente, o que me motiva escolher MVC já que o esforço de desenvolvimento é maior?

As maiores vantagens são:

  • Controle total do HTML e JavaScript gerado.
    Seu site não vai ter o CSS quebrado ou uma função JS desconhecida gerada pelo   ASP.Net. Além de facilitar a compatibilidade com os browsers.
  • Possibilidade de testar a UI
    No WebForms isso é quase impossível, uma vez que não conhecemos o código que ele irá gerar. Para quem usa TDD é essencial ter todas as camadas testadas.
  • Reaproveitamento de código
    O código que é gerado com MVC é seu, você o conhece e o reaproveita onde quiser.
  • Aperfeiçoamento no conhecimento de CSS, HTML e JavaScript.
    Essas tecnologias por mais que bem conhecidas estão em alta, novidades como Windows 8, HTML 5 e o conceito da “Nova Web” são baseadas no uso destes conhecimentos, não dá mais para deixar de lado.

Até então todos desenvolvedores ASP.Net eram adeptos ao WebForms, logo nem sempre encontramos profissionais experientes em MVC (que já está na versão 4).

Cenário:
Você tem um projeto de um sistema web para fazer, o prazo é curto, o sistema não exige uma interface rica e customizada (ainda mais se for uma intranet) e sua equipe não tem conhecimento de MVC, vá de WebForms, não é nesse momento que deverá colocar em prática o aprendizado do MVC.

Eu mesmo gosto do WebForms (assim como já gostei muito de ASP3), trabalhei anos com ele, migrei para o MVC e aos poucos estou convertendo projetos para essa tecnologia.

Minha dica é:
Aprenda! Não deixe de aprender, experimente fazer um projeto em MVC, com o tempo e conhecimento a produtividade volta ao normal, e mais, você se manterá atualizado (MVC já é um pré-requisito para muitas vagas de desenvolvimento).

Por hoje é isso…
Pretendo continuar esse assunto abordando um novo conceito, chamado até então de “Nova Web”. Aguardem.

Quer compartilhar sua experiência? Tirar dúvidas? Utilize os comentários 😉

Referências:

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

C# – Para Iniciantes – Parte 1 – Variáveis, Passagem por Valor ou Referência.

Olá Pessoal, Vou fazer uma série sobre (C Sharp) C# para iniciantes.

Atendendo à diversos pedidos vou procurar abordar de uma forma diferente a transferência de conhecimentos nessa linguagem, apostila e tutorial tem de monte na internet, a intenção não é essa, vamos abordar necessidades reais de quem quer dar os primeiros passos em C# e agora quer aprender mais.

Só para começar, um pouquinho de história:
O C# é uma linguagem derivada do C++, mas também tem base em Java e Object Pascal.
Criada em meados de 1999 por Anders Hejlsberg (pai do Turbo Pascal e Delphi) vem desde 2001 ganhando espaço e se tornou uma das linguagens mais populares da atualidade.

Vamos dar o primeiro passo:

Variáveis

Toda variável é uma alocação de uma quantidade de memória, é nesse espaço de memória que está armazenado o conteúdo da variável, internamente uma variável possui um ponteiro, o ponteiro para o sistema operacional é um endereçamento físico de memória, serve para localizar onde está armazenado tal dado.

A declaração de variável em C#:

Tipo NomeDaVariavel;

int MeuInteiro; 

Deve-se sempre inicializar uma variável:

int MeuInteiro = 0; 

Stack e Heap

O gerenciamento da memória no C# é feito em duas áreas de memória, o Stack e o Heap.

O Stack é uma área bem pequena de memória (alguns KB) e funciona no formato de pilha.

Pilha é uma estrutura de dados em que a inserção e a remoção de elementos de uma sequência se faz pela mesma extremidade, geralmente designada por topo da pilha”

Ou seja, o último que entra na pilha é o primeiro que sai (LIFO – Last-In-First-Out)
Qualquer dado inserido na Stack é automaticamente retirado automaticamente após a conclusão do processo que a alocou, isso livra o programador de se preocupar com isso.
Quando a Stack atinge seu tamanho máximo temos um problema muito conhecido como “stack overflow”. Os dados armazenados na Stack são chamados de “Value Types”.

A Heap é uma área de memória bem grande, diferente da Stack que é pequena, seu tamanho muda dinamicamente conforme o uso, a Heap é acessada indiretamente, por meio de referência, por isso chamamos os dados da Heap de “Reference Type”.
Existe um processo chamado Garbage Collector (GC) que é responsável pela limpeza desta área de memória.

O custo de se criar um objeto na Heap é muito maior do que na Stack, sendo assim na área de memória Stack nós temos os Value Types a seguir:
Tipos numéricos (int, long, short etc), ponto flutuante (float, double), decimal, booleanos (true e false) e estruturas definidas pelo usuário (struct).

Na Heap nós temos os Reference Types do tipo: Classes, Interfaces e Delegates.

As características dos tipos alocados em cada uma dessas áreas são as seguintes:

Value Types:

  • Uma variável deste tipo contém o valor, e não um endereço de referência para o valor;
  • Derivam de System.ValueTypes;
  • Variáveis de escopo local precisam ser inicializadas antes de serem utilizadas;
  • Atribuir o valor de variável a outra, implicitamente, é feita uma cópia do conteúdo da variável. Sendo assim, qualquer alteração no conteúdo de uma delas, não afetará a outra. Quanto maior for um objeto deste tipo mais custosa será sua cópia.

Reference Types:

  • Uma variável contém a referência (ou endereço) para o objeto que está na Heap;
  • Atribuir o valor de uma variável para outra faz uma cópia da referência, e não do próprio objeto. Ou seja, não é feita a cópia do objeto, e sim do endereço de memória do objeto, o que não gera muito custo para objetos grandes;
  • São alocados na Heap e seus objetos são coletados pelo Garbage Collector;
  • São passados por referência, enquanto que Value Types são passados por valor. Ou seja, a alteração de um objeto afetará todas as instâncias que apontam para ele.

Boxing e Unboxing

Boxing é o processo de converter um “Value Type” para o tipo de object ou a qualquer tipo de interface implementada por este tipo de valor “Reference Type”.

Unboxing extrai o “Value Type” do objeto. Transforma um objeto em um tipo simples.

      // Vamos fazer um Boxing
      int i = 123;
      object obj = i;

      // Agora vamos fazer Unboxing
      obj = 123;
      i = (int)obj;

Simples né?

O Garbage Collector (GC)

Como na Heap todos objetos são referenciados, o GC verifica se existe alguma variável fazendo referência a determinado objeto, caso não encontre ele desaloca “Coleta” aquela área de memória.

Um fato interessante, por mais que se chame o Garbage Collector a sensação que temos é de que ele irá entrar em ação no mesmo instante, mas não, estamos apenas sinalizando a ele. “Passe por aqui GC”.

Não é recomendado chamar manualmente o GC, deixe com que ele trabalhe de sua forma.
Abaixo estamos chamando o GC, porém sinalizando para que ele aguarde o trabalho em memória terminar:

      GC.Collect();
      GC.WaitForPendingFinalizers();

Passagem de Valor ou por Referência

Dada as funções:

      public void FuncaoPorValor(int numero)
      {
          numero = 10;
      }

      public void FuncaoPorReferencia(ref int numero)
      {
          numero = 10;
      }

A única diferença entre as duas é que uma trata a variável “numero” passada por valor e a outra trata a variável “numero” por referência.

Observemos os resultados:

      int variavel = 0;
      FuncaoPorValor(variavel);

      MessageBox.Show("Resultado = " + variavel.ToString());
      // Resultado = 0 Foi passada uma cópia da variável pro método.

      int variavel2 = 0;
      FuncaoPorReferencia(variavel2);

      MessageBox.Show("Resultado = " + variavel2.ToString());
      // Resultado = 10 Foi passada a referência da variável pro método.

Normalmente quando passamos uma variável para uma função, estamos passando uma cópia dela para a função trabalhar.
Caso essa cópia seja modificada a original permanece igual.

Quando passamos a variável por referência, um ponteiro de memória está sendo passado, ou seja, caso seja modificada a própria variável está sendo alterada, pois o ponteiro de memória aponta para a alocação original.

E por hoje ficamos por aqui.
Espero que aproveitem e em caso de dúvidas podem postá-las nos comentários.

Referências:

LightSwitch – Um jeito simples de criar aplicações modernas para empresas.

Olá pessoal, trago hoje mais uma novidade da Microsoft, o LightSwitch 2012

Todas as empresas atendem um determinado negócio e hoje em dia é praticamente impossível imaginar que não exista um sistema apoiando o controle do negócio ou pelo menos parte dele.

Desde a papelaria da esquina até um banco, todas empresas necessitam de um sistema, seja ele de apoio aos negócios ou de controle (estoque por exemplo).

As empresas possuem esta necessidade, é vital para seu funcionamento, mas nem sempre estão dispostas a investir financeiramente para adquirir um sistema moderno sob encomenda, tão quanto esperar aqueles meses de projeto para que fique pronto.

Resultado:
Sistemas Access, planilhas Excel, Softwares de prateleira ou até aquele sistema em VB5 que o vizinho tinha desenvolvido uns 10 anos atrás.

Em minha experiência com sistemas já presenciei diversos cenários, um dos mais intrigantes foi estar em um departamento de um banco de grande porte onde todo o processo era controlado por um sistema chamado “Planilhão”. O planilhão fazia tudo, controlava valores, entradas, saídas, diferenças.
Exposição à erros humanos, duplicação de informação e perda de dados era rotina.

Desenvolver um sistema sob encomenda que atenda o negócio de um determinado cliente não é barato para quem compra e não é fácil para quem faz.

Pensando nesse cenário a Microsoft inovou mais uma vez e lançou uma solução:

LightSwitch for Visual Studio

  • Desenvolva rapidamente aplicações de negócio.
  • Obtenha mais de seus dados.
  • Surpreenda os usuários finais.
  • Estenda sua aplicação sem redesenhá-la.

O LightSwitch é 100% RAD (Rapid Application Development).
Disponível para download no Visual Studio 2010, parte do Visual Studio 2012.
Cria automaticamente toda a estrutura (telas, CRUD, pesquisas, visualizações).
O único código que é escrito é a regra de negócios. Possui a facilidade de acompanhar o crescimento do sistema sem maiores manutenções.
Pode ser hospedado no Windows Azure 🙂

Arquitetura:

Arquitetura LightSwitch

Desenvolvedores tem em mãos com LightSwitch uma oportunidade de gerar novos negócios, pois possibilita o rápido desenvolvimento de sistemas, em conjunto com o Entity Framework todas as Entidades são criadas com base na modelagem de dados.

Não tem mais desculpa para usar o velho “planilhão” agora 🙂

Curioso para experimentar?
Abaixo uma série de vídeos passo-a-passo que irá prover todo o suporte necessário para se ambientar com a nova ferramenta:
(Conteúdo oficial Microsoft – Em Inglês) 

1 – How Do I: Define My Data in a LightSwitch Application?
(6 minutos 55 segundos)

2 – How Do I: Create a Search Screen in a LightSwitch Application?
(8 minutos, 58 segundos)

3 – How Do I: Create an Edit Details Screen in a LightSwitch Application?
(5 minutos, 15 segundos)

4 – How Do I: Format Data on a Screen in a LightSwitch Application?
(12 minutos, 52 segundos)

5 – How Do I: Sort and Filter Data on a Screen in a LightSwitch Application?
(9 minutos, 44 segundos)

6 – How Do I: Create a Master-Details (One-to-Many) Screen in a LightSwitch Application?
(9 minutos, 15 segundos)

7 – How Do I: Pass a Parameter into a Screen from the Command Bar in a LightSwitch Application?
(11 minutos, 44 segundos)

8 – How Do I: Write business rules for validation and calculated fields in a LightSwitch Application?
(15 minutos, 55 segundos)

9 – How Do I: Create a Screen that can Both Edit and Add Records in a LightSwitch Application?
(7 minutos, 30 segundos)

10 – How Do I: Create and Control Lookup Lists in a LightSwitch Application?
(7 minutos, 24 segundos)

11 – How Do I: Set up Security to Control User Access to Parts of a Visual Studio LightSwitch Application?
(23 minutos, 52 segundos)

12 – How Do I: Deploy a Visual Studio LightSwitch Application?
(20 minutos 24 segundos)

13 – How Do I: Deploy a LightSwitch Application to Azure?
(12 minutos, 41 segundos)

14 – How Do I: Modify the Navigation of Screens in a LightSwitch Application?
(04 minutos, 19 segundos)

15 – How Do I: Open a Screen After Saving Another Screen in a LightSwitch Application?
(08 minutos, 41 segundos)

16 – How Do I: Connect LightSwitch to an Existing Database?
(15 minutos, 20 segundos)

17 – How Do I: Connect LightSwitch to SharePoint Data?
(15 minutos, 26 segundos)

18 – How Do I: Save Data from Multiple Data Sources on the Same Screen?
(07 minutos, 19 segundos)

19 – How Do I: Set Default Values on Fields when Entering New Data?
(03 minutos, 21 segundos)

20 – How Do I: Copy Data from One Row into a New Row?
(07 minutos, 18 segundos)

21 – How Do I: Add Commands as Buttons and Links to Screens?
(08 minutos, 15 segundos)

22 – How Do I: Show Multiple Columns in an Auto-Complete Dropdown Box?
(02 minutos, 39 segundos)

23 – How Do I: Create Custom Search Screens in LightSwitch?
(18 minutos 22 segundos)

24 – How Do I: Handle Database Concurrency Issues?
(14 minutos 12 segundos)

O objetivo desse post é divulgar a novidade, em breve postarei mais conteúdo como exemplos, códigos e dicas.

Downloads:

Saiba mais em: