O gerenciamento do ciclo de vida em aplicações e janelas WPF (Windows Presentation Foundation) diverge significativamente dos modelos de frameworks mais antigos como o WinForms. O WPF, construído sobre um framework mais moderno, integra conceitos como XAML, eventos roteados e propriedades de dependência, resultando em uma sequência de eventos de ciclo de vida mais rica e distinta. Este artigo explora em detalhes os eventos cruciais que governam o tempo de vida de uma aplicação e de suas janelas no WPF.

Estrutura Fundamental de uma Aplicação WPF

O ponto de entrada para qualquer aplicação WPF reside nos arquivos App.xaml e seu code-behind, App.xaml.cs. A classe App, que herda de System.Windows.Application, é a principal responsável por supervisionar o ciclo de vida da aplicação como um todo.

Eventos do Ciclo de Vida do Objeto Application

O objeto Application dispara uma série de eventos em uma ordem específica, que são essenciais para controlar o fluxo da aplicação:

1. Startup: Disparado logo após a inicialização do objeto Application e antes que qualquer janela seja exibida. É o local ideal para processar argumentos da linha de comando e instanciar a janela principal.

protected override void OnStartup(StartupEventArgs args)
{
   base.OnStartup(args);
   // Lógica para analisar e utilizar argumentos de linha de comando
   // Por exemplo, criar e exibir a janela inicial
   var janelaPrincipal = new MainWindow();
   janelaPrincipal.Show();
}

3. Activated: Ocorre quando a aplicação se torna o aplicativo em primeiro plano, ou seja, quando o usuário a traz para o foco. Este evento refere-se à aplicação inteira, não a uma janela específica.
4. Deactivated: Inversamente ao Activated, este evento é disparado quando a aplicação perde o foco e deixa de ser o aplicativo em primeiro plano.
5. DispatcherUnhandledException: Captura exceções não tratadas que ocorrem no thread da interface do usuário (UI) da aplicação. Permite registrar erros e, possivelmente, evitar o encerramento abrupto da aplicação.
6. SessionEnding: Disparado quando a sessão do usuário está prestes a terminar, seja por logoff, desligamento ou reinicialização do sistema. É uma oportunidade para o aplicativo perguntar ao usuário se deseja salvar dados ou cancelar o encerramento da sessão.
7. Exit: Ocorre momentos antes de a aplicação ser completamente encerrada. É o momento apropriado para realizar operações de limpeza, como salvar configurações ou liberar recursos.

Os eventos Startup e Exit são amplamente utilizados para controle inicial e final da aplicação, frequentemente em conjunto com a propriedade ShutdownMode.

Configuração do ShutdownMode da Aplicação

A propriedade Application.ShutdownMode define quando a aplicação será automaticamente encerrada. Existem três modos principais:

• OnLastWindowClose (Padrão): A aplicação é encerrada quando a última janela aberta é fechada.
• OnMainWindowClose: A aplicação encerra-se quando a janela designada pela propriedade Application.MainWindow é fechada, independentemente de outras janelas estarem abertas.
• OnExplicitShutdown: A aplicação só será encerrada através de uma chamada explícita ao método Application.Shutdown().

O ShutdownMode pode ser configurado diretamente no XAML da classe App:

<Application x:Class="MinhaAppWPF.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             StartupUri="JanelaPrincipal.xaml"
             ShutdownMode="OnMainWindowClose">
</Application>

Eventos do Ciclo de Vida do Objeto Window

Uma instância de Window no WPF passa por uma sequência distinta de eventos desde sua criação até seu fechamento, diferentemente de WinForms e sem um equivalente direto para alguns eventos (como ContentRendered em WinForms).

Estágios de Criação e Inicialização da Janela

1. Construtor da Janela: Durante a instanciação da janela, o método InitializeComponent() é invocado para processar o XAML e construir a árvore visual dos elementos.
2. SourceInitialized: Disparado quando o HwndSource (o identificador de janela de baixo nível) da janela é criado. Neste ponto, o identificador da janela (HWND) está disponível, mas a janela ainda não é visível. É útil para interoperação avançada com APIs Win32.
3. Loaded: Ocorre quando o motor de layout da janela conclui o processo de medição e arranjo dos elementos, e os elementos foram adicionados à árvore visual, mas a janela ainda não foi renderizada visualmente. É um bom momento para inicializações de UI, como vinculação de dados ou definição do foco.
4. ContentRendered: Disparado quando todo o conteúdo da janela (a árvore visual completa) é renderizado pela primeira vez na tela. Note que ele é disparado apenas uma vez, na primeira renderização completa do conteúdo, e não em cada rearranjo de layout subsequente. Útil para ações que dependem da renderização completa.

Estágios de Ativação e Desativação da Janela

