Continuando nosso curso de C#, aprenderemos agora sobre Vetores, Enumeração e Listas.

Na mundo real muitas vezes precisamos representar várias coisas para uma mesma finalidade, por exemplo:

  • Representar uma sequência de números inteiros: 1, 5, 10, 55, 65, 80, 99
  • Representar uma enumeração de cores: verde, amarelo, azul, vermelho
  • Representar uma lista de compras: arroz, batata, sabão, peixe

Na programação também é desta forma:

Vetores

Vetores, ou arrays, são uma coleção de variáveis. Podemos usar um vetor da seguinte maneira:

int[] números = new int[8];
números[0] = 1;
números[1] = 5;
números[2] = 10;
números[3] = 55;
números[4] = 65;
números[5] = 80;
números[6] = 99;
números[7] = 106;

// ou então podemos fazer simplesmente assim:
int[] números = new int[] {1, 5, 10, 55, 65, 80, 99, 106 };

declaramos uma variável chamada números do tipo vetor de inteiros e a inicializamos com uma coleção de 8 números.

Podemos então obter qualquer número desta sequência desta forma:

int a = numeros[0] // a será 1
int b = numeros[1] // b será 5
int c = numeros[5] // c será 80

Uma técnica muito utilizada com vetores é a iteração, veja como usar:

//Este exemplo cria um novo vetor que receberá os valores pares do primeiro vetor:
int[] números2 = new int[3];
for (int i = 0; i < números.Length; i++)
{
      if (números[i] % 2 == 0)
            números2[i] = números[i];
}

Matrizes

Matrizes, (matrix), são vetores de duas dimensões:

int[,] matriz = new int[,]  {
      {1, 5} {10,55} {65,80} {99, 106}
};

Enumerações

Enumerações são um tipo particular no C#. Usamos para criar uma série de dados para tornar nossa programação mais fácil. A vantagem de se utilizar enumerações em c# e não uma coleção de Strings é que podemos utilizar o intellisense do Visual Studio para tornar o código mais seguro e consequêntemente consome também menos memória.

enum cores { amarelo, verde, vermelho, azul };

public void ObtemCor(cores cor)
{
      switch (cor)
      {
         case cores.amarelo:
            MessageBox.Show("amarelo");
         break;
         case cores.verde:
            MessageBox.Show("verde");
         break;
         case cores.vermelho:
            MessageBox.Show("vermelho");
         break;
         case cores.azul:
            MessageBox.Show("azul");
         break;
         default:
         break;
      }
}

Listas

Lista é algo extremamente prático de se trabalhar. Com listas podemos adicionar e remover dados se ter que preocuparmos com sua posição.

List<string> nomes = new List<string>();
nomes.Add("Amanda");
nomes.Add("Roberto");
nomes.Add("José");
nomes.Add("Fred");
nomes.Add("Joana");
// ou então podemos fazer simplesmente assim:
List<string> nomes = new List<string>(){
      "Amanda", "Roberto", "José", "Fred", "Joana"
};

Podemos percorrer facilmente esta lista, sem precisarmos saber a posição do item, com um for aprimorado:

foreach (var item in nomes)
{
      MessageBox.Show(item.ToString());
}

É isto aí pessoal, no próximo artigo aprederemos algumas coisas muito importantes sobre Strings. Até lá!

Curso de Programação em C# – parte 8 – Métodos

Publicado: 31 de outubro de 2010 por Junio Albino em Cursos
Tags:, , ,

Se você chegou até aqui quer dizer então que já passou por este caminho:

Curso de Programação em C#

  1. Parte I – Introdução
  2. Parte II – C#
  3. Parte III – Meu Primeiro Programa
  4. Parte 4 – Codificando
  5. Parte 5 – Variáveis e Tipos
  6. Parte 6 – Operadores
  7. Parte 7 – Estruturas de Controle

Médotos são ações que executamos.

Em outras linguagens, como C++, um método também é chamado de função. Os métodos têm capacidade de receber parâmetros, processar alguma tarefa e retornar algum valor. Vamos ver mais de perto para que servem e como funcionam os métodos.

