Vou palestrar no DevBrasil Summit 2013

Olá Pessoal, tudo bem?

DevBrasil Summit 2013

O DevBrasil Summit 2013 é encontro nacional da rede social DevBrasil reunindo desenvolvedores de software de todo o Brasil para falar de inovação, empreendedorismo e tecnologia.

Farei minha palestra sobre Visual Studio LightSwitch, um tema que eu adoro falar principalmente para o público mais jovem que está iniciando na carreira de desenvolvimento.

Segue link oficial, façam suas inscrições (gratuíto):
http://devbrasil.net/events/devbrasil-summit-2013-sao-paulo

Mais uma vez agradeço ao Mestre Ramon Durães e o time DevBrasil pela oportunidade 🙂

Espero vocês lá!

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 😉

e-Books Microsoft Press Grátis!

Olá pessoal, e-Books Microsoft Press Grátis!

Vamos aproveitar a oportunidade e agregar mais conhecimentos para nossa carreira?

Ando ocupado preparando o material de minha palestra no Visual Studio Summit 2012, em breve voltarei com posts mais regulares 🙂

Enquanto isso, divirtam-se com estes downloads:

cover for Introducing Windows Server 2012 RTM Edition    cover for Introducing Windows Server 2008 R2   cover for Introducing Microsoft SQL Server 2012   cover for Introducing Microsoft SQL Server 2008 R2

cover for Understanding Microsoft Virtualization Solutions, 2nd Ed   clip_image007   clip_image008   clip_image009

clip_image010   672611.indd    Moving to Visual Studio 2010  Programming Windows Phone 7

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.

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.

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:

Prática de Desenvolvimento + Qualidade na Entrega

Olá Pessoal, hoje vamos falar sobre Prática de Desenvolvimento de Software.

De que forma ela influência na qualidade das entregas?

Participo de alguns grupos de debate sobre desenvolvimento, arquitetura, etc… E apesar dos assuntos lá debatidos não iniciarem em volta deste, quase sempre caem no mesmo tema.

Lá está você esperando eu começar a abordar um SCRUM + Kanban, XP ou algum Ágile, pois é, mas a prática a ser abordada hoje é um pouco mais conhecida e muito mais utilizadas que estas:

Go Horse!
GoHorse!

Apesar da brincadeira, é uma dura e triste realidade.
Empresas ou Departamentos de TI que não possuem estrutura, processos e gestão de tarefas automaticamente tendem a implicitamente utilizar Go Horse!

O objetivo desse post, além da brincadeira é abordar como podemos apesar da triste realidade nos sair melhor mesmo em modo Extreme Go Horse!

Apenas para enfatizar o Go Horse!
Realizar a entrega de um sistema / tarefa de desenvolvimento em um prazo impossível, não pense, apenas faça! Compilou? Sobre no repositório e avisa que está pronto. Testes? Se o cliente encontrar Bug corrigiremos.

Sacou? Nada diferente do que um dia já vivemos ou talvez viveremos.

Apesar da enorme desmotivação que o Go Horse! proporciona, (já que não podemos aplicar tudo aquilo que estudamos e é certo) podemos nos basear em algumas inteligentes regras para tornar nosso trabalho mais assertivo e menos desmotivante, e quem sabe (por que não?) atingirmos com sucesso nossos objetivos:

1- Entenda o propósito.
Procure ter uma visão completa sobre os objetivos que o sistema visa atender. Saiba também o por que o cliente precisa do sistema, como funciona o negócio do cliente.

2- Foco no Domínio.
Um cliente paga para obter valor ao seus negócios, ou seja, foque realmente naquilo que o cliente precisa, se o tempo é curto entregue com uma interface de usuário mais básica porém funcional, encantar o cliente antes de tudo é atingir os objetivos dele, tudo que foi desenvolvido e não foi percebido pelo cliente é investimento jogado fora.

3- Entregue o mais importante antes.
Geralmente a parte mais crítica do sistema é a que fica por último, por ser mais difícil ou por ser a mais trabalhosa, porém é aquela o cliente mais precisa, atenda o desejo dele o quão antes possível. Com o feedback da entrega você saberá se está no caminho certo.

4- O código que você produz reflete que profissional você é.
Não é por que o prazo é curto que o código precisa ser um lixo, escreva códigos simples, comentados, quebre tudo por funcionalidades ao invés de criar uma linguiça com N rotinas aglomeradas. Na próxima manutenção você não terá que jogá-lo no lixo e fazer tudo de novo.
Quanto menos manutenção seu código gerar, mais tempo você terá para pegar aquele projeto bacana que só não iniciou por que a entrega do cliente não está funcionando.

5- Código funcionando é código testado.
Sempre que possível faça os testes unitários de seu código, (ainda falaremos mais sobre isso em breve) Procure testar as rotinas mais críticas, ex: cálculo de juros.

6- Seja prático
Um código que atende claramente o Domínio do cliente é facilmente entendido por outro desenvolvedor, assim você não se torna o eterno pai do sistema.
Investir mais na fase inicial de desenvolvimento para eliminar a possibilidades de manutenções ou mesmo para facilitar possíveis futuras expansões é perca de tempo, não preveja o futuro, tudo muda a toda hora, atenda a necessidade atual da melhor forma possível, o futuro vem depois.

7- Adquira uma organização pessoal para aumento de produtividade.
E-mails, twitters, Facebook, e qualquer tipo de “desviadores de foco” estão presentes na vida de qualquer desenvolvedor. Procure obter momentos de 100% de foco, otimize sua produção com uma quantidade X desses momentos em sua jornada diária, e depois disso nos intervalos você pode Tuitar, ler/responder os e-mails ou até mesmo implementar aquele Pattern que você achou que seria benéfico ao sistema, mas não daria tempo de fazer.
Existe uma técnica interessante para essa gestão de tempo, falaremos futuramente sobre o Pomodoro.

8- Não admita que as coisas são assim e pronto.
Como disse tudo muda a toda hora, se no seu trabalho o dia-a-dia é Go Horse! Você pode mudar isso. Sugira novas idéias, procure sempre aprimorar seu trabalho, não mantenha-se desmotivado, traga novidades para a empresa, procure convencer de forma teórica, didática e prática os seus gestores de que a coisa pode ser melhor.
Tudo mantem-se igual por que ninguém faz o esforço certo e necessário para que as coisas mudem.
Se no final de tudo (de tudo mesmo) a coisa não mudar, mude você! Afinal um bom profissional tem direito a uma boa oportunidade de trabalho.

Resumindo:
Apesar do Go Horse! definitivamente ser um dos grandes males de nossa área algumas inteligentes abordagens podem nos oferecer uma maior oportunidade de melhorar nosso dia-a-dia.
Sim, essa publicação é mais do mesmo, mas para quem principalmente está no início da carreira é importante ter em mente: Não vicie em um ritmo que não é bom, procure melhorar, procure mudar.

Especialmente inspirado: