Olá a todos, este é o meu primeiro post de muitos (espero eu) em que vos vou falar de programação em C#. Porquê C#? Porque é sem duvida a mais robusta e que irá ser o futuro da programação (nem que seja pelo facto de ser semelhante a C e Java, o que facilita a migração dessas tecnologias para .NET).
Neste primeiro post vou-vos falar do básico e das bases da linguagem C#. Vai ser uma revisão rápida e concisa porque o objectivo destes posts não será falar do básico mas sim do intermédio ao avançado.
O C# é uma linguagem Orientada a Objectos que permite herança, polimorfismo, encapsulamento, interfaces… etc.
- Orientada a objectos: É um paradigma de programação que usa objectos (instâncias de classes) que interagem entre si. Cada classe (como serão tratadas a partir daqui) determina o comportamento (definido nos métodos) e estados possíveis (atributos) dos seus objectos, assim como o relacionamento com outros objectos.
- Herança: Permite que as classes filhas (derivadas de outra classe) herdem e /ou estendam as funcionalidades da classe mãe. Como os seus métodos e atributos.
Atenção que o C# apenas permite uma herança de classe mãe mas permite herança de múltiplos interfaces.
- Polimorfismo: é o princípio pelo qual duas ou mais classes derivadas de uma mesma classe mãe podem invocar métodos que têm a mesma assinatura (lista de parâmetros e retorno) mas comportamentos distintos que são definidos na classe filha.
- Encapsulamento: consiste na separação de aspectos internos e externos de um objecto. Este mecanismo é utilizado amplamente para impedir o acesso directo ao estado de um objecto (aos seus atributos), disponibilizando externamente apenas os métodos que alteram estes estados. Vamos falar mais á frente de propriedades.
- Interfaces: é um contrato entre a classe e o mundo externo. Quando uma classe implementa uma interface, ela está comprometida (obrigada) a fornecer o comportamento especificado pela interface.
Depois desta explicação genérica de uma linguagem de programação orientada a objectos vou-vos falar dos tipos específicos de C#. O c# divide-se em dois tipos que são muito importantes para o que queremos atingir, existem os tipos de valor e os referência.
Tipos valor: estas variáveis contem os seus dados directamente, cada variável contém a sua cópia dos dados. Estas variáveis são guardadas na Stack (memoria mais rápida) e são automaticamente destruídas quando saem do scope (bloco de execução). Ex: Todos os simples (int, byte, short, double, bool, etc… ) e Structs e enumerators.
Tipos referência: Estas variáveis não contem os dados directamente mas apontadores para eles. Duas variáveis distintas podem apontar para os mesmos dados. Estes dados são guardados na heap (mais lenta) e são destruídos num processo chamado garbage collector. Ex: String, Arrays, Classes, Delegates.
Static vs Instance: Um método static não pode ser instanciado, pode ser acedido directamente sem usar a palavra new e só permitem ter dentro do seu bloco membros estáticos por ex: a função String tem o método estático Format.
Os métodos instance têm obrigatoriamente de ser instanciados com a palavra new por ex: MinhaClasse nome = new MinhaClasse(); Os métodos instanciados podem conter variáveis estáticas.
Um bom exemplo seria colocar uma variável global a classe estática e incrementar essa variável sempre que se instanciasse a classe, assim teríamos um contador de quantas vezes instanciamos a classe.
• Mãos á obra
Declarar variáveis: As variáveis em c# são declaradas como “tipo nome”. Atenção que o c# é case sensitive.
int numero; string texto;
Arrays: Os arrays como vimos em cima são tipos de referencia logo só guardam uma copia do seu valor. E são “zero indexed” começam no zero.
int[] numero; int[] numero = new int[10]; // array com 10 elementos int[,] numero = new int[5,4]; // array multidimensional 2 dimensões neste caso. Int[][] numero = new [5][4]; // array de arrays ou jagedd array.
Outros exemplos de inicialização de arrays:
int[] numero = new int[] {1, 2, 3, 4, 5}; //array com 5 elementos int string[] nome = new string{“ola”,”pplware”}; // array com 2 elementos string int[,] numeros = new int[,] { {1, 2}, {3, 4}, {5, 6} }; // array multidimensional
Instanciar objectos: para instanciar um objecto utiliza-se o nome da classe e depois o nome que queremos dar ao objecto.
NomeClasse meuNome = new NomeClasse();
Isto funciona assim se a classe tiver o default constructor. Caso tenha mais construtores poderia ficar assim:
NomeClasse meuNome = new NomeClasse(parametro);
O parâmetro é uma variável que estou a passar ao construtor da classe NomeClasse.
Quanto ás keywords, loops, etc e para não me vou alongar mais vejam este documento que tem lá tudo acerca disso e até uma comparação entre c# e vb.Net.
• Primeiro programa: O compilador que vou usar para os meus exemplos vai ser o VisualStudio, a minha versão é a Professional que me foi dada pela aliança académica, se não tiverem podem usar a versão Express. Pode ser o 2005 ou 2008.
O fantástico HelloWorld.
Abram o visual studio e façam File- New-Project, escolham console aplication (ainda não vamos para forms hoje).
No topo do projecto estão as importações de Namespaces que vamos utilizar neste projecto: using System; Permite usar a Classe Console directamente se não tínhamos de escrever System.Console sempre que quiséssemos aceder a essa classe.
Depois vemos o Namespace do projecto serve para identificar o nosso projecto. Mais tarde veremos a sua utilidade.
Temos a nossa class e lá dentro o método Main, todos os projectos em C# começam no método Main, em Windows forms não o vemos porque começamos com a form que é uma partial class que por trás contem o Main. (Depois vemos isto tudo).
O Main é sempre static e pode ou não levar parâmetros neste caso recebemos um array de strings com o nome args string[] args (mais abaixo vamos utiliza-lo).
Num projecto deste género nós temos acesso á classe Console e com ela podemos escrever e ler na consola do Dos. Agora a única coisa que temos de fazer é escrever Console.WriteLine(“Hello World”); Para podermos ver alguma coisa convém também escrever Console.ReadLine(); Assim o processo para e fica á espera de um input nosso. Agora carreguem no f5 e vejam o vosso hello world. Simples não?! Mas pouco interessante.
Vamos a um mais interessante que tal uma calculadora? Esta calculadora poderia ser feita dentro do programa a pedir valores mas como quero mostrar os argumentos vai ser um pouco diferente, como eram antigamente os comandos de MS-DOS.
Usando o mesmo projecto limpem o código Console.WriteLine(“Hello World”);
int a=int.Parse(args[0]); criamos uma varivel inteira que recebe o primeiro valor que vamos escrever e converte-o para inteiro caso contrario haveria um erro a dizer que não pode converter string em inteiro. int b = int.Parse(args[2]); fazemos o mesmo para o terceiro parâmetro int c=0; e outra variável inteira que vai conter o resultado final e é inicializada a 0.
Depois fazemos um switch com o valor que esta na segunda posição ou seja o operador, e vamos verificar (lembrem-se que este valor é uma string) qual é o texto do operador quando corresponder fazemos a operação.
Os switch tem de ter sempre um break para parar a execução em todos os blocos case. switch (args[1]) { case “+”: c = a + b; break; case “-“: c = a – b; break; case “*”: c = a * b; break; case “/”: c = a / b; break; default: break; } No fim mostramos o valor Console.WriteLine(c.ToString()); Como o “c” é uma variavel inteira temos de utilizar o método estático ToString() para a converter em string.
Para correr o programa precisamos de abrir a linha de comandos MS-DOS e ir ate á directoria onde esta o ficheiro executável, no meu caso está nos meus documentos C:\Documents and Settings\adminpclocal\My Documents\Visual Studio 2005\Projects\HelloWorld\HelloWorld\bin\Debug
Depois corrar o executavel no meu caso HelloWorld.exe e escrevam os valores e operação á frente por ex:
HelloWorld.exe 5 * 2 (tem de ter espaços a separar) Carrega-se no enter e vê-se o resultado.
E pronto já tem uma calculadora, arcaica é certo mas ainda estamos no começo.
Conclusão: Espero que tenham gostado do post este como disse no inicio foi básico mas vai ser útil para o futuro. No próximo post já vai ser mais puxado e vamos começar a trabalhar com Windows forms, vamos fazer uma classe uma struct e ver as diferenças, uns eventos, aceder e manipular ficheiros e claro uns programinhas.
Então obrigado a todos e ate breve.