Na programação não é uma boa prática repetirmos código, ao contrário, devemos reutilizar o máximo possível, para isso servem os métodos, que são blocos de código que podem ser chamados sempre que necessário.

Um método deve ter um tipo de retorno, um nome, os parâmetros (se houver), o corpo (onde é processado o código) e o retorno (quando houver).

Este é um exemplo de um método que não obtêm e nem retorna nenhum valor:

void mostraMensagem()
{
      string mensagem = "Olá Mundo!";
      MessageBox.Show(mensagem + " em c#");
}

Observe que criamos um método chamado “mostraMensagem”, assim podemos chamá-lo pelo seu nome, seguido dos parênteses, quantas vezes quizermos, sem precisarmos repetir o conteúdo do mesmo, assim:

mostraMensagem();
mostraMensagem();
mostraMensagem();

o seguinte método obtêm um valor mas não retorna nada:

void atribuiValor(int b)
{
      int a = b;
}

o seguinte médodo retorna um valor (observe que usamos a plavra “int” antes do nome para especificar que o método retorna um valor do tipo inteiro):

int retornaA()
{
      int a = 10;
      return a;
}
  • Métodos que não recebem parâmetros ficam com os parênteses vazios
  • Métodos que recebem parâmetros devem tê-los declarados dentro de parênteses
  • Métodos que não retornam nada devem ser assinados com a palavra void
  • Métodos que retornam alguma coisa devem usar a palavra return e declarar seu tipo de retorno

Exemplo de um método que recebe dois parâmetros do tipo inteiro, os soma e retorna o resultado que também é do tipo inteiro:

// Declaração do método
int soma(int x, int y)
{
      return x + y;
}

// e para chamar o método
int a = 2;
int b = 3;
int resultado = soma(a, b); // o resultado será 5

Sobrecarga de Métodos: podemos também usar o mesmo nome para dois métodos diferentes quando estes têm um compartamento semelhante:

// soma 2 números
int soma(int a, int b)
{
      return a + b;
}

// soma 3 números
int soma(int a, int b, int c)
{
      return a + b + c;
}

No C# temos também métodos com parâmetros opcionais e nomeados:

//Parâmetros nomeados
int Somar(int x, int y)
{
      return x + y;
}

// Chamando o método
Somar(x: 1, y: 2);

//Parâmetros Opcionais

static int Somar(int x, int y=2)
{
      return x + y;
}

//note que iremos passar só o valor de X e não de Y (que irá assumir o valor 2)
int resultado = Somar(x:1); //resultado será 3

//Não se pode colocar um parâmetro opcional na frente de um não opcional assim:
int Somar(int x=2, int y)
{
      return x + y;
}

É isso aí pessoal, no próximo post aprenderemos sobre Vetores, Enumerações e Listas.

Se você chegou até aqui quer dizer então que já passou por este caminho:

Curso de Programação em C#

  1. Parte I – Introdução
  2. Parte II – C#
  3. Parte III – Meu Primeiro Programa
  4. Parte 4 – Codificando
  5. Parte 5 – Variáveis e Tipos
  6. Parte 6 – Operadores

Agora vamos aprender algumas coisas bem legais na programação que são as estruturas de controle, sem elas a programação não seria nada, aliás são as estruturas que dão uma lógica à programação.

Para entendermos este capítulo devemos fazer um comparativo de um programa com algumas ações e decisões que tomamos no mundo real.

Como exemplo vamos visualizar nosso ambiente do que fazemos quando acordamos:

  1. Acordamos
  2. Levantamos da cama e calçamos nossas pantufas :S
  3. Escovamos os dentes
  4. Se o café estiver pronto, o tomamos (nem sempre nossa mãe ou esposa acorda antes de nós…)
  5. Senão, vamos pentiar o cabelo e vestir a roupa enquanto o fazem para nós
  6. Tomando o café colocamos açúcar na xícara (nossa mulher, ou mãe, toma o café com adoçante…)
  7. Acrescentamos 4 colheres de açúcar ao café porque gostamos dele bem doce.
  8. Damos um beijo em nossa mãe ou mulher e vamos para o trabalho.
  • Veja que no nosso dia-a-dia não fazemos as coisas linearmente como se tudo fosse perfeito.
  • Lidamos com situações inesperadas e temos que tomar decisões diferente conforme o caso.
  • Precisamos repetir ações até que alguma condição seja satisfeita.

