Fundamentos

Criando Projeto

No terminal digite dotnet new console.
Isso criara a estrutura do projeto:

Sendo esses respectivamente subpasta que gera o executável, arquivo de projeto que guarda as configurações básicas e por ultimo o arquivo principal.

Executando projeto

Para execução utilize o comando no terminal dotnet run

Entendendo a Sintaxe

No arquivo principal:

    
using System;

    

        namespace aguradorInstruções
        {

        Class ModeloObjto
            {
                static void Main(String[] args)
                {
                    Console.WhiteLine("Code Programa...")   
                }
            }

        

        Class Outra
            {

            }

        }

Interessante notar que no C# tudo são classes.
Para o funcionamento do programa é necessário declarar a função Main.
Essa é uma função estatica e retorna nenhum valor (void).
Ainda a mesma recebe parâmetros do tipo strings[]

Instruções no C# são sinalizadas com seu final em ";".
Cada Instrução é executada uma após a outra.

Para desenvolver em qualquer lugar acesse Repl

Declarando Variáveis

Para declarar uma variável basta informar o tipo seguido do Nome exemplo: 

    float Quant = 9.36 ;

Tipo de Dados
TIPO
REPRESENTAÇÃO
RANGE
VALOR PADRÃO
Bool Boolean True or False False
Byte 8-bit unsigned Integer 0 to 255 0
Char 16-bit Unicode character U +0000 to U +ffff '\0'
decimal 128-bit precise decimal values with 28-29 significant digits (-7.9 x 1028 to 7.9 x 1028) / 100 to 28 0.0M
double 64-bit double-precision floating point type (+/-)5.0 x 10-324 to (+/-)1.7 x 10308 0.0D
Float 32-bit single-precision floating point type -3.4 x 1038 to + 3.4 x 1038 0.0F
Int 32-bit signed integer type -2,147,483,648 to 2,147,483,647 0
Long 64-bit signed integer type 923,372,036,854,775,808 to 9,223,372,036,854,775,807 0L
Sbyte 8-bit signed integer type -128 to 127 0
Short 16-bit signed integer type -32,768 to 32,767 0
Uint 32-bit signed integer type 0 to 4,294,967,295 0
Ulong 64-bit signed integer type 0 to 18,446,744,073,709,551,615 0
Ushort 16-bit signed integer type 0 to 65,535 0

Ainda caso a variável ser definida na compilação utilize o tipo var.
Para valores que não devem ser alterados utilize o tipo const seguido do tipo. A principal utilização é em elementos que devem ser protegidos dentro do programa.

Enumeradores

Para pré definir uma lista de valores aceitáveis utilize o tipo enum seguido do nome do mesmo com chaves contendo os valores aceitos. 

    enum diasSemana{Domingo, Segunda, Terça, Quarta, Quinta, Sexta, Sábado};

A posição desses valores serão representados por índice. Basta fazer um cast informando o enumerador entre parênteses seguido do numero do índice. 
    Console.WriteLine((diasSemana)5)

Resultado da execução: >> Sexta

Convertendo valor em numero 
    Console.WriteLine((int)diasSemana.Sexta);

Resultado da execução: >> 5

typecast

É necessário toda vez que a conversão de valores for Explicita, o implícito é feito de maneira automática uma vez que a conversão não apresenta nenhum risco de alteração de valores.

Exemplos:

Implícito

De int para float são acrescido zeros ao final então não existe risco de alteração valores uma vez que o zero representa a ausência de valor fracionado.

Explicito

Já ao contrario, de float para int o valor vai ser alterado em parte, uma vez que perderá seu valor fracional.

Atribuindo valores

Input através do teclado Console.ReadLine();

    String variavel = Console.ReadLine();
Boas praticas de nomenclatura
COMPONENTE
PREFIXO
EXEMPLO
Formulário frm frmCadastro
Caixa de Figura (PictureBox) pic picImagens
Label lbl lblNome
Caixa de Texto (TextBox) txt txtNome
Botão de Comando – Button btn btnSalvar
Caixa de Verificação (CheckBox) chk chkData
ComboBox cbo cboEstado
ListBox lst lstFornecedor
Timer tmr tmrRelogio
Grid grd grdClientes
Menu mnu mnuExibir

Identificando

Podemos identificar uma variável, funções, classes etc.

Palavras Reservadas
PALAVRAS-CHAVE RESERVADAS
abstract as
base bool break byte
case catch char checked class const
continue
decimal default delegate do double
else enum event explicit extern
false finally fixed float for foreach
goto
if implicit in int interface internal
is
lock long
namespace new null
object operator out override
params private protected public
readonly ref return
sbyte sealed short sizeof stackalloc static
string struct switch
this throw true try typeof
uint ulong unchecked unsafe ushort using
virtual void volatile
while
add alias ascending
descending dynamic
from
get global group
into
join
let
orderby
partial
remove
select set

Convertendo variáveis

A conversão de variáveis se da a partir da declaração da variável que salvara o valor convertido seguido do processo novo_tipo.Parse(); 

    string variavel = 3;

    b = int.Parse(variável);
