C# - Chamando outros programas por linha de comando

Esse post não será mais atualizado nesse blog. Para visualizar esse post em seu novo endereço, acesse:
http://milaneze.com.br/post/2009/07/26/C-Chamando-outros-programas-por-linha-de-comando.aspx


Às vezes é necessário abrir algum site, abrir o notepad ou mesmo abrir algum diretório programaticamente. Isso é bem simples, basta utilizar o comando mostrado abaixo. No exemplo, está sendo aberto o DOS. Como podemos observar, o comando é a mesma coisa que ir no menu Iniciar >> Executar.

System.Diagnostics.Process.Start("cmd");

Para chamar algum arquivo, basta digitar como parâmetro o nome do arquivo e o Windows irá abrir com o programa padrão para isso.

No caso de precisar abrir uma página da web ou qualquer programa que aceite argumentos de entrada, basta usar como primeiro parâmetro o nome do programa e o segundo o nome da página ou os argumentos que esse aplicativo vai receber. Exemplo:

System.Diagnostics.Process.Start("iexplore", "http://ericmilaneze.blogspot.com");

Assim como explicado antes, é a mesma coisa que digitar os comandos em Iniciar >> Executar.

C# - Tratamento de Exceções

Esse post não será mais atualizado nesse blog. Para visualizar esse post em seu novo endereço, acesse:
http://milaneze.com.br/post/2009/07/25/C-Tratamento-de-Excecoes.aspx


O tratamento de exceções em C# é feito através do bloco try...catch...finally.

Tudo que possa causar alguma exceção, como por exemplo, uma divisão por zero, deve ser colocado dentro do bloco try.

Cada bloco catch responde a um determinado tipo de exceção, por exemplo: DivideByZeroException ou StackOverflowException.

O bloco finally é chamado existindo ou não uma exceção no bloco try.

Assim que uma exceção ocorre no bloco try, o código para e verifica o primeiro bloco catch para ver se o tipo de exceção corresponde, correspondendo ou não, o código passa para o próximo bloco catch e faz a mesma verificação. Após passar por todos blocos catch (ou mesmo não passando, caso não existam), o código dentro do bloco finally é executado.

Classes de exceção definidas pelo usuários devem ser derivadas da classe ApplicationException e todas exceções do CLR (Common Laguage Runtime) são herdadas da classe SystemException, ambas são derivadas da classe Exception.

Para chamar alguma exceção programaticamente, é possível usar o código throw new ClasseExcecao() dentro de um bloco try. Exemplo: throw new Exception("Erro: Divisão por zero");

O código abaixo é um exemplo de exceção de divisão por zero:

   1:  class Program

   2:  {

   3:      static void Main(string[] args)

   4:      {

   5:          int valor1 = Convert.ToInt16(Console.ReadLine());

   6:          int valor2 = Convert.ToInt16(Console.ReadLine());

   7:   

   8:          int valor3 = 0;

   9:   

  10:          try

  11:          {

  12:              valor3 = valor1 / valor2;

  13:          }

  14:          catch (DivideByZeroException excecao)

  15:          {

  16:              valor2 = 1;

  17:              valor3 = valor1 / valor2;

  18:              Console.WriteLine(excecao.Message);

  19:              Console.WriteLine("valor 2 passa a ser " + valor2.ToString());

  20:          }

  21:          finally

  22:          {

  23:              Console.WriteLine(valor3.ToString());

  24:          }

  25:   

  26:          Console.WriteLine("\n");

  27:   

  28:          try

  29:          {

  30:              throw new FormatException();

  31:          }

  32:          catch(FormatException excecao)

  33:          {

  34:              Console.WriteLine(excecao.Message);

  35:          }

  36:          Console.ReadLine();

  37:      }

  38:  }

C# - Sobrecarga do operador

Esse post não será mais atualizado nesse blog. Para visualizar esse post em seu novo endereço, acesse:
http://milaneze.com.br/post/2009/07/08/C-Sobrecarga-do-operador.aspx


Alguns tipos de dados como int, por exemplo, possuem operadores como +, -, *, etc. O próximo exemplo mostra como criar esses tipos de operadores para outros tipos, definidos pelo usuário.

Classe Score

   1:  class Score

   2:  {

   3:      double valor;

   4:   

   5:      public Score(double score)

   6:      {

   7:          valor = score;

   8:      }

   9:          

  10:      public static double operator + (Score x, Score y)

  11:      {

  12:          return x.valor + y.valor;

  13:      }

  14:  }

Aplicação da classe

   1:  class Program

   2:  {

   3:      static void Main(string[] args)

   4:      {

   5:          Score a = new Score(1);

   6:          Score b = new Score(2);

   7:   

   8:          double c = a + b;

   9:   

  10:          Console.WriteLine(c.ToString());

  11:   

  12:          Console.ReadLine();

  13:      }

  14:  }

C# - Interface

Esse post não será mais atualizado nesse blog. Para visualizar esse post em seu novo endereço, acesse:
http://milaneze.com.br/post/2009/07/07/C-Interface.aspx


É uma classe que não possui atributos, apenas métodos, porém esses não possuem implementação. Toda classe derivada de uma interface deve implementar todos seus métodos. Se a classe não implementa todos os métodos, o método que não foi implementado deve ser declarado como abstrata e, por consequência, essa classe deve ser abstrata.


Diferenças entre classe abstrata e interface

As semelhanças entre classe abstrata e interface são muitas. Uma interface é utilizada quando não existe a necessidade das classes derivadas herdarem métodos já implementados. Outra diferença é que interfaces não permitem a declaração de atributos, como as classes abstratas.


