Continue lendo meus posts lá

Abraços!

Bom pessoal, este blog foi feito como requisito à uma disciplina da faculdade, não estarei atualizando mais. Por favor, se desejar lendo meus posts vá para http://junioalbino.wordpress.com

Um abraço!

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#

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.

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. Se nã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 açúcar ao café até ele ficar gostoso.
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“.
• 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
provamos
se precisar de mais
colocamos 1 colher de açúcar

em c#:

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

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, também chamados de funções.

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

Operadores de cálculos:

• 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

Lógica:

• 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

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

Atribuição

• =

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

Cuidado! É muito comum o programador confundir o operador “==” com o “=”.

Podemos também usar o parêntese para operações mais complexas, 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;

E para finalizar, o C# tem alguns recursos legais para facilitar nossa vida. Um deles é o operador “+ +” ou “- -” que são de incremento ou 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

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

Até a próxima

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.

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.

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.

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.