A programação também segue essa linha de raciocínio. Vamos conciliar agora o mundo real com a programação. Veja o seguinte pseudo-código:

se café estiver pronto
tomamos café
senão
vamos vestir a roupa

podemos representar este caso no C# assim:

if(caféPronto == true)
{
    tomamosCafé();
}
else
{
    vestimosRoupa();
}
  • O “if” significa “se” e o “else” significa “senão“.
  • true” significa “verdadeiro” enquanto “false” significa “falso” (óbvio…).
  • Os parênteses depois de “tomamosCafé” e “vestimosRoupa” indicam ações.

A linha “if(caféPronto == true)” pode ser substituída por “if(caféPronto)” pois sendo a variável caféPronto booleana não há motivos para acrescentar “==true”

Vejam o seguinte caso, executamos uma ação enquanto outra não é satisfeita:

enquanto café não está pronto
vestimos roupa

no C# ficará assim:

while(café != pronto)
{
    vestimosRoupa();
}

E na repetição temos:

colocamos 1 colherer de açúcar de cada vez até colocarmos 4

em c#:

// Este bloco de código irá ser executado 4 vezes
for(int i = 0; i < 4; i++)
{
    acrescentamosAçúcar();
    provamos();
}

Note que neste bloco for nós declaramos uma variável do tipo inteira chamada i e a iniciamos com o valor 0, enquanto a variável i for menor que 4 ela teria seu valor incrementado por mais uma unidade.

Você também pode parar a execução de um de loop for ou while com as palavras-chave break ou continue assim:

// Nunca executa a ação FacaAlgo()
for(int i = 0; i < 10; i++){
    if(i == 0) break;
    FacaAlgo();
}
// Executa a ação FacaAlgo() apenas uma vez
for(int i = 0; i < 10; i++){
    if(i == 0) continue;
    FacaAlgo();
}

Neste post aprendemos um dos recursos que toda linguagem de programação tem que são as Estruturas de Controle.

No próximo artigo iremos aprender sobre métodos.

Curso de Programação em C# – parte 6 – Operadores

Publicado: 31 de outubro de 2010 por Junio Albino em Cursos
Tags:, ,

Se você chegou até aqui quer dizer então que já passou por este caminho:

Curso de Programação em C#

  1. Parte I – Introdução
  2. Parte II – C#
  3. Parte III – Meu Primeiro Programa
  4. Parte 4 – Codificando
  5. Parte 5 – Variáveis e Tipos

Operadores são símbolos que usamos na programação para diversas coisas, tais como:

  1. Fazer cálculos matemáticos
  2. Resolver questões de lógica
  3. Relacionar e comparar valores
  4. Atribuir valores a uma variável

Os operadores de cálculos matemáticos são:

  • Soma (+)
  • Subtração (-)
  • Multiplicação (*)
  • Divisão (/)
  • Módulo ou resto da divisão (%)

Ex:

int x = 1 + 2; // x será 3
double y = 3 / 2; // y será 1.5
int z = 5 / 2; // z será 1

Operadores lógicos:

  • E (&&)
  • Ou (||)
  • Não (!)

Ex:

if(x = 2 && y = 3)... // irá executar o comando se x for igual a dois e se y for igual a 3
if(x = 2 || y = 3)... // irá executar o comando se y for igual a dois ou se y for igual a 3
if(!(condiçãoVerdadeira))... // irá executar o comando se a condição não for verdadeira

Operadores de Relação:

  • Igual (==)
  • Diferente (!=)
  • Menor que (<)
  • Maior que (>)

Ex:

