Uma das coisas chatas que eu considero no Visual Basic .NET é a questão do ByVal nos parametros dos procedimentos. Como todos sabem, se não especificarmos nada quando estamos criando os parametros de um determinado procedimento, por default é colocado ByVal.

Até então sem muitos problemas. Então vou lá e crio um procedimento qualquer, com um parametro do tipo ArrayList e, como não especifiquei se quero ByVal ou ByRef, o editor automaticamente embutiu o maldito ByVal. Pois bem, a questão é que mesmo com ByVal, se eu passar o meu objeto ArrayList para o procedimento e dentro dele alterar esse objeto, como adicionar ou remover elementos, isso refletirá no meu objeto original, ou seja, o comportamento é ByRef.

Isso funciona da mesma forma para tudo o que são objetos no .NET, com excessão dos value-types. Mesmo sem a keyword ByRef, se o objeto sofrer alguma alteração, isso será considerado, já que apontará para o mesmo local – objetos sempre serão ByRef. Será que não havia uma forma de automatizar isso, pois ficaria muito mais legível e de fácil entendimento.

Depois de 3 e-mails recebidos em menos de 1 mes, onde colegas me perguntaram para que serve e qual a diferença entre os operadores is e as do C#, resolvi postar aqui a resposta que enviei à eles e, assim contribuir com os demais colegas que possam ter a mesma dúvida.

Operador is:
Este operador verifica se objeto é compatível com um determinado tipo, e o resultado desta avaliação é um valor booleano (True ou False). A vantagem deste operador é que ele nunca lançará uma Exception, mesmo quando os tipos não forem compatíveis. O código abaixo demonstra isso:

     public class Cliente{}
     //….
     object obj = new Object();
     bool teste1 = (obj is Object); // Retorna True
     bool teste2 = (obj is Cliente); // Retorna False

Assim sendo, podemos ter um if comparando se o tipo é compatível com outro e sendo, fazermos o cast (conversão):

     if(obj is Cliente){
          Cliente c = (Cliente)o;
          //….
     }

O único problema deste código é que o CLR verificará o tipo do objeto duas vezes, ou seja, na condicional o operador is fará essa verificação e, logo após, passando por esta verificação e agora já dentro do bloco if antes da conversão ser feita, uma nova verificação é realizada perdendo assim em performance.

Operador as:
É neste caso que o operador as entra em ação. Ele verifica se o objeto é compatível com o tipo Cliente e, se for, o operador retorna um ponteiro (não nulo) para este objeto. Se caso o tipo não for compatível, então como o operador is, também é retornado nulo. Com isso, o tipo só é verificado uma vez. O código abaixo exemplifica o uso do operador as e comprova o ganho no desempenho:

     Cliente c = obj as Cliente;
     if(c != null){
          //….
     }

Lembre-se que a verificação (if) se faz necessário, pois caso o objeto for incompatível, o operador as retornará nulo, e uma Exception do tipo System.NullReferenceException será atirada ao cliente.

Nota: Felizmente no VB.NET 2005 teremos também um operador semelhante: o TryCast, como é explicado neste post.

Encontrei uma feature no Visual Basic .NET que particularmente até hoje nunca utilizei, mas achei bastante interessante. Trata-se da condição When em um bloco Catch do tratamento de exceções. Através desta condicional, definimos se a Exception que foi gerada pelo código que estava sendo gerenciado pelo bloco Try irá ou não ser tratada. Para exemplificar, veja o código abaixo:

        Dim gerarException As Boolean = True
        Try
            Throw New Exception(“Erro na aplicação!”)
        Catch ex As Exception When gerarException
            Console.WriteLine(“Erro na Aplicação, mas foi tratado.”)
        End Try

Analisando o código acima vemos que uma Exception é gerada dentro do bloco Try. Se a variável booleana estiver definida como True, o bloco Catch que trata a Exception será executado, do contrário a mesma é atirada na tela, mas claro, isso baseando-se no código do exemplo acima.

Sim, apesar de não ser intrinsicamente do C#, ou seja, a Microsoft somente disponibilizou isso no Visual Basic .NET, no site IDesign.net tem um wrapper que utiliza as classes My do próprio Visual Basic .NET e assim, podemos consumí-las no C#. O autor deu o nome de “That” para esta classe e um exemplo do uso dela em C#, seria:

     this.RichTextBox1.Text = That.Computer.FileSystem.ReadAllText(“Arquivo.txt”);

Para que quiser baixar o projeto, está aqui o link.

Agora que estou me habituando no C# 2.0, já vem o 3.0: http://msdn.microsoft.com/events/pdc/agenda/default.aspx

• C# 3.0 Language Innovations
• C++ Interop: Under the Hood
• Visual Basic Language Innovations
• Visual Basic: Under the Hood
• Visual Studio Team System: Bringing Development and Test Together for Building and Testing Distributed Applications
• Monad: Bringing Scripting and Extensibility to Your Build Environment
• Enabling Rich Design-time Support for Your Custom Avalon Controls in Visual Studio

Na nova versão da linguagem Visual Basic .NET foi introduzida o “novo” operador chamado TryCast, que até o momento, era somente visto em códigos do .NET Framework que eram decompilados pelo Reflector e não podia ser utilizado em aplicações que nós mesmo desenvolvemos.

Ela é usada como utilizamos atualmente os operadores CType ou o DirectCast, ou seja, passamos o objeto que queremos converter e o tipo para qual este deve ser convertido. Mas a diferença é que o TryCast somente trabalha com References Types, como Classes e Interfaces. E também vale lembrar que ele requer herança ou implementação entre os dois tipos.

Ao contrário do CType e DirectCast, que atiram uma InvalidCastException quando não é possível a conversão, o TryCast retorna Nothing. Abaixo, um exemplo do uso deste novo operador:

          Public Sub Teste(ByVal obj As Object)
               Dim colecao As IList = TryCast(obj, IList)
               If Not (colecao Is Nothing) Then
                    Console.WriteLine(“Coleção válida.”)
               End If
          End Sub

Isso já é suportado no C#, onde lá é conhecido como operador “as“.

Com a nova versão do .NET (2.0), temos agora no C# as chamadas Static Classes, onde é possível declarar uma classe como estática e assim ter todos os seus membros também estáticos, evitando assim a criação de uma classe sealed com o construtor privado e além disso, já informará caso, por engano, voce coloque um método de instancia dentro de uma classe estática. A sintaxe fica agora parecida como:

          public static class MinhaClasse{
               public static void MeuMetodo(){
                    //…
               }
          }

Depois dizem que o C# não copia o VB.NET 😛