O próximo exemplo demonstra como uma interface é declarada e usada. A classe IPagavel é uma interface que é implementada pelas classes Invoice e Empregado (classe abastrata). A classe EmpregadoAssalariado é derivada da classe Empregado.


Classe IPagavel

   1:  public interface IPagavel

   2:  {

   3:      decimal getQuantidadePagar();

   4:  }

Classe Invoice

   1:  class Invoice : IPagavel

   2:  {

   3:      private string partNumber;

   4:      private string partDescription;

   5:      private int quantidade;

   6:      private decimal precoPorItem;

   7:   

   8:      public Invoice(string part, string descricao, int quantidade, decimal preco)

   9:      {

  10:          partNumber = part;

  11:          partDescription = descricao;

  12:          this.quantidade = quantidade;

  13:          precoPorItem = preco;

  14:      }

  15:   

  16:      public string PartNumber

  17:      {

  18:          get

  19:          {

  20:              return partNumber;

  21:          }

  22:   

  23:          set

  24:          {

  25:              partNumber = value;

  26:          }

  27:      }

  28:   

  29:      public string PartDescription

  30:      {

  31:          get

  32:          {

  33:              return partDescription;

  34:          }

  35:   

  36:          set

  37:          {

  38:              partDescription = value;

  39:          }

  40:      }

  41:   

  42:      public int Quantidade

  43:      {

  44:          get

  45:          {

  46:              return quantidade;

  47:          }

  48:   

  49:          set

  50:          {

  51:              quantidade = (value < 0) ? 0 : value;

  52:          }

  53:      }

  54:   

  55:      public decimal PrecoPorItem

  56:      {

  57:          get

  58:          {

  59:              return precoPorItem;

  60:          }

  61:   

  62:          set

  63:          {

  64:              precoPorItem = (value < 0) ? 0 : value;

  65:          }

  66:      }

  67:   

  68:      public override string ToString()

  69:      {

  70:          return string.Format("{0}: \n{1}: {2} ({3}) \n{4}: {5} \n{6}: {7:C}", "invoice", "part number", PartNumber, PartDescription, "quantity", Quantidade, "price per item", PrecoPorItem);

  71:      }

  72:   

  73:      public decimal getQuantidadePagar()

  74:      {

  75:          return Quantidade * PrecoPorItem;

  76:      }

  77:  }

Classe Empregado

   1:  abstract class Empregado : IPagavel

   2:  {

   3:      private string primeiroNome;

   4:      private string ultimoNome;

   5:      private string numeroSeguroSocial;

   6:   

   7:      public Empregado(string primeiro, string segundo, string ssn)

   8:      {

   9:          primeiroNome = primeiro;

  10:          ultimoNome = segundo;

  11:          numeroSeguroSocial = ssn;

  12:      }

  13:   

  14:      public string PrimeiroNome

  15:      {

  16:          get

  17:          {

  18:              return primeiroNome;

  19:          }

  20:      }

  21:   

  22:      public string UltimoNome

  23:      {

  24:          get

  25:          {

  26:              return ultimoNome;

  27:          }

  28:      }

  29:   

  30:      public string NumeroSeguroSocial

  31:      {

  32:          get

  33:          {

  34:              return numeroSeguroSocial;

  35:          }

  36:      }

  37:   

  38:      public override string ToString()

  39:      {

  40:          return string.Format("{0} {1}\nsocial security number: {2}", PrimeiroNome, UltimoNome, NumeroSeguroSocial);

  41:      }

  42:   

  43:      public abstract decimal getQuantidadePagar();

  44:  }

Classe EmpregadoAssalariado

   1:  class EmpregadoAssalariado : Empregado

   2:  {

   3:      private decimal salarioSemanal;

   4:   

   5:      public EmpregadoAssalariado(string primeiro, string ultimo, string ssn, decimal salario)

   6:          : base(primeiro, ultimo, ssn)

   7:      {

   8:          SalarioSemanal = salario;

   9:      }

  10:   

  11:      public decimal SalarioSemanal

  12:      {

  13:          get

  14:          {

  15:              return salarioSemanal;

  16:          }

  17:   

  18:          set

  19:          {

  20:              salarioSemanal = value < 0 ? 0 : value;

  21:          }

  22:      }

  23:   

  24:      public override decimal getQuantidadePagar()

  25:      {

  26:          return SalarioSemanal;

  27:      }

  28:   

  29:      public override string ToString()

  30:      {

  31:          return string.Format("empregado assalariado: {0}\n{1}: {2:C}", base.ToString(), "salário semanal", SalarioSemanal);

  32:      }

  33:  }

Implementação das classes

   1:  class Program

   2:  {

   3:      static void Main(string[] args)

   4:      {

   5:          IPagavel[] objetosPagaveis = new IPagavel[4];

   6:   

   7:          objetosPagaveis[0] = new Invoice("1234", "cadeira", 2, 400.00M);

   8:          objetosPagaveis[1] = new Invoice("9876", "pneu", 4, 80.00M);

   9:          objetosPagaveis[2] = new EmpregadoAssalariado("Eric", "Milaneze", "111-111-111", 750.00M);

  10:          objetosPagaveis[3] = new EmpregadoAssalariado("Thiago", "Milaneze", "222-222-222", 1500.00M);

  11:   

  12:          Console.WriteLine("Invoices e Empregados processados polimorficamente:\n");

  13:   

  14:          foreach (IPagavel pagavelAtual in objetosPagaveis)

  15:          {

  16:              Console.WriteLine( "{0} \n{1}: {2:C}\n", pagavelAtual, "pagamento", pagavelAtual.getQuantidadePagar() );

  17:          }

  18:   

  19:          Console.ReadLine();

  20:      }

  21:  }