if(a == b)... // irá executar o comando se o valor de a for igual ao valor de b
if(a > b)... // irá executar o comando se o valor de a for maior que o valor de b

Operador de Atribuição

  • =
a = 2; // atribui o valor 2 à variável a

Cuidado! É muito comum o programador confundir o operador de comparação “==” com o de atribuição “=”.

Podemos também usar o parêntese para operações mais complexas, que necessite dar, por exemplo, preferência para os sinais de “+” ou “-” sobre os operadores “*” ou “/”, veja um exemplo:

int x = (a + b) / (c - d);

OBS: Não se esqueça dos tipos ao fazer cálculos. Para facilitar o C# faz várias conversões automaticamente:

Ex:

int x = 5 / 2;
// x será 2 e não 2.5, pois uma variável inteira só pode receber valores inteiros
// e o C# é inteligente o suficiente para não tentar colocar um valor decimal numa variável inteira

E ao invés de:

int a = 2;
a = a + 2;

podemos simplificar as coisas assim:

int a = 2;
a += 2;

Assim fica mais legal, não acha?

E para finalizar, o C# tem alguns recursos legais para facilitar nossa vida. Um deles é o operador de incremento “+ +” e o de decremento “- -“. Eles são úteis quando você quer incrementar uma unidade a uma variável.

Ex:

int a = 2;
int b = ++a; // a será igual a 3, ou seja, a = a + 1 e b será igual a 3;
int c = a++; // a será igual a 4, enquanto c será igual a 3, pois o valor de a foi atribuído a c antes do incremento

E o decremento é simplesmente o contrário, ou seja, ao invés de somar ele subtrai.

O C# possui muitos outros operadores, mas desta vez vamos aprender só estes mesmo, afinal não podemos guardar na mente tudo que existe sobre um assunto não é mesmo?

Até a próxima – Estruturas de controle

Resenha baseada no texto de Mauro Sotille

A era da internet veio para mudar a maneira como são feitos negócios e projetos numa empresa, o processo que antes era feito de maneira linear hoje é feito de forma paralela, onde várias atividades são feitas ao mesmo tempo entre várias pessoas, conectadas entre si por meio da tecnologia da informação.

Devido à complexidade da abstração proporcionada pela internet, as empresas tem encontrado muitas dificuldades diante da implementação de projetos que se baseiam ou utilizam estas novas formas de fazer negócios.

Assim, nota-se a necessidade de que os gerentes de projeto estejam preparados para lidar com tal situação, por exemplo, muitas vezes este profissional deve entender a real necessidade do cliente não apenas pelo que este diz, mas vendo o problema de uma forma bem mais ampla, pois muitas vezes o cliente não expressa ao certo o que quer, e em conseqüência disso o resultado pode não ser o que ele esperava, gerando assim insatisfação geral de ambas as partes quando o projeto estiver pronto.

Diante desta nova era da internet a comunicação tem um papel muito importante nos projetos, assim como uma integração maior entre os setores da empresa com a área de TI, pois em muitos casos é isto que faz diferença entre a ascensão e a queda de uma organização.

Voce ja viu:
Desenvolvimeto de Software – Introdução

As metodologias tradicionais também conhecidas por metodologias pesadas ou orientadas a documentação surgiram em um contexto de desenvolvimento de software muito diferente do atual onde a estrutura computacional baseava-se em mainframes e terminais burros.

O acesso aos computadores ainda era muito limitado o que tornava o custo de alterações e correções muito alto, além de não existirem ferramentas de apoio ao desenvolvimento do software, como depuradores e analisadores de código.

Por esses motivos os softwares eram planejados e documentados em sua totalidade antes de se iniciar o processo de implementação. A principal metodologia tradicional e que ainda é muito utilizada atualmente é o modelo Clássico.

O modelo Clássico foi o primeiro processo de desenvolvimento de software publicado e pode ser descrito como sendo um conjunto de etapas sequenciais onde ao termino de cada etapa é elaborado um documento padrão que deve ser aprovado antes que se inicie a etapa seguinte. Compõem o modelo Clássico as etapas de definição de requisitos, projeto do software, implemetação e teste unitário, integração e teste do sistema, operação e manutenção.

