Aprender a programar em C# – Parte 1

Com o objetivo de levar um pouco do conhecimento de C# (C-Sharp) aos iniciantes em programação, estou iniciando uma nova série com o foco no aprendizado sobre a linguagem onde os iniciantes em programação acompanhar e aprender a programar em C#.
Iremos abordar alguns detalhes básicos sobre a linguagem tais como sintaxe, tipos de dados, variáveis, operadores, controle de fluxo e laços de repetição.

1 – Introdução

O C# (C-Sharp) é uma linguagem de programação orientada a objeto e fortemente tipada criada pela Microsoft e tendo como principal desenvolvedor Anders Hejlsberg (o mesmo criador do Delphi e Turbo Pascal) como parte do Framework .NET que se encontra na atualmente na versão 5.0. É uma linguagem influenciada pelo C++, Java e Object Pascal.

2 – Sintaxe

Um código em C# será armazenado sempre em um arquivo com extensão “.cs” como por exemplo FolhaDePagamento.cs ou ConexaoDados.cs. Dentro dos arquivos C#, poderemos ter várias ou nenhuma namespaces e dentro dessas uma ou mais classes. Vamos a alguns exemplos
01namespace Br.CSharpBrasil.MeuNamespace
02{
03    public class FolhaDePagamento
04    {
05        public FolhaDePagamento()
06        {
07 
08        }
09    }
10 
11    public class ConexaoDados
12    {
13        public ConexaoDados()
14        {
15 
16        }
17    }
18}
19 
20namespace Br.CSharpBrasil.OutroNamespace
21{
22    public class Faturamento
23    {
24        public Faturamento()
25        {
26 
27        }
28    }
29}
Em uma classe C#, poremos utilizar algumas modificadores de acesso como: public ou internal
  • public: Esse modificador quando definida na classe a torna acessível publicamente, ou seja, não existe restrição para acesso a classe.
  • internal: Ao aplicar esse modificador a uma classe, essa passa a ser acessível somente dentro do mesmo arquivo do nosso assembly, ou seja, nenhum outro poderá ter acesso a classe.
Veja o exemplo de uso dos modificadores.
01namespace Br.CSharpBrasil.MeuProjeto
02{
03    public class MinhaClasse1
04    {
05        public MinhaClasse1()
06        {
07 
08        }
09    }
10 
11    internal class MinhaClasse2
12    {
13        public MinhaClasse2()
14        {
15 
16        }
17    }
18}

3 – Tipos de dados

Agora que já conhece um pouco da estrutura de um arquivo C#, veremos os tipos de dados existente. Como mencionei anteriormente, o C# é uma linguagem fortemente tipada e possui alguns tipos de dados que poderemos utilizar para declara o tipo de nossas variáveis.
Nome Classe .NET Tamanho Intervalo
byte Byte 8 0 a 255
sbyte SByte 8 -128 a 127
int Int32 32 -2147483648 a 2147483647
uint Uint32 32 0 a 4294967295
short Int16 16 -32768 a 32767
ushort UInt16 16 0 a 65535
long Int64 64 -922337203685477508 a 922337203685477507
ulong UInt64 64 0 a 18446744073709551615
float Single 32 -3,4 x 10^28 a 3,4 x 10^38
double Double 64 ±5,0 x 10^-324 a ±1,7 x 10^308
char Char 16
bool Boolean 8 true ou false
object Object

string String

decimal Decimal 128 (-7,9 x 10^28 a 7,9 x 10^28) / (10^(0 a 28))

4 – Variáveis

Para a criação das variáveis, é importante seguir algumas regrinhas básicas na hora de dar um nome a elas:
  • Não utilizar palavras reservadas do C#: while, for, if, do, event, etc…
  • Não é permitido caracteres especiais, espaços
  • Utilizar somente _ ou letras ou números
  • Obrigatoriamente deverá iniciar com _ ou letras
  • O nome da variável deverá ser único no contexto que ela for declarada.
Vamos a alguns exemplo de declaração de variáveis:
1int contador = 890 ;
2double preco = 3210.74D ;
3bool existe = false ;
4string site = "csharpbrasil.com.br" ;

6 – Operadores

Os operadores são termos ou símbolos usados em uma expressão.
Categoria Operadores
Primários x.y, f(x), a[x], x++, x–, new, typeof, checked, unchecked, default(T), delegate, sizeof, ->
Unários +x, -x, !x, ~x, ++x, –x, (T)x, await, &x, *x
Aritméticos x * y, x / y, x % y, x + y, x – y
Shift (Troca) x << y, x >> y
Relacional x < y, x > y, x <= y, x >= y, is, as
Igualdade x == y, x != y
E lógico x & y
OU Exclusivo Lógico x ^ y
OU Lógico x | y
E Condicional x && y
OU Condicional x || y
Condicional ?:
Atribuição x = y, x += y, x -= y, x *= y, x /= y, x %= y, x &= y, x |= y, x ^= y, x <<= y, x >>= y
Null-coalescing ??
Lambda =>
Como já conhece os operadores, vamos a alguns de uso:
1/* OPERADORES ARITMETICOS */
2int x = 6 * 5 / 3; // Resultado = 10
3int y = 9 + 8 * 14; // Resultado = 121
4int z = 15 % 7; // Resultado = 1

7- Controle de fluxo

São instruções que controlam o fluxo da execução do programa de acordo com certas condições. Sem eles o código é executado do começo ao fim sem respeitar nenhuma condição. São eles:
  • if: É utilizada para verificar se um condição é verdadeira. Esse é utilizando em conjunto com alguns dos operadores citados anteriormente.
  • else: É utilizado quando a condição testada do controle if não é verdadeira. Esse também pode ser utilizado em conjunto com if
  • switch: Esse controle de fluxo testa um parâmetro passado comparando-o com as condições existentes e direciona a saída para um deles. Quando não existe nenhuma condição, ele direciona para uma saída padrão.
