C# - Resumão Prático de 10 Conceitos Básicos e importantes


1- Como declarar variáveis ?

int x = 13;    //declara e define imediatamente
int y;         
 //declara e defina mais tarde
y = 13;

outras formas de declarar variáveis:

int a;
double area = 0;
int salario, imposto , soma;
int contador = 10;

string nome;
string nomeCompleto = "Macoratti";

2- Como declarar uma variável e atribuir-lhe um valor, sem saber o seu tipo, mas ainda tirar proveito da tipagem forte ?

A Inferência de tipo permite que você deixe o compilador decidir qual o tipo de uma variável local .(não pode ser utilizada para campos de classes).

Na linguagem C# a inferência de tipo usa a palavra reservada var.

A palavra-chave var instrui o compilador para deduzir o tipo da variável da expressão no lado direito da instrução de inicialização.

O tipo inferido pode ser um tipo interno, um tipo anônimo, um tipo definido pelo usuário ou um tipo definido na biblioteca de classes do NET Framework.

using System;

namespace Resumao_CSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            var inteiro = 13;
            var Objetos = new MeuTipo();
            var numeros = new double[] { 1.0, 1.5, 2.0, 2.5, 3.0 };

            //não é permitido inicializar para null
            //var myNullObj = null;
            //mas após a declaração podemos fazer essa inicialização
            var objetoNull = new MeuTipo();
            objetoNull = null;
            //
            Console.WriteLine("variável inteiro\t Tipo: {0}", inteiro.GetType());
            Console.WriteLine("varivável Objetos\t Tipo: {0}", Objetos.GetType());
            Console.WriteLine("variavel numeros\t Tipo: {0}", numeros.GetType());
            Console.ReadLine();
        }
    }

    class MeuTipo { }
}

3- Como executar a verificação de tipo somente em tempo de execução(tipos dinâmicos) ?

Podemos adiar a verificação de tipo usando a palavra-chave dynamic para variáveis e parâmetros de métodos.

using System;

namespace UsandoDynamic
{
    class Program
    {
        static void Main(string[] args)
        {
            //declara 3 tipos que não têm nada em comum 
            //mas todos possuem uma propriedade Id ed Nome
            Pessoa p = new Pessoa()
            { Id = 1, Nome = "Macoratti", Email = "macoratti@yahoo.com" };

            Companhia c = new Companhia()
            { Id = 1313, Nome = "Microsoft", Estatal = false };

            var v = new { Id = 13, Nome = "Joana", Feia = true };

            ImprimirInfo(p);
          ImprimirInfo(c);
          ImprimirInfo(v);

            try
            {
             ImprimirInfo(13);
            }
            catch (Exception ex)
            {
               Console.WriteLine("Opaaa...não ode chamar o método ImprimirInfo(13)");
               Console.WriteLine(ex);
            }
            Console.ReadKey();
        }
        static void ImprimirInfo(dynamic dados)
        {
            //vai imprimir qualquer coisa que possuir uma propriedade Id e Nome
            Console.WriteLine("ID: {0}, Nome: {1}", dados.Id, dados.Nome);
        }
    }
    //---------
    class Pessoa
    {
        public int Id { get; set; }
        public string Nome { get; set; }
        public string Email { get; set; }
    }
    //---------
    class Companhia
    {
        public int Id { get; set; }
        public string Nome { get; set; }
        public bool Estatal { get; set; }
    }
}
O método ImprimirInfo() recebe uma parâmetro do tipo dynamic e verifica o tipo e exibe o valor  da propriedade id e nome;

Embora a palavra-chave dynamic nos dá o comportamento dinâmico, nos bastidores, o Dinâmica Language Runtime (DLR) usa truques de compilador e reflection para vincular as chamadas envolvendo tipos dinâmicos para tipos estáticos.

4- Como usar a tipagem dinâmica para simplificar a interação com o COM ?

Você quer usar objetos de componentes COM e evitar a exigência de efetuar o cast para Object.

Use a tipagem dinâmica para que a verificação e vinculação seja feita em tempo de execução, como no exemplo a seguir, o qual utiliza o componente COM Excel 2007.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Excel = Microsoft.Office.Interop.Excel;

namespace usando_Dynamic
{
    class Program
    {
        static void Main(string[] args)
        {
            var app = new Excel.Application();
            app.Visible = true;
            app.Workbooks.Add();
       
    //para evitar o cast use dynamic               
            dynamic sheet = app.ActiveSheet;
            sheet.Cells[1, “A”] = 13;
            sheet.Cells[2, “A”] = 13;
            sheet.Cells[3, “A”] = “=A1*A2”;
            sheet.Columns[1].AutoFit();
        }
    }
}

4- Como declarar Arrays ?