Modelo Clássico

Esta divisão em etapas distintas ou inflexibilidade da metodologia é vista como um problema por dificultar possíveis alterações que são comuns no desenvolvimento de projetos. Por esse motivo é recomendável que metodologias tradicionais sejam aplicadas apenas em situações em que os requisitos do software são estáveis e requisitos futuros possam ser previsíveis.

Quando se fala em desenvolvimento de software você não sabe que caminho seguir? Está confuso sobre como deve começar, conduzir e finalizar o processo de desenvolvimento do seu SW?

Tipos de Desenvolvimento

Parabéns, você não é de outro mundo, essa dúvida é normal. Se você aprendeu a desenvolver a partir de um curso ou de um livro (e principalmente se isso já faz algum tempo) provavelmente você conhece o “Método Tradiconal” também chamado de sequencial.

Iniciaremos uma discussão sobre desenvolvimento de softwares sob os paradigmas da metodologia tradicional e metodologias ágeis. O objetivo não é dizer a você qual método de desenvolvimento de SW usar  mas sim mostrar diferenças entre os métodos mais populares para clarear suas ideias e permitir que você mesmo escolha como irá desenvolver seus softwares.

Computação Distribuída

Publicado: 12 de setembro de 2010 por Junio Albino em Sistemas de Informação
Tags:,

A Computação Distribuída é uma arquitetura de sistemas de informação que possibilita que seus recursos estejam separados entre si, em máquinas diferentes em um mesmo local físico ou até em distâncias maiores, como entre um continente e outro.

Um Sistema de Informação pode ter seus artefatos, ou código-fonte, divididos em camadas. Estas camadas podem ser duas, três, ou “N” camadas – termo utilizado para quando há mais de três.

Uma das arquiteturas amplamente utilizadas, em 3 camadas, é o padrão MVC – abreviatura de Model, View e Controller, ou Modelo, Visão e Controle.

Uma das principais vantagens de se utilizar a Computação Distribuída é o sistema ter a capacidade de escalabilidade, ou seja, a habilidade de ser escalável, ou de poder ter suas características ampliadas de acordo com as necessidades.

Já problemas da escalabilidade estão ligados à perda de desempenho que geralmente acontece neste tipo de sistema. E deve-se ter atenção a este ponto, pois, alguns sistemas devem funcionar em tempo real, sendo que um delay (atraso) poderia acarretar em prejuízos grandes. Outro problema é o tipo de comunicação, na computação distribuída deve-se dar preferência à assíncrona (não sincronizada) e não a síncrona (sincronizada).

Para alguns tipos de sistemas deve-se ter um cuidado especial ao distribuir, devido à questão de segurança. Pois, quanto mais distribuído for um sistema, maior o risco da segurança envolvida.

A computação distribuída pretende resolver os problemas referentes à computação centralizada, como por exemplo o fato de o sistema inteiro ficar inacessível devido a uma máquina não estar disponível.

Várias técnicas são utilizadas na computação distribuída, exemplo: servidores de banco de dados que fazem replicação, para que, se uma máquina ficar desativada os outros servidores tomem conta do sistema imediatamente.

O futuro da computação distribuída pode ir além do que possamos imaginar, desde um marca-passo conectado via wireless ao servidor de um hospital, avisando sobre uma alteração no batimento cardíaco de um paciente, até um sistema onde a geladeira de uma casa ao detectar a falta de um item, como carne ou frutas, envia um SMS para o proprietário, para que ele faça as compras.

A computação distribuída não irá substituir todos os atuais sistemas centralizados, mas já provou que tem seu valor no presente e terá muito mais no futuro.

Curso de Programação em C# – parte 5 – Variáveis e Tipos

Publicado: 21 de agosto de 2010 por Junio Albino em Cursos
Tags:, , ,

Se você chegou até aqui quer dizer então que já passou por este caminho:

Curso de Programação em C#

  1. Parte I – Introdução
  2. Parte II – C#
  3. Parte III – Meu Primeiro Programa
  4. Parte 4 – Codificando

