C# round 1 – Comparando as linguagens

Para começar é importante recordar que C# é uma das opções padrão que temos no .NET para desenvolvimento web, e por isso que mais a frente vamos falar tanto de ASPX como de C# já que estão intimamente relacionadas.

Vou dar um pequeno passeio pelo C# mostrando-lhe as similaridades e diferenças entre ambas as linguagens para que seja mais fácil de entender você e possa fazer uma comparação visual.

Algo que é muito importante de destacar é o fato que C# é case sensitive, quer dizer que faz diferença entre as maiúsculas e as minúsculas portanto tenha cuidado especial já que for não é o mesmo que For.

Também é importante que a maioria das linhas de código tenham um ponto e vírgula no final das mesmas, por sorte o ambiente de desenvolvimento é bastante amigável e marca sugestivamente um erro sublinhando de vermelho (como se fosse um erro ortográfico do Word) assim como também se auto-corrige a tabulação de um bloco ao fechar uma chave ou copiar um texto de outro lugar e o colorido da sintaxe é igual ao Visual FoxPro, e por isso que se ao escrever um comando o mesmo não ficar colorido, é melhor revisar se não cometeu um erro.

Os comando como if, case e for em C# se manipulam de um modo um pouco diferente que no Visual FoxPro já que estes comandos utilizam as chaves {} para indicar o início e o fim de um bloco de código, do seguinte modo:

 

Tabela 1: If-EndIf

Visual FoxPro C#
If cNombre = "pablo" 
    * Para comentarios usar o asterisco 
    * Processar algo ... 
Else 
    * Processar algo mais ... 
EndIf
if (cNombre == "pablo")
   {
   // Para comentarios usar 
   //barra dupla
   // Processar algo ...
   }
else
   {
   // Processar algo mais ...
 }

No caso de C# não existe um ENDIF, ENDCASE, ENDDO nem ENDFOR o NEXT, já que ao fechar a chave se esta dando fim a uma instrução. Assim também, é o caso do if há dois pontos a considerar… 1. A condição lógica do if deve estar fechada entre os parenteses. 2. Em C# não é o mesma coisa um sinal de igual que dois de modo que: a. Um sinal de igual atribui um valor como por exemplo idade = 44, neste caso estou atribuindo o valor 44 para a variável idade. b. Dois sinais de igual comparam um valor, onde idade == 44 significa que quero saber se o valor da variável idade é de 44. NOTA: Se o comando tem apenas uma linha de código, não é necessário colocar as chaves de inicio e fim de bloco.

 

Tabela 2: Do Case-EndCase

Visual FoxPro C#
Do Case
   Case nValor = 1
      * Processar algo ...
   Case nValor = 2
      * Processar algo ...
   Case nValor = 3
      * Processar algo ...
   OtherWise
      * Processar algo ...
EndCase
switch(nValor)
   {
   case 1;
   // Processar algo ...
      break;
   case 2;
   // Processar algo ...
      goto case 1;
   case 3;
   // Processar algo ...
      break;
   default
   // Processar algo ...
      break;
   }

Evidentemente, a versão do C# é mais estruturada, sem duvida é fácil destacar as diferenças mais importantes.

  • Toda a lógica do case deve apontar para uma única variável indicada no começo.
  • A variável dever ir entre parenteses.
  • Se deve indicar com o comando break que se quer sair do case;
    caso contrário se seguem avaliando os cases seguintes.
  • Se pode ir de um case a outro utilizando o goto case n.
  • É equivalente ao Otherwise e Padrão.

 

Tabela 3: For-Next

Visual FoxPro C#
For i = 1 to 30
   * Processar algo ...
Next
for (int i=1; i<=30; i++ )
   {
    // Processar algo ...
   }

Como se pode ver, a versão de C# é um pouco mais completa a primeira vista já que separa em três partes:

  • A primeira indica a variável (que pode ser declarada in situ).
  • Em segundo lugar esta a condição de loop .
  • Em terceiro lugar está o incremento (STEP no caso do Visual FoxPro) é onde a variável ponteiro se incrementa de 1 em 1.