Existem muitas variações na sintaxe da declaração de arrays. Abaixo temos exemplos que são todos equivalentes:

 static void Main(string[] args)
        {
            //todas são equivalentes
            int[] array1 = new int[4];
            array1[0] = 13; array1[1] = 14; array1[2] = 15; array1[3] = 16;
            int[] array2 = new int[4] { 13, 14, 15, 16 };
            int[] array3 = new int[] { 13, 14, 15, 16 };
            int[] array4 = { 13, 14, 15, 16 };
        }

5- Como declarar Arrays Multidimensionais ?

Primeiro, decida que tipo de matriz multidimensional você precisa. existem dois tipos em C#: retangulares e jagged(irregulares ou arrays de arrays)

a- Retangulares

int[,] mArray1 = new int[,]
{
     {1,2,3,4},
     {5,6,7,8},
     {9,10,11,12}
};
float val = mArray1[0, 1];
//2

b- Jagged

int[][] jaggedArray = new int[3][];

jaggedArray[0] = new int[2];
jaggedArray[1] = new int[5];
jaggedArray[2] = new int[3];

jaggedArray[0] = new int[] { 1, 2 };
jaggedArray[1] = new int[] { 3, 4, 5, 6, 7 };
jaggedArray[3] = new int[] { 8, 9, 10 };

Exemplo de criação e exibição de um array de array (jagged array):

using System;

namespace JaggedArrays
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declara um array de 4 elementos
            int[][] jaggedArray = new int[4][];

            // Inicializa os elementos
            jaggedArray[0] = new int[2] { 7, 9 };
            jaggedArray[1] = new int[4] { 12, 42, 26, 38 };
            jaggedArray[2] = new int[6] { 3, 5, 7, 9, 11, 13 };
            jaggedArray[3] = new int[3] { 4, 6, 8 };
            // Exibe os elementos do array
            for (int i = 0; i < jaggedArray.Length; i++)
            {
                System.Console.Write("Elemento({0}): ", i + 1);
                for (int j = 0; j < jaggedArray[i].Length; j++)
                {
                    System.Console.Write(jaggedArray[i][j] + "\t");
                }
                System.Console.WriteLine();
            }
            Console.ReadLine();
        }
    }
}

6- Usando o operador condicional (?)

O operador condicional é também conhecido como operador ternário e é formado por três operandos que são separados pelos sinais ? e :

Por exemplo: condicao ? valor_se_verdadeiro : valor_se_falso

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

static void Main(string[] args)
{
    bool condicao = true;
    int x = condicao ? 13 : 14;
    Console.WriteLine("x é {0}", x);
  
 //voce pode embudir uma condição
    Console.WriteLine("Condição é {0}", condicao ? "TRUE" : "FALSE");
     Console.ReadKey();
}

7- Usando o operador ??

O operador ?? simplifica a verificação de valores nulos. (null)

Os tipos por referência podem representar um valor não existente com uma referência null.
Os tipos por valor não podem representar valores null.
Ex:
string nome = null   
// OK, o tipo é por referência
int x = null             
 // Erro de Compilador, tipo por valor não pode ser null

Trata-se de um situação comum, onde você precisa verificar se há um valor nulo antes de usar uma variável.

Ele pode ser usado tanto com tipos anuláveis como com tipos de referência.

Sua representação é: x ?? y

que significa que se x não é nulo, será retornado x, caso contrário, y.

Na sintaxe: x ?? y

x é o primeiro operando que é do tipo nullable
y é o segundo operando que tem um valor non-nullable do mesmo tipo

Durante a execução de código, se x for avaliado como null, y é retornado como o valor.

Lembre-se que o operador ?? é avaliado da direita para a esquerda.

Então se você tem uma expressão da forma x?? y?? z

Esta expressão é avaliada como x ?? (y ?? z)

Exemplo:

class Program
    {
        static string _nome;

        static string Nome
        {
            get
            {
                return _nome ?? "Default";
            }
            set
            {
                _nome = value;
            }
        }

        static void Main(string[] args)
        {
            Console.WriteLine(Nome);
            Nome = "Macoratti";
            Console.WriteLine(Nome);
            Nome = null;
            Console.WriteLine(Nome);
        }
    }

8 - Adicionando métodos a tipos existentes com métodos de extensão

A rigor os Extensions Methods são uma implementação do padrão de projeto estrutural Composite e permitem que você adicione uma nova funcionalidade a um tipo de dado que já foi definido sem ter que criar um novo tipo derivado; dessa forma a funcionalidade comporta como um outro membro do tipo.

Através da aplicação dos Extensions Methods você pode, por exemplo, incluir funcionalidades adicionais a uma string sem ter que herdar da classe String, e o novo comportamento é tratado como um novo membro assim com os Extensions Methods é possível escrever um método que pode ser chamado como se ele fosse um método de instância de um tipo existente.