Variáveis são um lugar na memória do computador onde ficam guardados dados que utilizamos. Todo programa utiliza variáveis.

Podemos imaginar uma variável como uma caixa onde ficam guardados coisas que usamos. Existem variáveis de vários tipos assim como existem caixas de todos os tamanhos. Os tipos mais comuns de variáveis são:

  • Caractere: só para um caractere, tipo letra, número ou símbolo – Representado entre aspas simples
  • Palavra: uma palavra inteira com letras números e símbolos – Representado entre aspas duplas
  • Número Inteiro: números inteiros, exemplo: -2 e 10.000 – Representado sem ponto
  • Número Real: número de ponto flutuante, exemplo: 35,10 e 50,0001 – Representado com ponto no lugar da vírgula
  • Verdadeiro ou Falso: tipo binário, exemplo: true e false

Para usarmos variáveis devemos seguir os seguintes passos.

  1. Declarar o tipo da variável
  2. Dar um nome a ela
  3. Atribuir a ela algum valor

OBS: existem palavras reservadas no C# que não podemos usar como nome de variáveis, também só podemos inicializar o nome de uma variável com letra ou o sinal underline “_”

Os tipos do C# tem palavras-chave já definidas que são respectivamente:

  • char
  • string
  • int
  • double
  • bool

Estes tipos de variáveis são chamados “tipos primitivos”, existem também os “tipos de referência” que aprenderemos mais tarde.

Quando uma variável não tiver nenhum valor dentro dizemos que ela é null, ou seja, nula.

Veja como utilizar variáveis:

  1. Crie um novo projeto e inclua no form um botão
  2. Dê dois cliques no botão para que a IDE gere o evento Click
  3. Digite o conteúdo das linhas 21 a 23 dentro do método button1_click
  4. Depois execute o projeto
19.    private void button1_Click(object sender, EventArgs e)
20.    {
21.       string mensagem;
22.       mensagem = "Olá mundo usando variáveis!";
23.       MessageBox.Show(mensagem);
24.    }

Veja o que fizemos:

  1. Declaramos uma variável do tipo string chamada mensagem (linha 21)
  2. Atribuímos a esta variável o valor: “Olá mundo usando variáveis!(linha 22)
  3. E mandamos exibir o conteúdo desta variável para o usuário. (linha 23)

Desta forma podemos usar a variável em outros lugares e atribuir outros valores a ela.

Dica: Cada variável ocupa um espaço na memória, então utilize-as sempre de acordo com a necessidade. Ou seja, não utilize um tipo double se precisar apenas de um tipo inteiro e não declare mais variáveis do que o necessário.

Veja na tabela abaixo os tipos suportados pelo C# e suas características:

Pro C# 2010 and the .NET 4.0 Platform, Fifth Edition

Podemos atribuir também o valor de uma variável a outra:

19. private void button1_Click(object sender, EventArgs e)
20. {
21.    string mensagem1 = "Este é o valor da mensagem nº 1";
22.    string mensagem2 = "Este é o valor da mensagem nº 2";
23.
24.    mensagem1 = mensagem2;
25.    MessageBox.Show(mensagem1);
26. }

Observe que, quando executado o programa, a mensagem exibida é “Este é o valor da mensagem nº 2“, pois atribuímos o valor da variável mensagem2 à variavel mensagem1 (linha 22).

Podemos também colocar um valor de um tipo em uma variável de outro tipo fazendo uma conversão:

19. private void button1_Click(object sender, EventArgs e)
20. {
21.    int número = 30;
22.    string mensagem = número.ToString()
23.    MessageBox.Show(mensagem);
24. }

Convertemos o número 30 em uma string “30”. Porém note que a variável número não teve seu tipo alterado.

Para fazer o contrário, colocar uma string dentro de um int use o seguinte código:

string numeroStr = "30";
int numeroInt = Int32.Parse(numeroStr);

Algumas conversões são feitas automatimente:

int numeroInt = 50;
double numeroReal = numeroInt;