5. Activated: Ocorre quando a janela se torna a janela em primeiro plano (focada). Se a janela iniciar em segundo plano, este evento só será disparado quando o usuário interagir com ela.
6. Deactivated: Disparado quando a janela perde o foco e não é mais a janela em primeiro plano.

Estágios de Fechamento da Janela

7. Closing: Acionado quando a janela está prestes a ser fechada, seja por uma ação do usuário (clique no botão 'Fechar'), uma chamada ao método Close(), ou o encerramento da aplicação. Este é um evento cancelável; ao definir CancelEventArgs.Cancel = true, é possível abortar o fechamento da janela. Comumente usado para solicitar ao usuário que salve as alterações.
8. Closed: Ocorre depois que a janela foi completamente fechada e removida da tela. Neste ponto, os recursos da janela foram liberados, e quaisquer limpezas finais (como desregistrar eventos ou liberar recursos não gerenciados) podem ser realizadas. Após este evento, a janela não pode ser exibida novamente, embora o objeto ainda possa ser acessado para consulta de propriedades.

Outros Eventos Importantes da Janela

• StateChanged: Disparado quando o estado da janela muda (Normal, Minimized, Maximized).
• LocationChanged: Ocorre quando a posição da janela na tela é alterada.
• SizeChanged: Acionado quando o tamanho da janela é modificado.

Fluxo Típico de Interação entre os Ciclos de Vida da Aplicação e Janela

Considerando uma aplicação que cria e exibe sua janela principal através do evento Startup:

protected override void OnStartup(StartupEventArgs args)
{
    base.OnStartup(args);
    var janelaPrincipal = new MainWindow();
    janelaPrincipal.Show(); // Inicia a inicialização da janela
}

A sequência de eventos, assumindo ShutdownMode como OnLastWindowClose (padrão), seria aproximadamente:

É importante notar que, se o ShutdownMode for definido como OnMainWindowClose, o evento Application.Exit será disparado imediatamente após o fechamento da janela principal, forçando o fechamento de quaisquer outras janelas abertas (sem disparar seus eventos Closing).

Diferenças Essenciais em Relação ao WinForms

As arquiteturas subjacentes de WPF e WinForms levam a distinções notáveis no comportamento do ciclo de vida:

Diferenças Chave:

• No WPF, uma janela atua como um contêiner de controles, e sua inicialização envolve o sistema de layout. Assim, Loaded ocorre após o layout, mas antes da exibição real, enquanto ContentRendered é disparado quando a janela é efetivamente visível na tela.
• Não há um evento WPF diretamente equivalente ao evento Shown do WinForms; ContentRendered é frequentemente usado para propósitos similares.
• O evento Closing do WPF, com seu parâmetro CancelEventArgs, oferece um mecanismo poderoso para cancelar o fechamento da janela, similar ao FormClosing do WinForms.
• O encerramento da aplicação é gerido pelo objeto Application no WPF, proporcionando maior controle e permitindo a execução de tarefas de limpeza no evento Exit.

Recomendações Práticas

• Inicialização da Interface em Loaded: É o momento seguro para definir o contexto de dados, configurar o foco inicial e outras operações de UI, pois o layout da janela já foi processado.
• Operações Dependentes de Renderização em ContentRendered: Use este evento para tarefas que exigem que o conteúdo visual esteja totalmente renderizado, como tirar capturas de tela ou obter dimensões visuais exatas.
• Confirmação de Salvamento em Closing: Intercepte o fechamento da janela para perguntar ao usuário se ele deseja salvar dados, usando e.Cancel = true para impedir o fechamento.
• Salvamento de Estado Global em Application.Exit: Execute o salvamento de confgiurações do usuário, dados de log ou outras operações de persistência antes do encerramento completo da aplicação.
• Atenção ao ShutdownMode da Aplicação: Se a sua aplicação tiver várias janelas e você desejar que ela encerre quando a janela principal for fechada, certifique-se de configurar ShutdownMode="OnMainWindowClose".

Um Exemplo Prático de Intervenção no Ciclo de Vida

A compreensão do ciclo de vida é crucial para cenários como a implementação de uma aplicação de instância única. A verificação de um Mutex no evento OnStartup, por exemplo, permite que você detecte se outra instância da aplicação já está em execução. Se uma instância existente for detectada, a chamada a Application.Shutdown() dentro de OnStartup encerra a nova instância imediatamente, impedindo que eventos subsequentes (como a criação de janelas) ocorram.

Com esse conhecimento, é possível lidar com uma variedade de situações:

• Atualizar dados em Activated (quando o usuário retorna à aplicação).
• Pausar animações ou reduzir o consumo de recursos em Deactivated.
• Registrar logs de falha e tentar recuperação em DispatcherUnhandledException.