01int x = 2 * 3;
02int y = 15 / 3;
03 
04if (x >= 6)
05{
06    // Executada um instrução qualquer
07}
08 
09if (y > 10)
10{
11    // Executada um instrução qualquer
12}
13else
14{
15    // Executada um instrução qualquer
16}
17 
18switch (x % y)
19{
20    case 0:
21        // Executada um instrução qualquer
22        break;
23    case 1:
24        // Executada um instrução qualquer
25        break;
26    default:
27        // Executada um instrução qualquer
28        break;
29}

8- Laços de repetição

Os laços de repetição ou loops como são normalmente conhecidos, são instruções de interação que podem ser executadas um determinado numero de vezes, ou enquanto uma condição não for satisfatória ou até mesmo até quando ele for interrompida.
  • do: É executado enquanto uma determinada condição não é atendida
  • for: É executado um determinado numero de vezes
  • foreach: É executado em cima de uma matriz ou coleção, ou seja, percorre todos os elementos
  • while: É executado enquanto uma determinada condição não é atendida
01/* EXEMPLO DE EXECUÇÃO COM O LOOP "do" */
02int x = 0;
03do
04{
05    Console.WriteLine(x);
06    x++;
07} while (x <10);
08 
09/* EXEMPLO DE EXECUÇÃO COM O LOOP "for" */
10for(int y = 0; y < 10; y++)
11{
12    Console.WriteLine(y);
13}
14 
15/* EXEMPLO DE EXECUÇÃO COM O LOOP "foreach" */
16int[] l = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
17foreach(int i in l)
18{
19    Console.WriteLine(i);
20}
21 
22/* EXEMPLO DE EXECUÇÃO COM O LOOP "while" */
23int z = 0;
24while (z <10)
25{
26    Console.WriteLine(z);
27    z++;
28}
Até aqui você conseguiu ver ó básico da linguagem C#. Para que possamos mesmo começar a entender mais, no próximo artigo começaremos com a criação de um exemplo em C# criado em um editor de texto qualquer e compilando diretamente em linha de comando com o compilador csc para entender mais um pouco do funcionamento.
Até o próximo artigo e bons estudos!

Comentários

Postar um comentário

Postagens mais visitadas deste blog

Tutorial: Usando SQLite no Unity3D com C#

Imagem
Olá. Nesse tutorial veremos como usar banco de dados embarcados com Unity3D usando o SQLite. Um dos processos mais comuns em jogos e aplicações é o de salvar informações em algum lugar. Elas serão usadas mais tarde para, por exemplo, quando temos que salvar o estado do jogo para fecharmos o jogo. SQLite no Unity3D com C# É possível realizar esse processo de diversas formas, inclusive, no Unity3D existe a class PlayerPrefes entre outras formas que precisariam de mais alguma implementação. Essas soluções são muito boas e, em muitos casos, resolvem por completo a a maior parte das situações. Contudo, quando estamos falando de um jogo de RPG com muitos personagens, atributos, classes, etc, por exemplo, imagino que algo assim tão simples não seja a solução ideal. Uma boa opção para tais situações é usar banco de dados relacionais como o Sqlite que vai embarcado junto com o jogo e usa a linguagem Sql para realizar consultas. Então veremos como fazer a integração entre...
Leia mais

Criando um jogo multiplayer no Unity 3D com Photon Unity Networking – Parte 01

Imagem
Olá a todos desenvolvedores e interessados no mundo dos games! Nesta primeira série de artigos irei apresentar como trabalhar com o framework Photon Unity Networking (PUN) para a criação de jogos multiplayer desenvolvidos na famosa game engine Unity 3D. Abordaremos desde sua instalação até a troca de mensagens entre os jogadores, através da experiência que tive ao usá-lo. Criar um jogo multiplayer pode se tornar uma tarefa muito complexa. Existem inúmeras configurações complexas cliente/servidor a serem realizadas que acabam por estender em muito o tempo de desenvolvimento. Uma das grandes vantagens da game engine Unity é sua grande variedade de plugins que auxiliam o desenvolvimento, e em busca de um desses plugins para a criação de um multiplayer da versão digital do TRENCH, encontrei o Photon Unity Networking (PUN). O PUN, da desenvolvedora Exit Games, é um framework poderoso para a criação de jogos multiplayer em tempo real, tendo seu código otimizado e uma série de outro...
Leia mais

Tutorial: Utilizando Atributos no Unity3D

Imagem
Saudações, leitores, na publicação de hoje, diferentemente das semanas passadas onde escrevi artigo, trago dessa vez um tutorial onde estarei falando sobre o uso de atributos no Unity3D. Mas o que são esses atributos no Unity3D? Segundo o manual oficial da Unity: “Atributos são marcadores que podem ser colocados acima de uma classe, propriedade ou função em um script para indicar um comportamento especial.” Entretanto, seu uso mais corriqueiro é na declaração das variáveis e veremos ao longo do tutorial como utilizá-los e para o que serve cada um deles. Quais são? Vou relacionar aqui os que mais utilizo: Header(“Texto”) Space(10) Tooltip(“Texto”) ContextMenuItem(“Texto”, “Método”) Range(0,10) Multiline (5) ou Multiline HideInInspector SerializeField System.Serializable Para utilizá-los, em C#, é necessário colocá-los entre colchetes.  Ex: [Header(“Texto”)], [Space(10)], [Range(0,100)]. O atributo deve ir sempre uma lin...
Leia mais