Outras não são possível e darão erro:

double numeroReal = 50;
int numeroInt = numeroReal;

Isto se dá por uma questão lógica: o conjunto dos números inteiros estão contidos no conjunto dos números reais, e o contrário não é possível, ou seja, o conjunto de números inteiros conter o conjunto de números reais.

E como pra tudo na vida existe sedex… ops, digo, no C# temos várias formas de fazer a mesma coisa, aliás, temos formas mais práticas de fazê-las:

Ao invés de especificarmos sempre o tipo da variável podemos fazer simplesmente assim:

var numero = 100.00;

Explicação: O código acima cria uma variável chamada numero e atribui a ela um valor do tipo double. Assim sendo, a variável passa a ser double.

var nome = "João da Silva";

Já este código atribui uma string à variável “nome”.

A utilização da palavra-chave var é uma forma prática de declarar variáveis, e tem o mesmo efeito que a forma anterior.

Vamos aprender agora a usar um recurso muito útil na IDE, o Depurador! Com este recurso podemos ter informações das variáveis em tempo de execução. Para isso digite o seguinte código:

private void button1_Click(object sender, EventArgs e)
{
   var minhaVar = 100.00;
   MessageBox.Show(minhaVar.ToString());
}

Vá até a linha 22, onde iremos começar a depuração, e pressione F9. A linha ficará com o fundo vermelho:

Execute seu projeto e clique no botão que você criou no form, observe que o Visual Studio pausa a execução e pára justamente na linha que colocamos o break point. Passe o mouse sobre a variávei, observe que o Visual Studio mostra o tipo da variável (double) e seu valor (100.00):

Mas não se engane, a variável continua sendo estática, ou seja, uma vez atribuída o tipo dela como double ela não pode comportar-se como sendo, por exemplo do tipo inteiro.

Quer mais dinamismo? No C# você tem! Para criar variáveis dinâmicas que podem mudar seu tipo de acordo com o cenário, utilize a palavra-chave dynamic:

19. private void button1_Click(object sender, EventArgs e)
20. {
21.    dynamic variavel;
22.    variavel = 10;
23.    variavel = 40.678;
24.    variavel = "String qualquer";
25.
26.    MessageBox.Show(variavel);
27. }

Coloque um ponto de interrrupção na linha 20 (F9) e depure o programa (F5), clique no botão e utilize F11 para percorrer linha a linha.

Observe que a variável vai tendo seu valor e seu tipo mudados a cada linha:

Só que o dinamismo no C# não foi feito para que você fique aí brincando e usando da forma que quizer. Ao contrário, ele é um recurso muito poderoso e só deve ser usado em caso de necessidade, quando não sabemos o tipo da variável que iremos usar (e isto acontece em casos muito específicos, como trabalhar com webservices, componentes COM ou outros componentes desenvolvidos por plataformas diferentes), pois consome mais processamento e memória do computador, e não queremos ficar desperdiçando recurso a toa não é mesmo?

Mas só saber sobre variáveis não adianta muito se não fizermos algo realmente legal. No próximo artigo aprenderemos como utilizar operadores.

Curso de Programação em C# – parte 4 – Codificando

Publicado: 21 de agosto de 2010 por Junio Albino em Cursos
Tags:, , ,

Se você chegou até aqui quer dizer então que já passou por este caminho:

Curso de Programação em C#

  1. Parte I – Introdução
  2. Parte II – C#
  3. Parte III – Meu Primeiro Programa

Na parte III vimos como utilizar o Visual Studio para criar uma agenda de contatos sem usarmos nenhum código. Neste post iremos aprender sobre o código-fonte do programa.

Observamos que podemos criar um programa inteiro usando os recursos de design da IDE. Mas há muitas razões para que você crie seus programas também codificando-os, e não apenas montando-os como você faz com uma apresentação de slide ou um folheto publicitário.

Abra o Visual C# e crie um novo projeto, do tipo Windows Forms, chamado “Codificando”.

Arraste e solte da Toolbox para o formulário um Button um TextBox:

