Tag: C Sharp

Brackeys, the end.

O canal de youtube e comunidade do Brackeys vai terminar. Foi dos primeiros canais que segui já que tem vídeos muito interessantes para explicar o uso do Unity e assuntos correlacionados como é o caso da linguagem de programação c# ou de modelação de objectos.

Os vídeos e os outros canais de suporte vão ficar activos, apesar do projeto terminar.

+infos(listas no youtube): LINK

+infos(página oficial): https://brackeys.com/

Tags : , , ,

04_Introdução ao C# (pweb)

POO, princípios básicos:
abstração
herança
encapsulamento
polimorfismo

O mundo tem objectos que possuem características e comportamentos. Todos os objectos têm: estado (conjunto de propriedades de um objecto), comportamento (conjunto de acções sobre o objecto), unicidade (todo o objecto é único).

Objecto = Dados + Código
Dados -> comunica com -> atributos
Código -> comunica com -> métodos

nivel_acesso class nome_da_classe
{
        // bloco de instruções
}

um classe tem:
nivel_acesso: nível de proteção da classe ( internal/public ou abstract ou sealed)
pode existir uma class @override -> permite substituir qualquer coisa (por exemplo um método)
pode existir numa class o virtual -> permite sobrescrever qualquer coisa  (por exemplo um método)
e o new é usado para ocultar um determinado método

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            @override x = new @override();
            Console.WriteLine(x.Numero);
            Console.ReadKey();
        }
    }
    class @override
    {
        public int Numero { get; set; }
        public @override()
        {
            Numero = 5;
        }
    }
}

o this serve para nos referirmos ao próprio (variável, campo, método..) do objecto e não a algo “local”

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            Aviao a= new Aviao();
            Aviao b = new Aviao("USA");

            Console.WriteLine("Vem com o nome {0}", a.ONome);
            Console.WriteLine("Vem com o nome {0}", b.ONome);
            Console.ReadKey();
        }
    }
    class Aviao
    {
        public string ONome="TAP";

        public Aviao()
        {
        }

        public Aviao(string nome)
        {
            this.ONome = nome;

        }
    }
}

assim uma classe tem os seguintes membros:
variáveis (campos ou atributos(members fields));
métodos
propriedades (gets e sets)

Os atributos têm sempre um nível de protecção:
private (por defeito),
public (acedido a partir de outras classes ou métodos),
protected (acedido a partir da classe onde foi declarado e/ou classes derivadas),

protected internal (acedido a partir de uma classe onde foi declarado ou de classes derivadas)

Podemos também dividir as classes, usando a terminologia partial

As classes também têm um nível de protecção:
internal (por defeito, a classe acedida apenas no projeto),
public (acedida de qualquer parte),
abstract ou internal abstract (acedida apenas no projeto e não pode ser instanciada, apenas derivada de)
public abstract (acessível de qualquer parte e não pode ser instanciada, apenas derivada de)
sealed (acessível apenas no projeto, não pode ser derivada, apenas instanciada)
public sealed
O encapsulamento tem como objectivo principal ocultar de pormenores internos da classe. Para fora vão apenas os métodos (se for o caso). Normalmente essa implementação é feita usando getters e setters

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        //exemplo do encapsulamento
        static void Main(string[] args)
        {
            Aviao a= new Aviao();
            Aviao b = new Aviao();

            Console.WriteLine("Vem com o nome {0}", a.ONome);
            Console.WriteLine("Vem com o nome {0}", b.ONome);
            Console.ReadKey();
        }
    }
    class Aviao
    {
        private string nome = "TAP";
        public string ONome
        {
            get { return nome; }
            set { nome = value; }
        }
    }
}

Os métodos (funções dentro das classes) podem ter parâmetros, sendo que estes podem ser passados por valor, ou então por referência, ou uso do out.
O uso da referência (ref) permite actualizar uma variável.
Existe tambem o formato de out

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        //exemplo do ref
        static void Main(string[] args)
        {
            Contas a = new Contas();
            int numero = -3;
           Console.WriteLine("mostra resultados {0}", a.FazContas(ref numero));

            Console.ReadKey();
        }
    }
    class Contas
    {
        private int valor = 10;

        public int FazContas (ref int recebe)
        {
            if (recebe < 0)
            {
                valor = this.valor;
            }
            else
            {
                valor = recebe * recebe;
            }
            return valor;
        }
    }
}

Podemos também utilizar arrays, nomeadamente parâmetros como argumentos

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {

        //exemplo do arrays
        static void Main(string[] args)
        {
            Contas a = new Contas();
            int[] numeros = {1,2,3};

            Console.WriteLine("mostra resultados {0}", a.FazContas(numeros));

            Console.ReadKey();
        }
    }
    class Contas
    {
        public int FazContas (params int[] recebeArray)
        {
            int soma = 0;
            foreach (var r in recebeArray)
            {
                soma += r;
            }
            return soma;
        }
    }
}

É possivel passar “invocar” um função ou método dependendo dos valores dos argumentos que recebe

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        //exemplo do argumentos
        static void Main(string[] args)
        {
            Argumentos();
            Argumentos(texto:"Peter");
            Console.ReadKey();
        }
        static void Argumentos(int numero = 0, string texto = "Portugal")
        {
            Console.WriteLine("mostra resultados {0}, {1}", numero, texto);
        }
    }
}