ou
    b = Covert.ToInt32(variável);

Escopo

Até onde a variável é visível de onde ela foi declarada para onde ela pode ser acessada. 

    class exemplo
    {
        string variavel_global = "I'm global";
        

            static void Main()
            {
                int variavel_local = 0;
            }
        


        void outroMetodo()
        {
            int variavel_local = 0;
        }
    }

Arrays

São um conjuntos de dados do mesmo tipo atribuído a uma variavel.

unidimensional

vetores

Declarando array basta informar o tipo com colchetes de dados que o mesmo ira suportar, seguido do nome e depois o operador new informando o tipo com as posições dentro do colchete. 

    int nomeArray[] = new int[3];

Atribuindo valores;

Na criação: 
    int[] exemplo = new int[3]{0,1,2};
ou
    int[] exemplo = {0,1,2...};

↑ sem especificar o tamanho o mesmo sera preenchido na compilação de acordo com a quantidade de elementos declarados.

Declarando elementos: 
    int[] exemplo = new int[3];

    exemplo[0]= 0;
    exemplo[1]= 1;
    exemplo[2]= 2;

bidimensional

matrizes

A unica diferença é colocar uma virgula entre os colchetes depois do tipo, assim informando que a matriz ira conter dois números de índice respectivamente linhas e colunas. 

    int[,] exemplo = new int[2,3];

Na criação: 
    int[,] exemplo = new int[2,3]{{1,2,3},{4,5,6}};

Declarando elementos: 
    matriz[0,0]=1;
    matriz[0,1]=2;
    matriz[0,2]=3;
            
    matriz[1,0]=4;
    matriz[1,1]=5;
    matriz[1,2]=6;

Métodos para Arrays

Métodos que manipulam vetores ou matrizes.

Set Value

Insere um valor em uma posição de um conjunto de dados. 

    nome_vetor.SetValue("valor", 0);

Binary Search

Retorna a posição do elemento no tipo primitivo int. 

    int resposta = Array.BinarySearch(nome_vetor,valorProcurado);

Copy

Copia o conteúdo de um array para outro. 

    Array.Copy(nome_vetor,vetor_destino, tamanho);

Copy To

Copia o conteúdo de um array para outro. Mas este é a partir do vetor e não a partir do método Array.

    nome_vetor.CopyTo(vetor_destino, idexInicio);

Get Long Length

Retorna o tamanho de um conjunto de valores. 

    long elementosVetor = nome_vetor.GetLongLength(0);

Get Low Bound

Retorna a menor indice de um conjunto de dados. 

    int menorIndiceVetor = nome_vetor.GetLowerBound(0);
ou
    int menorIndiceMatriz = nome_matriz.GetLowerBound(1);

Get Upper Bound

Retorna a maior índice de um conjunto de dados. 

    int maiorIndiceVetor = nome_vetor.GetLowerBound(0);
ou
    int maiorIndiceMatriz = nome_matriz.GetLowerBound(1);

Get Value

Retorna a valores em formade objeto a partir do índice de um conjunto de dados. Por isso o Convert entra fazendo o do valor.

    int buscaVetor = Convert.ToInt32(nome_vetor.GetValue(2));
ou
    int buscaMatriz = Convert.ToInt32(nome_matriz.GetValue(0,2));

IndexOf

Retorna o índice do primeiro um elemento correspondente ao indicado nos parâmetros. 

    int buscaIndex = Array.IndexOf(nome_vetor,"elemento");

Last IndexOf

Retorna o índice do ultimo um elemento correspondente ao indicado nos parâmetros. 

    int buscaIndex = Array.LastIndexOf(nome_vetor,"elemento");

Reverse

Retorna o vetor com os itens na ordem invertida. 

    Array.Reverse(nome_vetor);

Sort

Retorna o vetor com os itens na ordem crescente. 

    Array.Sort(nome_vetor);

Para retornar a ordem decrescente organize e depoiis utilize o reverse.

Comentários

Para comentar uma linha use //.
Para comentar varias linhas abra com /* e feche com */.

Operadores

Aritimeticos

Relacionado a operações matemáticas.

Relacionais

Retorna um valor booleano.

Logicos

Une Operadores ou nega. ! nega. && todos verdadeiro. || um verdadeiro.

BitWise

Dobra ou gera Metade do valor manipulado. Os comandos são respectivamente << e >>.
A ordem do comando é variavel alterada operador bitwise seguido da quantidade de casas binárias a se manipular.

Ternarios

?caso verdadeiro :caso falso

Condicionais

if

Para decidir entre uma condição ou outra utilize a if.

Estrutura de seleção unilateral: 

    if (true)
    {
        comandos para verdadeiro();
    }

Por ter apenas uma opção pode ser marcada sem as chaves.
exemplo; 
    int x = 10;

    if(x > 2)
        x = 25;

else

Estrutura bilateral: 
    if ( TESTE )
        { Comandos caso verdadeiro }
    else
        { Comandos caso falso }

else if

