Na primeira parte do artigo, a linguagem C# completou os seis trabalhos propostos. Vamos agora terminar os seis restantes e provar que a linguagem C# é poderosa.
Para cada um dos trabalhos restantes, iremos incluir um novo projeto na solução via menu FILE -> Add New Project selecionando o tipo do projeto Windows Forms Application ou Console Application conforme o trabalho. Para ativar o projeto atual para execução, clique com o botão do mouse sobre o nome da Solução e defina qual o projeto deseja executar em Single startup project.
Aos trabalhos…
Trabalho #07
Escreva um programa que receba n valores do usuário e em seguida ordene os valores em ordem ascendente.
Teoria
Na linguagem C#, os arrays possuem o índice com base zero, ou seja, o primeiro elemento do array possui o índice zero (0). Um array de uma dimensão é declarado informando o tipo de dados do array, seguido do nome do array, lembrando que devemos colocar colchetes ([]) depois do tipo do array e não após o seu nome:
Exemplo:
int[] tabela; ==> correto int tabela[]; ==> incorreto
Na linguagem C#, o tamanho do array não é parte do seu tipo e isso permite declarar uma array e em seguida atribuir qualquer array de objetos int a ele, sem considerar o seu tamanho:
Exemplo:
int[] numeros; //declara numeros como um array de inteiros de qualquer tamanho numeros = new int[10]; // numeros agora é um array de 10 elementos numeros = new int[20]; // numeros agora é um array de 20 elementos
Além de arrays de uma dimensão, a linguagem C# suporta os seguintes tipos de arrays:
- Arrays com mais de uma dimensão:
string[,] names; int[,] array = new int[2, 2];
- Array-of-arrays (jagged):
byte[][] resultados;
int[][] numArray = new int[][] { new int[] {1,3,5}, new int[] {2,4,6,8,10} };
Em C# declaramos um array assim:
string[] nomes; //array nomes de qualquer tamanho
Mas isso não cria o array; para fazer isso devemos declarar:
nomes = new string[5]; //array de strings de 5 elementos
Finalmente, para inicializar o array fazemos assim:
nomes[0] = "José"; nomes[1] = "Carlos"; nomes[2] = "Macoratti"; nomes[3] = "Miriam"; nomes[4] = "Estela";
Observe o índice indicando a posição do elemento no array. O primeiro elemento é o zero e o último é 4. Assim, temos 5 elementos no array com posições: 0,1,2,3 e 4.
Prática
Using System;
namespace Trabalho7
{
class Program
{
static void Main(string[] args)
{
int numero;
int temp;
Console.WriteLine("\t\t Macoratti .net\n\tQuase tudo para Visual Basic\n");
try
{
//solicita a informação de quantos numeros vai usar
Console.WriteLine("Informe quantos números você quer usar :");
numero = Convert.ToInt32(Console.ReadLine());
int[] array = new int[numero];
//recebe os numeros do usuário
for (int i = 0; i < numero; i++)
{
Console.Write("Informe o no. " + i + " Valor:");
array[i] = Convert.ToInt32(Console.ReadLine());
}
//realiza a ordenação
for (int i = 0; i < numero ; i++)
{
for (int j = 0; j < numero - 1; j++)
{
if (array[j] > array[j + 1])
{
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
Console.WriteLine("Ordenando em Ordem Ascendente : ");
//imprime os numeros ordenados
for (int i = 0; i < numero; i++)
{
Console.WriteLine(array[i]);
}
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadKey();
}
}
}
Note que para acessar um elemento eu utilizei o seu índice (array[0]) e como em C# os arrays são base zero, o primeiro elemento tem o índice igual a zero (0).
Trabalho #08
Escreva um programa que receba 2 números de um usuário e retorne qual dos números é o maior e depois verifique se esse número é primo ou não.
Teoria
Um método é um bloco de código que contém uma série de instruções. Um programa faz com que as instruções sejam executados chamando o método e especificando todos os argumentos necessários do método. Em C#, todas instruções são executadas por métodos. O método Main é o ponto de entrada para cada aplicativo C# e ele é chamado pelo CLR (Common Languege Runtime) quando o programa é iniciado.
Métodos são declarados em uma classe ou struct, especificando o nível de acesso como public, private, abstract ou sealed, o valor de retorno, o nome do método. Essas partes juntas compõe a assinatura de método. Os parâmetros do método são colocados entre parênteses e são separados por vírgulas. Os parênteses vazios indicam que o método não requer nenhum parâmetro.
Chamar um método em um objeto é como acessar um campo. Após o nome do objeto, adicione um ponto, o nome do método e parênteses. Os argumentos são listados dentro dos parênteses, e separados por vírgulas.
Prática
using System;
namespace Trabalho8
{
class Program
{
static void Main(string[] args)
{
//cria uma instância da classe Program
Program p = new Program();
//define as variáveis usadas no programa como do tipo int
int num1, num2;
int numeroEscolhido;
Console.WriteLine("\t\t Macoratti .net\n\tQuase tudo para Visual Basic\n");
try
{
//recebe os numeros via console
Console.WriteLine("Informe o primeiro número : ");
num1 = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Informe o segundo número :");
num2 = Convert.ToInt32(Console.ReadLine());
//chamando o método para definir qual o numero maior
numeroEscolhido = p.NumeroMaior(num1, num2);
Console.WriteLine("O número maior é " + numeroEscolhido);
//chamando o método para verificar se o número é primo
p.NumeroPrimo(numeroEscolhido);
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadKey();
}
}
private int NumeroMaior(int num1, int num2)
{
if (num1 > num2)
{
return num1;
}
else
{
return num2;
}
}
private void NumeroPrimo(int num)
{
int i = 2;
while (i < num)
{
if (num % i == 0)
{
Console.WriteLine("\nEste número é um número Composto.");
break;
}
i++;
}
//
if (i == num)
{
Console.WriteLine("\nEste número é um número Primo.");
}
if (num == 0 || num == 1)
{
Console.WriteLine("\nEste número não Composto nem Primo.");
}
}
}
}
Neste exemplo poderíamos ter usado a função Max da classe Math, que retorna o maior valor entre dois números. Exemplo: Math.Max(x,y)
Trabalho #09
Escreva um programa que mostre a diferença entre um parâmetro por valor e um parâmetro por referência.
Teoria
Em C#, os argumentos podem ser passados aos parâmetros por valor ou por referência. A passagem por referência permite que membros da função, métodos, propriedades, indexadores, operadores e construtores alterem o valor dos parâmetros fazendo com que essa alteração persista no ambiente de chamada.
Uma variável de um tipo por referência não contém seus dados diretamente. Ele contém uma referência aos seus dados. Quando você passa um parâmetro do tipo de referência por valor, é possível alterar os dados apontados por referência, como, por exemplo, o valor de um membro da classe. No entanto, você não pode alterar o valor da referência propriamente dito; ou seja, você não pode usar a mesma referência alocando memória para uma nova classe. Para isso, passe o parâmetro usando a palavra-chave ref ou out.
Existem três modificadores de parâmetros que podem ser usados para alterar a forma como os parâmetros são passados para as funções:
- (nenhum): Se um parâmetro não é marcado com um modificador de parâmetro, ele será passado por valor, ou seja, o método chamado recebe uma cópia do dado original;
- out: Parâmetros out devem ser atribuídos pelo método sendo chamado, e portanto são passados por referência. Se o método chamado não atribuir os parâmetros out, haverá um erro de compilação;
- ref: O valor é atribuído pelo chamador e pode ser opcionalmente reatribuído pelo método chamado. Se o método chamado não atribuir um parâmetro ref, nenhum erro de compilação será gerado;
- params: Este modificador de parâmetro permite a enviar um número variável de argumentos como um único parâmetro lógico. Um método pode ter somente um modificador params, e ele deve ser o último parâmetro do método. O modificador params não é muito usado, mas existem vários métodos na biblioteca base da .NET Framework que fazem uso deste recurso. A forma padrão de enviar um parâmetro é por valor.
Os parâmetros de referência são necessários quando você quer permitir a um método operar em vários pontos de dados declarados dentro do escopo do chamador. Observe a diferença entre parâmetros de saída e parâmetros de referência:
- Parâmetros de saída não precisam ser inicializados antes de serem passados para o método, pois o método deve atribuir valores a esses parâmetros antes de finalizar.
- Parâmetros de referência devem ser inicializados antes de serem passados para o método. O motivo é que você está passando uma referência para uma variável existente. Se você não atribuir um valor inicial, isso seria equivalente a operar com uma variável local não atribuída.
Prática
using System;
namespace Trabalho9
{
class Program
{
public static void PorValor(int num)
{
num++;
}
public static void PorReferencia(ref int num)
{
num++;
}
static void Main(string[] args)
{
Console.WriteLine("\t\t Macoratti .net\n\tQuase tudo para Visual Basic\n");
int num;
try
{
Console.Write("Informe um número :\t");
num = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("\n\n\tTipo por Valor");
Console.WriteLine("--------------------------");
Console.Write("\nValor Anterior:\t{0}", num);
Program.PorValor(num);
Console.Write("\nValor Atual:\t{0}", num);
Console.WriteLine("\n\n\n--------------------");
Console.WriteLine("\tTipo por Referência");
Console.WriteLine("--------------------------");
Console.Write("\nValor Anterior:\t{0}", num);
Program.PorReferencia(ref num);
Console.Write("\nValor Atual:\t{0}", num);
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadKey();
}
}
}
}
Note que o valor passado por referência foi alterado pela função.
Trabalho #10
Escreva um programa que receba um número de um usuário e exiba a soma dos dígitos deste número. Exemplo: se o usuário informar 142 o valor exibido será: 1+4+2 = 7.
Teoria
O C# fornece um grande conjunto de operadores, que são os símbolos que especificam quais operações executar em uma expressão.
No C#, um operador é um elemento de programa que é aplicado a um ou mais operandos em uma expressão ou instrução. Operadores que usam um operando, como o operador de incremento (++) ou new, são chamados de Unário operadores. Operadores que usam dois operandos, como operadores aritméticos (+,-,*,/), são chamados de binário operadores. Um operador, o operador condicional (?:), usa três operandos e é o único operador Ternário em C#.
Operações em tipos integrais como ==, !=, <, >, <=, >=, binary +, binary -, ^, &, |, ~, ++, –, e sizeof() geralmente são permitidos em enumerações. Além disso, muitos operadores podem ser sobrecarregados pelo usuário, alterando, portanto, seu sentido quando aplicado a um tipo definido pelo usuário.
Cada operador tem uma precedência definida. Em uma expressão que contém vários operadores que têm níveis diferentes de precedência, a precedência dos operadores determina a ordem na qual os operadores são avaliados.
Comparação entre as linguagens VB .NET e C# – Operadores Aritméticos:
| Propósito | VB.NET | C# |
| Adição | + | + |
| Subtração | – | – |
| Multiplicação | * | * |
| Divisão de inteiros | \ | / |
| Módulo(divisão retornando o resto) | Mod | % |
| Exponenciação | ^ | n/d |
Se você precisa realizar cálculos mais complexos do que uma simples soma ou uma multiplicação em C#, use as funções da classe Math:
Abs(x)Acos(x)Asin(x)Atan(x)Ceiling(x)Cos(x)EExp(x)Floor(x)Log(x)Log10(x)Max(x,y)Min(x)PIPow(x,y)Round(x,y)Sin(x)Sqrt(x)Tan(x)
| Função | Finalidade | Exemplo |
| Valor absoluto de x | Abs(4.5) = 4,5; Abs(-4.5) = 4,5; |
|
| Arco cosseno de x | Acos (0.3) = 1,26… | |
| Arco seno de x | Asin(0.6) = 0,64… | |
| Arco tangente de x | Atan(0.5) = 0,46… | |
| Arredonda x para cima | Ceiling(0.1) = 1; Ceiling(-0.1) = 0; |
|
| Cosseno de x | Cos(0.5) = 0,87… | |
| Valor da constante E | E = 2,71… | |
| Exponencial (e elevado na x) | Exp(2.0) = 7,38… | |
| Arredonda x para baixo | Floor(0.8) = 0; Floor(-0.8) = -1; |
|
| Logaritmo de x na base natural e | Log(2.71) = 0,99… | |
| Logaritmo de x na base 10 | Log(2.0) = 0,30… | |
| Maior valor entre dois números | Max(1.8,1.9) = 1.9; Max(-0.3,-0.5) = -0,3; |
|
| Menor valor entre dois números | Min(1.2,1.5) = 1.2; Min(-0.3,-0.6) = -0,3; |
|
| Valor de PI | PI = 3,1415… | |
| Valor de x elevado na y | Pow(3,2) = 9 | |
| Arredonda x para y casas decimais | Round(6.98765,3) = 6,988 | |
| Seno de x | Sin(2) = 0,9… | |
| Raiz quadrada de x | Sqrt(144) = 12 | |
| Tangente de x | Tan(0.5) = 0,54… |
Prática
using System;
namespace Trabalho10
{
class Program
{
static void Main(string[] args)
{
Program p = new Program();
string numero;
int a;
int tamanho;
Console.WriteLine("\t\t Macoratti .net\n\tQuase tudo para Visual Basic\n");
try
{
Console.WriteLine("Informe um número inteiro : ");
numero = Console.ReadLine();
tamanho = numero.Length;
a = int.Parse(numero);
p.calcular(a, tamanho);
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadKey();
}
}
private void calcular(int numero,int tamanho)
{
int a;
int soma = 0;
for (int i = 1; i <= tamanho; i++)
{
a = numero % 10;
numero = numero / 10;
Console.Write( a );
if (tamanho > i)
Console.Write(" + ");
soma = soma + a;
}
Console.WriteLine("\n");
Console.WriteLine("A soma dos dígitos individuais deste número é => " + soma);
}
}
}
Nota: o operador ‘%’ tem como sua única função obter o resto de uma divisão.
Trabalho #11
Escreva um programa que calcule a área de um triângulo quando são fornecidos pelo usuário o valor dos 3 lados A, B e C. O programa deve verificar se o triângulo existe.
Teoria
Heron de Alexandria é o responsável por elaborar uma fórmula matemática que calcula a área de um triângulo em função das medidas dos seus três lados. A fórmula de Heron de Alexandria é muito útil nos casos em que não sabemos a altura do triângulo, mas temos a medida dos lados.
Em um triângulo de lados medindo a, b e c podemos calcular a sua área utilizando a fórmula de Heron:
 |
P = (a + b + c) / 2; Area = Math.Sqrt(P * (P – a) * (P – b) * (P – c)); |
Sabemos que um triângulo é formado por três lados que possuem uma determinada medida, mas essas não podem ser escolhidas aleatoriamente como os lados de um quadrado ou de um retângulo, é preciso seguir uma regra.
Só irá existir um triângulo se, somente se, os seus lados obedeceram à seguinte regra: um de seus lados deve ser maior que o valor absoluto (módulo) da diferença dos outros dois lados e menor que a soma dos outros dois lados.
Veja o resumo da regra abaixo:
| b – c | < a < b + c
| a – c | < b < a + c
| a – b | < c < a + b
Prática
using System;
namespace Trabalho11
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("\t\t Macoratti .net\n\tQuase tudo para Visual Basic\n");
double a, b, c, P;
double Area;
Console.WriteLine("\t Cálculo da área do Triângulo pela fórmula de Heron \n");
try
{
Console.Write("Informe o Lado A : ");
a = Convert.ToDouble(Console.ReadLine());
Console.Write("Informe o Lado B : ");
b = Convert.ToDouble(Console.ReadLine());
Console.Write("Informe o lado C : ");
c = Convert.ToDouble(Console.ReadLine());
if (verificaSeTrianguloExiste(a,b,c))
{
P = (a + b + c) / 2;
Area = Math.Sqrt(P * (P - a) * (P - b) * (P - c));
Console.WriteLine("\n\n");
Console.WriteLine("A Area do Triângulo de lados " + a + "," + b + " e " + c + " é igual a : " + Area);
Console.ReadKey();
}
else
{
Console.WriteLine("\n\n");
Console.WriteLine("Não existe triângulo com os lados informados");
Console.ReadKey();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadKey();
}
}
private static bool verificaSeTrianguloExiste(double a, double b, double c)
{
// Exemplo : 5, 10 e 9 -> verdadeiro
// A condição de existência
//| b - c | < a < b + c
//| a - c | < b < a + c
//| a - b | < c < a + b
//-------------------------
double bc = Math.Abs(b-c);
double ac = Math.Abs(a-c);
double ab = Math.Abs(a-b);
//
bool cond1 = false;
bool cond2 = false;
bool cond3 = false;
if (bc < a && a < b + c)
{
cond1 = true;
}
if (ac < b && b < a + c)
{
cond2 = true;
}
if (ab < c && c < a + b)
{
cond3 = true;
}
if (cond1 && cond2 && cond3)
{
return true;
}
else
{
return false;
}
}
}
}
A função Math.Abs retorna o valor absoluto de um número.
Trabalho #12
Escreva um programa que exiba uma lista dos serviços instalados no computador local e ao final informe o número total de serviços instalados.
Teoria
O método ServiceController.GeServices() recupera todos os serviços no computador local, exceto serviços de driver de dispositivo.
A classe ServiceController representa um serviço do Windows e permite que você se conecte a um serviço em execução ou interrompido, manipule o serviço e obtenha informações sobre ele.
Você pode usar a classe ServiceController para conectar e controlar o comportamento de serviços existentes. Quando você cria uma instância da classe de ServiceController, você define suas propriedades para poder interagir com um serviço específico do Windows. Você pode usar a classe para iniciar, parar e para manipular de outra maneira o serviço.
Depois de criar uma instância de ServiceController, você deve definir duas propriedades para identificar o serviço com que interage: o nome do computador e o nome de serviço que você deseja controlar.
Prática
using System;
using System.Linq;
using System.ServiceProcess;
namespace Trabalho12
{
class Program
{
static void Main(string[] args)
{
ServiceController[] services = ServiceController.GetServices();
Console.WriteLine("\t\t Macoratti .net\n\tQuase tudo para Visual Basic\n");
Console.WriteLine("\t Exibindo os serviços do Windows Instaldos \n");
try
{
foreach (ServiceController servico in services)
{
Console.WriteLine(" Serviço : " + servico.DisplayName);
}
Console.WriteLine("\n\n");
Console.WriteLine(" Total de Serviços : " + services.Count());
Console.ReadKey();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadKey();
}
}
}
}
E com isso concluímos os 12 trabalhos de Hércules usando a linguagem C# aproveitando para abordar diversos tópicos da linguagem.
Pegue o projeto completo aqui: DozeTrabalhos_CSharp2.zip
De 0 a 10, o quanto você recomendaria este artigo para um amigo?