Mantenha a linha de execução da interface do usuário responsiva

Os usuários esperam que seu aplicativo permaneça responsivo enquanto ele executa a computação, independentemente do tipo de computador. Isso significa coisas diferentes para aplicativos diferentes : fornecendo física realista, carregando dados do disco ou da Web, apresentando cenas complexas, navegando entre páginas ou processando dados. Independentemente do tipo de processamento, os usuários querem que seu aplicativo responda às ações deles e evite situações em que pareça não responder.

Seu aplicativo é controlado por eventos: seu código executa o trabalho em resposta a um evento e fica ocioso até o próximo evento. O código da plataforma para a interface do usuário (layout, entrada, disparo de eventos) e o código do seu aplicativo para a interface do usuário são executados na mesma thread da interface do usuário. Somente uma instrução é executada nesse thread de cada vez, portanto, se o código do aplicativo demorar muito para processar um evento, a estrutura não poderá executar layout nem gerar novos eventos. A capacidade de resposta do seu aplicativo está relacionada à disponibilidade da thread da interface do usuário para processar tarefas.

Você precisa usar o thread de interface do usuário para fazer quase todas as alterações nos elementos da interface do usuário. Você não pode atualizar a interface do usuário a partir de uma thread em segundo plano, mas pode enviar uma mensagem para ela com DispatcherQueue.TryEnqueue para que o código seja executado nela.

Instanciação do elemento de atraso

Alguns dos estágios mais lentos em um aplicativo incluem inicialização e alternância de exibições. Não faça mais trabalho do que o necessário para exibir a interface que o usuário vê inicialmente. Por exemplo, não crie a interface do usuário para conteúdo revelado progressivamente nem para conteúdos de pop-up.

• Use o atributo x:Load para atrasar a instanciação de elementos.
• Insira elementos programaticamente na árvore sob demanda.

Use DispatcherQueue.TryEnqueue com baixa prioridade para enfileirar trabalho para a thread da interface do usuário processar quando ela não estiver ocupada.

Usar APIs assíncronas

Para manter seu aplicativo responsivo, use versões assíncronas de APIs quando estiverem disponíveis. Uma API assíncrona garante que seu thread de execução ativo nunca seja bloqueado por um período significativo de tempo. Quando você chamar uma API na thread da interface do usuário, sempre use a versão assíncrona, caso exista.

Transferir tarefas para threads em segundo plano

Escreva manipuladores de eventos para retornar rapidamente. Quando uma quantidade não trivial de trabalho precisar ser executada, agende-o em um thread em segundo plano e retorne.

Você pode agendar o trabalho de forma assíncrona usando o await operador em C#. No entanto, await não garante que o trabalho seja executado em um thread em segundo plano. Muitas APIs do SDK do Aplicativo Windows agendam trabalho em uma thread em segundo plano para você, mas, se você chamar o código do seu aplicativo usando apenas await, você executará esse método na thread da interface do usuário. Você precisa executar explicitamente o código do aplicativo em um thread em segundo plano. Em C#, realize isso passando código para Task.Run.

Lembre-se de que você só pode acessar elementos da interface do usuário na thread da interface do usuário. Use a thread da interface do usuário para acessar os elementos da interface do usuário antes de iniciar o trabalho em segundo plano ou use DispatcherQueue.TryEnqueue na thread em segundo plano para enviar atualizações da interface do usuário de volta para a thread da interface do usuário.

public sealed partial class MainWindow : Window
{
    // Declared in MainWindow.xaml as x:Name="statusText".
    private TextBlock statusText;

    private async void NextMove_Click(object sender, RoutedEventArgs e)
    {
        // The await causes the handler to return immediately.
        await Task.Run(() => ComputeNextMove());

        // Now update the UI with the results.
        // This code runs on the UI thread after ComputeNextMove completes.
        statusText.Text = "Move computed.";
    }

    private void ComputeNextMove()
    {
        // Perform background work here.
        // Don't directly access UI elements from this method.
    }
}

Neste exemplo, o manipulador NextMove_Click retorna em await para manter a thread da interface do usuário responsiva. A execução é retomada nesse manipulador após a conclusão de ComputeNextMove (que é executado em uma thread em segundo plano), e o código restante atualiza a interface do usuário com os resultados.

Conteúdo relacionado

• Programação assíncrona
• Planejamento e medição de desempenho
• Otimizar sua marcação XAML