Para aumentar a quantidade de verificações é só declarar o else if seguido do novo teste. 

    if ( TESTE1 )
        { Comandos caso verdadeiro }
    else if ( TESTE2 )
        { Comandos caso verdadeiro }
    else
        { Comandos caso falso }

Condições aninhadas

Consiste em incluir condições dentro de condições criando uma árvore de execução. 

    if(teste1)
    {

        if(teste1.1)
        {
            {

                if(teste1.1.1)
                {
                    (comandos caso verdadeiro) 
                }
                else
                {
                    (comandos caso falso)
                }
            
             }
        }
        else
        {
            (comandos caso falso)
        }
        
      }
    else
    {
        (comandos caso falso)
    }

Switch

Testa uma variavel e com os valores correspondentes as constantes das cases. Estrutura basica do switch: 

    char teste = 'y'

    

        switch(teste)
        {
            

                case 'x':
                    Console.WriteLine("valor selecionado foi x");
                    break;
            

            

                case 'y':
                    Console.WriteLine("valor selecionado foi y");
                    break;
            

            

                case 'z':
                    Console.WriteLine("valor selecionado foi z");
                    break;
            

            

                default:
                    Console.WriteLine("valor informado invalido"); 
                    break;
            

        }


Cada case deve terminar com um break a fim evitar a quebra de execução.

Go-to

Desvia a execução para um ponto especifico (label). Geralmente é usado estruturas de repetição.
A label é marcado com um nome simples seguido de ':' ex: nome:
Já a chamada é feita através do comando goto nome;
O mesmo pode ser colocado como opção através de um if etc...

Estruturas de Iteração

Propósito, repetir uma ação ou uma sequencia delas.

For

Utilização destinada a quando sei a quantidade de vezes que a ação deve ser repetida.
Estrutura: 

    for(contador;regra;incremento)
    {
        comandos ou ações a serem repetidas
    }
Exemplo pratico 
    for(int i=0; i < 9; i++)
    {
        Console.WriteLine("Contador correspondendo {0}", i);
    }

For Each

Ele itera itens de uma coleção e executa uma determinada ação.
Estrutura: 

    foreach(type cont_item in nomeArray)
    {
        comandos a serem executados
    }

While

Utilização destinada a quando não se sabe a quantidade de vezes que será repetido.
Estrutura: 

    int contador = y;
    while(contador < x)
    {
        contador ++
  ou        comandos...
        contador ++
    }

Do While

Utilização destinada a quando não se sabe a quantidade de vezes que será repetido, Porém garantindo que o comando será executado ao menos uma vez, já que o teste se encontra ao final.
Estrutura: 

    int contador = y;
    
    do
    {
        contador ++
  ou        comandos...
        contador ++
    }while(contador < x)

Métodos

São conjuntos de instruções que pode ser chamado a qualquer momento durante a execução de uma programa.
Métodos podem trabalhar a partir de paramentos de entrada, ou simplesmente retornam valores. 

        

    namespace aguradorInstruções
    {

        Class ModeloObjto
            {
            

                static void Main()
                {
                    Console.WhiteLine(operacao(1,2)); 
                }
            

            

                static int operacao(int n1, int n2)
                {
                    return = n1 + n2;
                }
            

            }

    }

resultado da operação >> 3

Passagem Referencia

Ao utilizar ref em parâmetro de operação esta sendo feito a indicação de qual memoria deve ser utilizada. Isso implicara diretamente na variavel de origem. 

        

    namespace aguradorInstruções
    {

        Class ModeloObjto
            {
            

                static void Main()
                {
                    int vExemplo = 9;
                    operacao(ref vExemplo);
                    Console.WhiteLine(vExemplo); 
                }
            

            

                static void operacao(ref int variavel) 
                {
                    variavel*=2;
                }
            

            }

    }

Argumento Out

O retorno só pode voltar um valor, o argumento out. 

        

    namespace aguradorInstruções
    {

        Class ModeloObjto
            {
            

                static void Main()
                {
                    int divid, divis, quoc, rest;
                    divid = 9;
                    divis = 2;
                    quoc = operacao(divid, divis ,out rest);
                    Console.WhiteLine("O quociente foi {0} e o resto {1}", quoc, rest);  
                }
            

            

                static int operacao(int dividendo int divisor, out int resto)  
                {
                    int quociente;
                    quociente = dividendo / divisor;
                    resto = dividendo % divisor;
                    return quociente;
                }
            

            }

    }

o resultado será: >> O quociente foi 4 e o resto foi 1

Argumento Params

Permite criar funções sem a necessidade de expressar todas os parâmetros de entrada. 

        

    namespace aguradorInstruções
    {

        Class ModeloObjto
            {
            

                static void Main()
                {
                    operacao(3, 6, 9...);
                }
            

            

                static void operacao(params int[] variavel) 
                {
                    int resultado;

                    if(variavel.Length > 0)
                    {
                        for(int i = 0; i < variavel.Length; i++) 
                        {
                            resultado+= variavel[i];
                        }
                    }
                    else
                    {
                        Console.WriteLine("Não existem parâmetros");  
                    }

                    Console.WhiteLine("O resultado foi {0}", resultado);  
                }
            

            }

    }


voltar