O polimorfismo:
definição de métodos ou interfaces, que são genéricos e que podem ser implementados de diversas formas
Vantagens do polimorfismo:
reutilizar código;
tempo de desenvolvimento;
manutenção.
A herança:
permite reutilizar o código, permite a construção de classes baseadas noutras, sendo que a subclasse:
herda todas as propriedades e métodos da classe base;
pode incluir ou sobrepor novas propriedades e métodos.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PWEB_estudoCsharp
{
    class Program
    {
        //exemplo de herança
        static void Main(string[] args)
        {
            Filho f = new Filho();
            Console.WriteLine("mostrar {0}", f.Metodo2());
            Console.WriteLine("mostrar {0}", f.Metodo1());
            Console.ReadKey();
        }
        class Mae
        {
            private int numero = 10;
            public Mae() { }

            public int Metodo1()
            {
                return numero;
            }
        }

        class Filho:Mae
        {
            private int valor = 1;
            public int Metodo2()
            {
                return valor;
            }
        }
    }
}

Os membros da classe base, podem ser virtuais. A classe que herda uma classe com membros virtuais pode ser overridden pela classe que a herda, fazendo com que a classe derivada possa fornecer uma implementação alternativa para o membro.
O uso da palavra sealed evita que uma classe ou membros virtuais sejam herdados

uma classe base pode ser abstracta. É uma classe conceptual no qual se definem funcionalidades para as subclasses (que a herdam) e que possam implementá-las de forma não obrigatória.
se for estabelecido um método abstracto, então essa classe também o é. esse método não possui implementação na classe abstracta, apenas é e obrigatoriamente a sua definição e a implementação de ser feita na classe derivada.

Podem existir interfaces, usando a expressão interface
Todas as interfaces são publicas, os seus métodos não têm implementação, mas quem faz uso de uma interface tem que implementar as funcionalidades dos métodos.

Podem também tratar das excepções usando as expressões:
try
catch
finally
throw

Tags : ,

03_Introdução ao C# (pweb)

Acerca do C#:
arquitectura que faz uso de namespaces (uma classe que contem elementos, e que estes podem ser partilhados com outras classes)
recomendável instalar o ReSharper (https://www.jetbrains.com/)
todos os ficheiros têm extensão de .cs,
c# é case sensitive,
o compilador ignora os espaços vazios,
cada statement de C# termina com ponto e virgula,

using System; //namespace
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace csharp1
{
    class Program
    {
        static void Main(string[] args) //existe apenas um
        {
            string nome;
            Console.WriteLine("Olá Mundo!");
            Console.WriteLine("Qual o seu nome?");
            nome = Console.ReadLine();
            Console.WriteLine("Bem vindo {0}", nome);
            Console.ReadKey();
        }
    }
}

estrutura básica de um programa em c#:
tem vários namespace, como é o caso do using System;
contém um unico método chamado de main;
e no exemplo em cima:
vai escrever o Olá Mundo!
o método que faz esta acção é o WriteLine
Este método pertence ao objeto System.Console
Static, porque indica que o método Main pode ser chamado mesmo que não haja instância da classe

Nas variáveis podem ser usados literais: inteiros (L, long), reais (f, float)..

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace chsarp_v0
{
    class Program
    {
        static void Main(string[] args)
        {
            int numero = 24;
            string texto = "Pedro deste lado";

            Console.WriteLine($"{texto} {numero}");
            Console.ReadKey();
        }
    }
}

Enumerações (enums) permitem declarar uma lista de constantes

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace chsarp_v0
{
    class Program
    {
        enum DiaFutebol : int
        {
            sextafeira = 0,
            sabado = 1,
            domingo = 2
        };
        static void Main(string[] args)
        {
            DiaFutebol DiaF = DiaFutebol.sextafeira;
            Console.WriteLine($"Dia de futebol {0}", DiaF);
            Console.ReadKey();
        }
    }
}

As estruturas:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

struct Aviao
{
    private string cor;
    public Aviao(string cor)
    {
        this.cor = cor;
    }
    public string Cor
    {
        get { return cor; }
        set { cor = "verde"; }
    }
    public string Descricao()
    {
        return "Cor de um avião = " + cor;
    }
}
namespace chsarp_v0
{
    class Program
    {   
        static void Main(string[] args)
        {
            Aviao aviao;
            aviao = new Aviao("Preto");
            Console.WriteLine(aviao.Descricao());
            Console.ReadKey();
        }
    }
}

Os arrays:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace chsarp_v0
{
    class Program
    {   
        static void Main(string[] args)
        {
            int[] numeros = {1, 2, 3, 4, 5, 6, 7, 8, 9};
            Console.WriteLine("\\-primeira versão:");
            for (int i = 0; i < numeros.Length; i++)
            {
                Console.WriteLine("informacao {0}", numeros[i]);
            }
            Console.WriteLine("\\-segunda versão:");
            foreach (var anda in numeros) 
            {
                Console.WriteLine("informacao {0}", anda);
            }
            Console.ReadKey();
        }
    }
}
Tags : ,