O uso de i++ se interpreta como se a variável i soma 1 a seu atual valor e existem as seguintes combinação:

  • i++ é o mesmo que i=i + 1
  • i+= 10 é o mesmo que i=i + 10
  • i– e o mesmo que i=i – 1

Dentro do loop também se pode utilizar ++i que significa em lugar de somar 1 ao terminar de processar o bloco de código será somado antes de processar o bloco de código.

 

Tabela 4: Do While-EndDo

Visual FoxPro C#
Local i as integer
I = 30
Do While i > 0
   i = i - 1
   * Processar algo ...
EndDo
int i=30;
while (i>0)
   {
       i--;
       // Processar algo ...
    }

Como se vê as diferenças neste caso são mínimas, já que se bem no C# se tem a condição lógica vá entre parenteses.

É importante ressaltar que tanto no if como no case, o while e o for a condição principal de cada um esta entre parenteses, quer dizer, que neste caso do if e o While a condição lógica esta entre parenteses, e é o caso de case a variável vai entre parenteses e no caso do for os parenteses do loop vão entre parenteses não tem ponto e virgula no final da linha seguinte é uma chave no inicio do bloco.

O que no Visual FoxPro conhecemos como AND no C é &&, também ocorre o mesmo com OR no Visual FoxPro que é o ||.

Manipulando dados em C#

Em C# se utiliza um conceito de manipulação de dados bastante interessante que é o DataSet, o qual é um conjunto de tabelas contidas em um objeto, semelhante a ter uma base de dados Fox com todas as tabelas em uma variável, algo muito interessante. Porém o uso que é vamos dar ele é bastante reduzido por hora.

Como o objeto DataSet é um objeto container, contém tabelas, que contém registros que contém campos, e deste modo como se deve acessar a informação contida em um DataSet lembrando sempre que as matrizes em C# são base zero portanto se quiser pedir a primeira tabela do DataSet dsDatos eu devo fazer:

dsDatos.Tables[0]; // A primeira tabela
dsDatos.Tables[1]; // A segunda tabela

Seguindo esta minha lógica, para acessar os registro de uma tabela:

dsDatos.Tables[0].Rows[0]; // O primeiro registro da primeira tabela
dsDatos.Tables[0].Rows[1]; // O segundo registro da primeira tabela
dsDatos.Tables[0].Rows[2]; // O terceiro registro da primeira tabela
dsDatos.Tables[2].Rows[9]; // O oitavo registro da terceira tabela

Agora, para poder saber o valor do campo “Apellido” se dever escrever:

x = dsDatos.Tables[0].Rows[0]["Apellido"];

E no caso de querer saber o valor do quarto campo do array:

x = dsDatos.Tables[0].Rows[0][3];

Também se pode querer saber a quantidade de tabelas ou de registro que tem uma tabela para qual existe:

dsDatos.Tables.Count;
dsDatos.Tables[0].Rows.Count;


Tabela 5: Declaração de variáveis
Visual FoxPro C#
Local nEdad As Integer
Local cNombre As String
Local oRs As MiDll.Metodo
int nEdad = 0;
string cNombre = "";
MiDll.Metodo oRs = new MiDll.MetodoClass();

 

Em C# se deve indicar como primeira instância o tipo de variável que irá utilizar, logo o nome da variável e finalmente se deve atribuir um valor. Em se tratando de um objeto é necessário colocar new entre o igual e o objeto.

A maioria dos objetos tem a possibilidade de converter qualquer que seja seu valor em uma string utilizando ToString(), esta função é bastante interessante devido o fato dela incorporar um modo pouco convencional para aqueles desenvolvedores que não estão acostumados a programar em C.

 

Tabla 6: Converter valores

Visual FoxPro C#
Local nEdad As Integer
Local cEdad As String
Local nLargo As Integer
nEdad = 55
cEdad = Alltrim(Str(nEdad))
nLargo = Len(cApellido)
int nEdad = 0;
string cEdad = "";
int nLargo = 0;
nEdad = 55;
cEdad = nEdad.ToString().Trim();
nLargo = cApellido.Length();