Abaixo temos um exemplo de como criar um método de extensão para o tipo int. O método de extensão IsPrimo() verifica se um número é primo.

using System;

namespace MetodosExtensao
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i < 50; ++i)
           {
               if (i.IsPrimo())
               {
                   Console.WriteLine(i);
               }
           }
            Console.ReadKey();
        }
    }

    static class IntMethods
    {
     
  //métodos de extensão tem que ser static
        //a palavra chave this informa ao C# que este é um extension method

        public static bool IsPrimo(this int numero)
        {
            if (numero % 2 == 0)
            {
                if (numero == 2)
                    return true;
                return false;
            }
            int maximo = (int)Math.Sqrt(numero);
            for (int i = 3; i <= maximo; i += 2)
            {
                if ((numero % i) == 0)
                {
                    return false;
                }
            }
            return true;
        }
    }
}

A seguir algumas características dos Extensions Methods:

O LINQ usa o recurso dos Extensions Methods de forma extensiva.

9 - Invocar métodos com parâmetros padrão

A partir da versão 4.0 a linguagem C# suporta parâmetros default.

No exemplo abaixo o método MostraPasta() utiliza parâmetros padrão. Se o método for chamado sem parâmetros o método usará os parâmetros padrão definidos: c:\dados e false.

using System;
using System.IO;

namespace Macoratti
{
    class Program
    {
        static void Main(string[] args)
        {
              MostraPasta();
            MostraPasta(@"C:\dados");

            //não podemos fazer esta chamada
            //MostraPasta(false);

        }

        static void MostraPasta(string raiz = @"C:\dados",bool mostraCaminhoCompleto = false)
        {
            foreach (string pasta in Directory.EnumerateDirectories(raiz))
            {
                string saida = mostraCaminhoCompleto ? pasta : Path.GetFileName(pasta);
                Console.WriteLine(saida);
            }
        }
    }
}

O novo recurso de parâmetros padrão do C# 4.0 oferece uma alternativa para a sobrecarga de método.

O uso de parâmetro padrão pode ser uma questão controversa. A quem defenda a utilização de sobrecarga de métodos ao invés de parâmetros padrão. Cabe avaliar cada situação para decidir qual opção melhor se aplica.

10 - Invocar métodos com parâmetros nomeados

Na versão 4.0 da linguagem C# temos o suporte aos parâmetros nomeados.

A utilização de parâmetros nomeados permite dar nome a um parâmetro que estamos passando para um método e não apenas identificar o parâmetro pela sua posição.

Os parâmetros nomeados são úteis quando um método suporta múltiplos parâmetros opcionais e você deseja especificar quais parâmetros esta passando.

    class Program
    {
        static void Main(string[] args)
        {
               Multiplicar();
            Multiplicar(x:10);
            Multiplicar(10,20);
            Multiplicar(y: 30);

        }

        static int Multiplicar(int x = 0, int y = 0)
        {
            return x * y;
        }
    }
O método Multiplicar() utiliza dois parâmetros nomeados x e y que possuem valores nomeados.

Podemos fazer a chamada de diversas formas omitindo parâmetros e/ou identificando-os pelo seu nome.

Multiplicar();
Multiplicar(x:10);
Multiplicar(10,20);
Multiplicar(y: 30);

 

Este novo recurso do C# 4.0 oferece uma alternativa para a sobrecarga de método.

E assim vimos um resumo de 10 características importantes da linguagem C#.

Pegue o projeto completo aqui: Resumao_CSharp.zip

Mat 5:1 Jesus, pois, vendo as multidões, subiu ao monte; e, tendo se assentado, aproximaram-se os seus discípulos,

Mat 5:2 e ele se pôs a ensiná-los, dizendo:

Mat 5:3 Bem-aventurados os humildes de espírito, porque deles é o reino dos céus.

Mat 5:4 Bem-aventurados os que choram, porque eles serão consolados.

Mat 5:5 Bem-aventurados os mansos, porque eles herdarão a terra.

Mat 5:6 Bem-aventurados os que têm fome e sede de justiça porque eles serão fartos.

Mat 5:7 Bem-aventurados os misericordiosos, porque eles alcançarão misericórdia.

Mat 5:8 Bem-aventurados os limpos de coração, porque eles verão a Deus.

Mat 5:9 Bem-aventurados os pacificadores, porque eles serão chamados filhos de Deus.

Mat 5:10 Bem-aventurados os que são perseguidos por causa da justiça, porque deles é o reino dos céus.

Mat 5:11 Bem-aventurados sois vós, quando vos injuriarem e perseguiram e, mentindo, disserem todo mal contra vós por minha causa.

Referências:


José Carlos Macoratti