VB.NET 2003 - Espiando a estrutura duma aplicação Windows Forms

Neste artigo resolvi examinar mais de perto a estrutura de uma aplicação Windows Forms típica procurando mostrar, se o tempo deixar, o modelo de programação dos formulários e a forma como o VS.NET usa este modelo, o relacionamento entre o formulário e os controles que ele contém e o relacionamento entre formulários.

Todas as aplicações Windows Forms possuem em comum os seguintes itens:

Começando pelo começo

Todas os programas precisam iniciar executando alguma tarefa, e as aplicações .NET possuem um método especial que é chamado quando a aplicação esta sendo executada. Este método é responsável pela criação de qualquer janelas que a aplicação precisa realizando também outros procedimentos necessário para inicializar a aplicação.

Com C# e com o Visual Basic , este ponto de entrada é sempre o método estático chamado Main(). No entanto se você criar um novo projeto no VS.NET usando a linguagem VB.NET com apenas um único form, o famoso formulário padrão form1.vb, e,  tentar localizar o método Main() no código gerado pelo VB , não vai encontrar. No entanto ele esta lá, escondido. Para alcançá-lo execute o aplicativo ILDASM do VB.NET e abra o arquivo compilado referente ao projeto do formulário único e você terá como resultado o seguinte :

O disassembler ILDASM exibindo o método Main() oculto em uma aplicação VB.NET

Nota: O arquivo ILDASM.exe esta na pasta de instalação do seu VS.NET

Se criar a mesma aplicação usando a linguagem C# e visualizar o código gerado irá encontrar o trecho de código abaixo:

/// <summary>

/// The main entry point for the application.

/// </summary>

[STAThread]

static void Main()

{

      Application.Run(new Form1());

}

 

Quem conhece Java sabe que o método main é um método especial do Java: o método main de uma classe, se declarado é executado quando você roda a classe como uma aplicação. Só por curiosidade, ele possui, a seguinte sintaxe:

class Teste
{
    public static void main (String[] args)
    {
        System.out.println("Olá, sou o método main");
    }
}
Java - Exemplo de uso da classe main()

Voltando a plataforma .NET podemos  modificar o método Main() para permitir passagem de parâmetros de linha de comando e podemos também alterar o tipo de retorno. Abaixo temos um exemplo usando C# e VB.NET onde o método Main pode receber parâmetros do tipo String[] ou String()

[STAThread]
static int Main(string[] args)
{
    Application.Run(new Form1( ));
}

<STAThread> _
Public Shared Function Main(args As String( )) As Integer
    Application.Run(New Form1( ))
End Sub
método Main - C# método Main - VB.NET

Tudo o que acontece no método Main é a criação de uma instância da principal interface do usuário (form1), sendo que a seguir o controle é então passado para a classe Application da plataforma .NET, a qual gerencia a execução da aplicação.  O programa irá rodar até que a classe Application decida a hora de encerrar, por padrão isto ocorre quando o formulário principal é fechado (Close).

A classe Application

Para realizar este controle o framework Windows Forms precisa ter um alto grau de controle sobre a aplicação. Precisando responder corretamente a qualquer tipo de entrada que todas as aplicações Windows precisam manipular, como cliques de mouse e requisições para redesenhar controles. Em outras palavras: o framework precisa estar carregado junto com a linha (thread) principal da nossa aplicação a maior parte do tempo, de outra forma, ela não será capaz de tratar com estes eventos.

Embora a execução da aplicação na Plataforma .NET é gerenciada pelo framework podemos influenciar o comportamento da nossa aplicação usando a classe Application. Por exemplo, podemos dizer ao framework para dar um shutdown em nosso programa através da invocação do método Application.Exit.

Na verdade a interação com a classe Application é a primeira coisa que a maioria dos programas fazem. Eles iniciam chamando Application.Run para render o controle aos formulários Windows. Desta forma o framework exibe o objeto Form que após isto fica no estado de espera pela execução de eventos.  Este estilo de execução orientado a eventos é uma característica importante dos formulários Windows.

O framework esta apto a tratar com eventos somente porque nos o deixamos estar carregado, pelo menos enquanto um evento não estiver sendo executado , pois quando isto ocorre , ele fica em background aguardando a execução do evento terminar. Se o evento levar muito tempo ara ser executado a interface do formulário pode parar de responder. A dica é não criar eventos que levam muito tempo para serem executados.

Quando isto não for possível a classe Application fornece o método DoEvents. Este método gerencia qualquer entrada pendente e então retorna. Desta forma a execução de um código que leva muito tempo para ser executado pode ser feita sem dar a impressão que a aplicação travou.

A classe Application também fornece alguns outros recursos. Por exemplo , podemos modificar a forma de tratar as exceções. Se qualquer de nossos tratadores de eventos disparar uma exceção, o comportamento padrão e terminar a aplicação. A classe Application possui um método estático (shared) chamado ThreadException que é levantado sempre que uma exceção ocorre. O tratamento deste evento previne uma o surgimento de exceção não manipulada, e a aplicação não será encerrada a menos que você a encerre explicitamente.

A classe Application fornece também o evento Idle que é disparado sempre que uma entrada foi manipulada e a aplicação esta prestes a se tornar inativa. Podemos usar isto para efetuar um processamento em background.

Pretendo voltar ao assunto em breve.

 VB.NET , é fácil, é simples, é legal. Divirta-se... 

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

José Carlos Macoratti

1