No caso do C# existe Convert o qual se encarrega de converter quase todos os tipos de dados suportados pelo sistema, basta escrever Convert na janela de edição para que apareça o intellisense com todas as opções possíveis.

Percorrendo uma tabela

Embora em C# os dados sejam manipulados como objetos, vemos uma sutil equivalência de como é percorrer uma tabela no Visual FoxPro e como faze-lo em C# e adicionar uma variável.

Visual FoxPro C#
Local nTotal as Integer
nTotal = 0
Select MiCursor
Scan
   * Totalizar todos os registro do cursor ...
   nTotal = nTotal + Importe
EndScan
decimal nTotal = 0;
For(int i=0; i<dsDatos.Tables[0].Rows.Count; i++ )
   {
   // Totalizar todos os registro da tabela ...
   nTotal += dsDatos.Tables[0].Rows[i]["importe"]
   }

Como se pode ver a primeira vista não se requer muito mais código, não obstante é necessário começar a trabalhar com objetos como DataSet no caso que de se estar manipulando um conjunto de tabelas ou com o DataTable no caso usar uma única tabela.

Mais adiante veremos que podemos carregar um XML em um DataSet, o que significa que podemos carregar vários XML em um mesmo DataSet e utilizar um conjunto de Tabelas para acessar as diferentes tabelas do DataSet.

Tratamento de Erros

Em C# existe o try-catch que esta presente no Visual FoxPro 8.0, se bem que a funcionalidade seja muito similar, para aqueles que ainda não tenham programado nada em Visual FoxPro 8.0 irei contar do que se trata.

C#

try
   {
   // Ao produzir um erro dentro da instrução try, salta-se o bloco do catch
   }
catch(Exception exc)
   {
   // A variável exc, do tipo Exception, contém o erro produzido. Se tenho uma página
   // chamada error.aspx que recebe um parametro com o text da menssagem de error...
   Response.Redirect("error.aspx?mensaje=" + exc.ToString().Trim())
   }

Temos que levar em conta certas características quando ao funcionamento, como por exemplo:

  • Não se pode direcionar para outra página dentro do try.
  • Se houver um erro e entrar no catch se direciona para uma página com Response, não se pula o código que está abaixo como mostra o exemplo seguinte:

Nesta rotina para enviar um email se pode ver que no final da rotina se chama a pagina mensaje.aspx para informar o usuário que o email foi enviado com sucesso essa linha de código jamais se pula se surgir um erro.

C#

private void Enviar_Mail( string MailMSG )
{
   MailMessage msgMail = new MailMessage();
   try
   {
      msgMail.To = "quemsera@servidor.com.ar";
      msgMail.From = quemsera@servidor.com.ar;
      msgMail.Subject = "Novo usuário";
      msgMail.BodyFormat = MailFormat.Text;
      msgMail.Body = MailMSG;
      // Enviar o email para o administrador
      SmtpMail.SmtpServer = "smtp.servidor.com.ar";
      SmtpMail.Send(msgMail);
   }
   catch (Exception exc)
   {
      Response.Redirect("error.aspx?Mensaje=" + exc.ToString().Trim());
   }
   Response.Redirect("mensaje.aspx?Mensaje=Email foi enviado");
}

Através seu funcionamento, se produz algum erro dentro do try será capturado pelo catch o qual chama a pagina de error.aspx que fará com que não se execute a penúltima linha da rotina que mostra uma mensagem indicando que um email foi enviado, pelo contrario se não tiver nenhum erro se executará a penúltima linha da rotina.

Conclusão

Como pudermos ver, C # não é uma linguagem difícil e além das diferenças evidentes entre ambas as linguagens eu acredito que está claro que C# é completamente intuitivo mesmo quando seja necessário lembrar de pôr o ponto e virgula no final da maioria das linhas de código ou que seja necessário colocar o código entre colchetes.

 

Print Friendly, PDF & Email

Sobre o Autor