Selecine o botão e mude a propriedade Text para Clique aqui

Após isto, dê dois clique no botão que você acaba de criar.

Você verá a seguinte tela:

Note que o Visual Studio criou uma nova aba chamada Form1.cs. Esta é a janela que iremos utilizar para codificar nosso programa.

Se você quizer voltar para o Design pressione shift + F7 e para ir ao Código apenas F7.

Não se preocupe em entender todo este código já de primeira. Segue abaixo algumas descrições:

  • Os blocos de código são cercados por chaves.  “{” para início e “}” para fim. Toda chave que se abre deve ter uma correspondente que a fecha.
  • As 8 primeiras linhas são utilizadas para que o .NET saiba quais recursos incluir no programa
  • As linhas 10 e 12 são respectivamente a declaração do Namespace e da Classe, é como se fosse o nome da pasta e o nome do arquivo, mas não necessariamente devem ser assim.
  • As linhas 14 a 17 declaram o construtor da classe. Veremos mais sobre isso depois.
  • As linhas 19 a 21 especificam o comportamento do programa ao ser disparado o evendo de clicar no botão criado.
  • Toda linha de código deve ser terminada com “;”

Algumas vez podemos querer colocar algumas anotações em nosso código, como por exemplo explicar o que o código faz, ou simplesmente escrever algo como o que comprar na feira, ou escrever um poema que você acaba de criar. Para isto devemos criar comentários no código, e isto é feito da seguinte forma:

// Isto é um comentário e não será considerado pelo compilador

ou em bloco de código:

/*
Este é um comentário em bloco.
Este tipo de comentário pode ter várias linhas
*/

há também comentários que são usado para fins de documentação XML:

/// <sumary>
/// Este código será interpretado pela IDE como sendo um tipo de documentação
/// </sumary>

Os caracteres usados para se criar comentários são o “//” para comentários de uma linha, “/**/” para comentários multilinha e “///” para comentários XLM.

Comentários são muito utilizados na programação, é uma boa prática sempre comentarmos nosso código, para que fique mais fácil fazer sua manutenção posteriormente. Esta prática de comentar o código-fonte é chamada de documentação.

Outra questão muito importante na programação é a Indentação. A Indentação é um recurso que usamos para facilitar a visualização do nosso código, perceba que algumas linhas um espaçamento maior que outras. Esta indentação pode ser feita utilizando a tacla TAB do teclado. O Visual Studio também auxilia na indentação do código automaticamente quando fechamos uma chave “}”.

Para prosseguirmos com nosso programa coloque o cursor na linha 21.

Vamos escrever um código para que quando o usuário clicar no botão seja exibida uma mensagem do que estiver escrito no TextBox:

19.  private void button1_Click(object sender, EventArgs e)
20.  {
21.                 MessageBox.Show(textBox1.Text);
22.  }

Execute o projeto Control + F5.

Escreva “Olá Mundo!” no TextBox e pressione o Botão. Será exibida uma pequena janela contendo a mensagem que você acabou de escrever:

Esse tipo de coisa você só faz com código. Alías, tudo é código, quer ver?

Abra o arquivo Form1.Designer.cs e clique no “+” onde está escrito: “Windows Form Designer generated code

Este é o arquivo responsável por criar a parte visual do nosso programa, veja que ele é só código.

Perceba que há letras maiúsculas e minúsculas, não se engane pois deve ser assim, o C# é case-sensitive, ou seja, faz muita diferença se você escreve com CAIXA ALTA ou caixa baixa. Exemplo:

 MessageBox.Show(textBox1.Text);

é diferente de:

 messagebox.show(textBox1.text);

Se você escrever a segunda alternativa o Visual Studio mostrará um erro e seu programa não irá compilar e muito menos executar.

Agora que você já sabe que um projeto de C# é todo feito com código e que podemos utilizar as ferramentas de design do Visual Studio para nos ajudar a codificar, você já pode aprender sobre alguns dos recursos fundamentais de todo programa de computador:

Variáveis e tipos de dados.

Atá a próxima!