Modelo de threading
O Windows Presentation Foundation (WPF) foi projetado para salvar os desenvolvedores das dificuldades de threading. Como resultado, a maioria dos desenvolvedores do WPF não escreve uma interface que usa mais de um thread. Como os programas multi-threaded são complexos e difíceis de serem depurados, deve-se evitá-los quando existem soluções single-threaded.
Não importa o quão bem arquitetado, no entanto, nenhuma estrutura de interface do usuário é capaz de fornecer uma solução de thread único para cada tipo de problema. O WPF chega perto, mas ainda há situações em que vários threads melhoram a capacidade de resposta da interface do usuário (interface do usuário) ou o desempenho do aplicativo. Depois de discutir algum material de fundo, este artigo explora algumas dessas situações e conclui com uma discussão de alguns detalhes de nível inferior.
Observação
Este tópico discute o threading usando o InvokeAsync método para chamadas assíncronas. O InvokeAsync método usa um Action or Func<TResult> como um parâmetro e retorna um DispatcherOperation or , DispatcherOperation<TResult>que tem uma Task propriedade. Você pode usar a await palavra-chave com o ou o DispatcherOperation .Task Se você precisar aguardar de forma síncrona o Task que é retornado por um DispatcherOperation ou DispatcherOperation<TResult>, chame o método de DispatcherOperationWait extensão. A chamada Task.Wait resultará em um deadlock. Para obter mais informações sobre como usar a Task para executar operações assíncronas, consulte Programação assíncrona baseada em tarefas.
Para fazer uma chamada síncrona, use o Invoke método, que também tem sobrecargas que usam um delegado, Action, ou Func<TResult> parâmetro.
Visão geral e o dispatcher
Normalmente, os aplicativos WPF começam com dois threads: um para lidar com a renderização e outro para gerenciar a interface do usuário. O thread de renderização é executado efetivamente oculto em segundo plano enquanto o thread da interface do usuário recebe entrada, manipula eventos, pinta a tela e executa o código do aplicativo. A maioria dos aplicativos usa um único thread de interface do usuário, embora em algumas situações seja melhor usar vários. Discutiremos isso com um exemplo mais tarde.
O thread da interface do usuário enfileira itens de trabalho dentro de Dispatcherum objeto chamado . O Dispatcher seleciona itens de trabalho com base em prioridade e executa cada um até a conclusão. Cada thread de interface do usuário deve ter pelo menos um Dispatcher, e cada Dispatcher um pode executar itens de trabalho em exatamente um thread.
O truque para criar aplicativos responsivos e fáceis de usar é maximizar a Dispatcher taxa de transferência, mantendo os itens de trabalho pequenos. Dessa forma, os itens nunca ficam obsoletos Dispatcher na fila aguardando processamento. Qualquer atraso perceptível entre a entrada e a resposta pode frustrar um usuário.
Como então os aplicativos WPF devem lidar com grandes operações? E se o código envolver um cálculo grande ou precisar consultar um banco de dados em algum servidor remoto? Normalmente, a resposta é lidar com a grande operação em um thread separado, deixando o thread da interface do usuário livre para cuidar dos Dispatcher itens na fila. Quando a grande operação for concluída, ela poderá relatar seu resultado de volta ao thread da interface do usuário para exibição.
Historicamente, o Windows permite que os elementos da interface do usuário sejam acessados apenas pelo thread que os criou. Isso significa que um thread de segundo plano responsável por uma tarefa de execução longa não pode atualizar uma caixa de texto quando ele é concluído. O Windows faz isso para garantir a integridade dos componentes da interface do usuário. Uma caixa de listagem poderá ter uma aparência estranha se seu conteúdo for atualizado por um thread de segundo plano durante a pintura.
O WPF tem um mecanismo interno de exclusão mútua que impõe essa coordenação. A maioria das classes no WPF deriva de DispatcherObject. Na construção, a DispatcherObject armazena uma referência ao Dispatcher link ao thread em execução no momento. Na verdade, o DispatcherObject associa ao thread que o cria. Durante a execução do programa, a DispatcherObject pode chamar seu método público VerifyAccess . VerifyAccess examina o Dispatcher associado ao thread atual e o compara com a referência armazenada durante a Dispatcher construção. Se eles não corresponderem, VerifyAccess lança uma exceção. VerifyAccess destina-se a ser chamado no início de cada método pertencente a um DispatcherObject.
Se apenas um thread puder modificar a interface do usuário, como os threads em segundo plano interagem com o usuário? Um thread em segundo plano pode solicitar que o thread da interface do usuário execute uma operação em seu nome. Ele faz isso registrando um item de trabalho com o Dispatcher thread da interface do usuário. A Dispatcher classe fornece os métodos para registrar itens de trabalho: Dispatcher.InvokeAsync, Dispatcher.BeginInvokee Dispatcher.Invoke. Esses métodos agendam um delegado para execução. Invoke é uma chamada síncrona – ou seja, ela não retorna até que o thread da interface do usuário realmente termine de executar o delegado. InvokeAsync e BeginInvoke são assíncronas e retornam imediatamente.
O ordena Dispatcher os elementos em sua fila por prioridade. Há dez níveis que podem ser especificados ao adicionar um elemento à Dispatcher fila. Essas prioridades são mantidas na DispatcherPriority enumeração.
Aplicativo de thread único com um cálculo de execução longa
A maioria das interfaces gráficas do usuário (GUIs) passa grande parte do tempo ocioso enquanto aguarda eventos gerados em resposta às interações do usuário. Com uma programação cuidadosa, esse tempo ocioso pode ser usado de forma construtiva, sem afetar a capacidade de resposta da interface do usuário. O modelo de threading do WPF não permite que a entrada interrompa uma operação que está acontecendo no thread da interface do usuário. Isso significa que você deve retornar Dispatcher periodicamente para processar eventos de entrada pendentes antes que eles fiquem obsoletos.
Um aplicativo de exemplo que demonstra os conceitos desta seção pode ser baixado do GitHub para C# ou Visual Basic.
Considere o seguinte exemplo:
Este aplicativo simples faz uma contagem ascendente a partir do três, pesquisando os números primos. Quando o usuário clica no botão Iniciar, a pesquisa é iniciada. Quando o programa encontra um primo, ele atualiza a interface do usuário com sua descoberta. A qualquer momento, o usuário pode parar a pesquisa.
Embora seja simples o suficiente, a pesquisa de números primos poderá continuar para sempre, o que apresenta algumas dificuldades. Se lidássemos com toda a pesquisa dentro do manipulador de eventos de clique do botão, nunca daríamos ao thread da interface do usuário a chance de lidar com outros eventos. A interface do usuário não seria capaz de responder a mensagens de entrada ou processo. Ele nunca redesenhará e nunca responderá aos cliques do botão.
Poderíamos realizar a pesquisa de números primos em um thread separado, mas precisaríamos lidar com problemas de sincronização. Com uma abordagem single-threaded, podemos atualizar diretamente o rótulo que lista o maior primo encontrado.
Se dividirmos a tarefa de cálculo em partes gerenciáveis, podemos retornar periodicamente aos Dispatcher eventos e process. Podemos dar ao WPF a oportunidade de repintar e processar a entrada.
A melhor maneira de dividir o tempo de processamento entre o cálculo e a manipulação de eventos é gerenciar o Dispatchercálculo a partir do . Usando o InvokeAsync método, podemos agendar verificações de números primos na mesma fila da qual os eventos de interface do usuário são extraídos. Em nosso exemplo, agendamos somente uma única verificação de números primos por vez. Depois que a verificação de números primos for concluída, agendaremos a próxima verificação imediatamente. Essa verificação continua somente depois que os eventos pendentes da interface do usuário foram tratados.
O Microsoft Word realiza a verificação ortográfica usando esse mecanismo. A verificação ortográfica é feita em segundo plano usando o tempo ocioso do thread da interface do usuário. Vamos dar uma olhada no código.
O exemplo a seguir mostra o XAML que cria a interface do usuário.
Importante
O XAML mostrado neste artigo é de um projeto C#. O XAML do Visual Basic é um pouco diferente ao declarar a classe de suporte para o XAML.
<Window x:Class="SDKSamples.PrimeNumber"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="Prime Numbers" Width="360" Height="100">
<StackPanel Orientation="Horizontal" VerticalAlignment="Center" Margin="20" >
<Button Content="Start"
Click="StartStopButton_Click"
Name="StartStopButton"
Margin="5,0,5,0" Padding="10,0" />
<TextBlock Margin="10,0,0,0">Biggest Prime Found:</TextBlock>
<TextBlock Name="bigPrime" Margin="4,0,0,0">3</TextBlock>
</StackPanel>
</Window>
O exemplo a seguir mostra o code-behind.
using System;
using System.Windows;
using System.Windows.Threading;
namespace SDKSamples
{
public partial class PrimeNumber : Window
{
// Current number to check
private long _num = 3;
private bool _runCalculation = false;
public PrimeNumber() =>
InitializeComponent();
private void StartStopButton_Click(object sender, RoutedEventArgs e)
{
_runCalculation = !_runCalculation;
if (_runCalculation)
{
StartStopButton.Content = "Stop";
StartStopButton.Dispatcher.InvokeAsync(CheckNextNumber, DispatcherPriority.SystemIdle);
}
else
StartStopButton.Content = "Resume";
}
public void CheckNextNumber()
{
// Reset flag.
_isPrime = true;
for (long i = 3; i <= Math.Sqrt(_num); i++)
{
if (_num % i == 0)
{
// Set not a prime flag to true.
_isPrime = false;
break;
}
}
// If a prime number, update the UI text
if (_isPrime)
bigPrime.Text = _num.ToString();
_num += 2;
// Requeue this method on the dispatcher
if (_runCalculation)
StartStopButton.Dispatcher.InvokeAsync(CheckNextNumber, DispatcherPriority.SystemIdle);
}
private bool _isPrime = false;
}
}
Imports System.Windows.Threading
Public Class PrimeNumber
' Current number to check
Private _num As Long = 3
Private _runCalculation As Boolean = False
Private Sub StartStopButton_Click(sender As Object, e As RoutedEventArgs)
_runCalculation = Not _runCalculation
If _runCalculation Then
StartStopButton.Content = "Stop"
StartStopButton.Dispatcher.InvokeAsync(AddressOf CheckNextNumber, DispatcherPriority.SystemIdle)
Else
StartStopButton.Content = "Resume"
End If
End Sub
Public Sub CheckNextNumber()
' Reset flag.
_isPrime = True
For i As Long = 3 To Math.Sqrt(_num)
If (_num Mod i = 0) Then
' Set Not a prime flag to true.
_isPrime = False
Exit For
End If
Next
' If a prime number, update the UI text
If _isPrime Then
bigPrime.Text = _num.ToString()
End If
_num += 2
' Requeue this method on the dispatcher
If (_runCalculation) Then
StartStopButton.Dispatcher.InvokeAsync(AddressOf CheckNextNumber, DispatcherPriority.SystemIdle)
End If
End Sub
Private _isPrime As Boolean
End Class
Além de atualizar o texto no , o Button manipulador é responsável por agendar a primeira verificação de número primo StartStopButton_Clickadicionando um delegado à Dispatcher fila. Algum tempo depois que esse manipulador de eventos tiver concluído seu trabalho, o Dispatcher selecionará o delegado para execução.
Como mencionamos anteriormente, InvokeAsync é o Dispatcher membro usado para agendar um delegado para execução. Nesse caso, escolhemos a SystemIdle prioridade. O Dispatcher executará esse delegado somente quando não houver eventos importantes a serem processados. A capacidade de resposta da interface do usuário é mais importante do que a verificação de números. Também passamos um novo delegado que representa a rotina de verificação de números.
public void CheckNextNumber()
{
// Reset flag.
_isPrime = true;
for (long i = 3; i <= Math.Sqrt(_num); i++)
{
if (_num % i == 0)
{
// Set not a prime flag to true.
_isPrime = false;
break;
}
}
// If a prime number, update the UI text
if (_isPrime)
bigPrime.Text = _num.ToString();
_num += 2;
// Requeue this method on the dispatcher
if (_runCalculation)
StartStopButton.Dispatcher.InvokeAsync(CheckNextNumber, DispatcherPriority.SystemIdle);
}
private bool _isPrime = false;
Public Sub CheckNextNumber()
' Reset flag.
_isPrime = True
For i As Long = 3 To Math.Sqrt(_num)
If (_num Mod i = 0) Then
' Set Not a prime flag to true.
_isPrime = False
Exit For
End If
Next
' If a prime number, update the UI text
If _isPrime Then
bigPrime.Text = _num.ToString()
End If
_num += 2
' Requeue this method on the dispatcher
If (_runCalculation) Then
StartStopButton.Dispatcher.InvokeAsync(AddressOf CheckNextNumber, DispatcherPriority.SystemIdle)
End If
End Sub
Private _isPrime As Boolean
Esse método verifica se o próximo número ímpar é um primo. Se for primo, o método atualiza diretamente o bigPrimeTextBlock para refletir sua descoberta. Podemos fazer isso porque o cálculo está ocorrendo no mesmo thread que foi usado para criar o controle. Se tivéssemos optado por usar um thread separado para o cálculo, teríamos que usar um mecanismo de sincronização mais complicado e executar a atualização no thread da interface do usuário. Demonstraremos essa situação a seguir.
Várias janelas, vários threads
Alguns aplicativos WPF exigem várias janelas de nível superior. É perfeitamente aceitável que uma combinação de Thread/Dispatcher gerencie várias janelas, mas às vezes vários threads fazem um trabalho melhor. Isso é especialmente verdadeiro se houver alguma chance de que uma das janelas monopolize o thread.
O Windows Explorer funciona dessa maneira. Cada nova janela do Explorer pertence ao processo original, mas é criada sob o controle de um thread independente. Quando o Explorer não responde, como ao procurar recursos de rede, outras janelas do Explorer continuam a ser responsivas e utilizáveis.
Podemos demonstrar esse conceito com o exemplo a seguir.
As três janelas superiores desta imagem compartilham o mesmo identificador de thread: 1. As outras duas janelas têm identificadores de thread diferentes: Nove e 4. Há um glifo ! giratório !️ de cor magenta no canto superior direito de cada janela.
Este exemplo contém uma janela com um glifo rotativo ‼️ , um botão Pausar e dois outros botões que criam uma nova janela no thread atual ou em um novo thread. O ‼️ glifo está girando constantemente até que o botão Pausar seja pressionado, o que pausa o thread por cinco segundos. Na parte inferior da janela, o identificador de thread é exibido.
Quando o botão Pausar é pressionado, todas as janelas no mesmo thread não respondem. Qualquer janela em um thread diferente continua funcionando normalmente.
O exemplo a seguir é o XAML para a janela:
<Window x:Class="SDKSamples.MultiWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Title="Thread Hosted Window" Width="360" Height="180" SizeToContent="Height" ResizeMode="NoResize" Loaded="Window_Loaded">
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="*" />
<RowDefinition Height="Auto" />
<RowDefinition Height="Auto" />
</Grid.RowDefinitions>
<TextBlock HorizontalAlignment="Right" Margin="30,0" Text="‼️" FontSize="50" FontWeight="ExtraBold"
Foreground="Magenta" RenderTransformOrigin="0.5,0.5" Name="RotatedTextBlock">
<TextBlock.RenderTransform>
<RotateTransform Angle="0" />
</TextBlock.RenderTransform>
<TextBlock.Triggers>
<EventTrigger RoutedEvent="Loaded">
<BeginStoryboard>
<Storyboard>
<DoubleAnimation Storyboard.TargetName="RotatedTextBlock"
Storyboard.TargetProperty="(UIElement.RenderTransform).(RotateTransform.Angle)"
From="0" To="360" Duration="0:0:5" RepeatBehavior="Forever" />
</Storyboard>
</BeginStoryboard>
</EventTrigger>
</TextBlock.Triggers>
</TextBlock>
<StackPanel Orientation="Horizontal" VerticalAlignment="Center" Margin="20" >
<Button Content="Pause" Click="PauseButton_Click" Margin="5,0" Padding="10,0" />
<TextBlock Margin="5,0,0,0" Text="<-- Pause for 5 seconds" />
</StackPanel>
<StackPanel Grid.Row="1" Margin="10">
<Button Content="Create 'Same Thread' Window" Click="SameThreadWindow_Click" />
<Button Content="Create 'New Thread' Window" Click="NewThreadWindow_Click" Margin="0,10,0,0" />
</StackPanel>
<StatusBar Grid.Row="2" VerticalAlignment="Bottom">
<StatusBarItem Content="Thread ID" Name="ThreadStatusItem" />
</StatusBar>
</Grid>
</Window>
O exemplo a seguir mostra o code-behind.
using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
namespace SDKSamples
{
public partial class MultiWindow : Window
{
public MultiWindow() =>
InitializeComponent();
private void Window_Loaded(object sender, RoutedEventArgs e) =>
ThreadStatusItem.Content = $"Thread ID: {Thread.CurrentThread.ManagedThreadId}";
private void PauseButton_Click(object sender, RoutedEventArgs e) =>
Task.Delay(TimeSpan.FromSeconds(5)).Wait();
private void SameThreadWindow_Click(object sender, RoutedEventArgs e) =>
new MultiWindow().Show();
private void NewThreadWindow_Click(object sender, RoutedEventArgs e)
{
Thread newWindowThread = new Thread(ThreadStartingPoint);
newWindowThread.SetApartmentState(ApartmentState.STA);
newWindowThread.IsBackground = true;
newWindowThread.Start();
}
private void ThreadStartingPoint()
{
new MultiWindow().Show();
System.Windows.Threading.Dispatcher.Run();
}
}
}
Imports System.Threading
Public Class MultiWindow
Private Sub Window_Loaded(sender As Object, e As RoutedEventArgs)
ThreadStatusItem.Content = $"Thread ID: {Thread.CurrentThread.ManagedThreadId}"
End Sub
Private Sub PauseButton_Click(sender As Object, e As RoutedEventArgs)
Task.Delay(TimeSpan.FromSeconds(5)).Wait()
End Sub
Private Sub SameThreadWindow_Click(sender As Object, e As RoutedEventArgs)
Dim window As New MultiWindow()
window.Show()
End Sub
Private Sub NewThreadWindow_Click(sender As Object, e As RoutedEventArgs)
Dim newWindowThread = New Thread(AddressOf ThreadStartingPoint)
newWindowThread.SetApartmentState(ApartmentState.STA)
newWindowThread.IsBackground = True
newWindowThread.Start()
End Sub
Private Sub ThreadStartingPoint()
Dim window As New MultiWindow()
window.Show()
System.Windows.Threading.Dispatcher.Run()
End Sub
End Class
A seguir estão alguns dos detalhes a serem observados:
A Task.Delay(TimeSpan) tarefa é usada para fazer com que o thread atual pause por cinco segundos quando o botão Pausar é pressionado.
private void PauseButton_Click(object sender, RoutedEventArgs e) => Task.Delay(TimeSpan.FromSeconds(5)).Wait();Private Sub PauseButton_Click(sender As Object, e As RoutedEventArgs) Task.Delay(TimeSpan.FromSeconds(5)).Wait() End SubO
SameThreadWindow_Clickmanipulador de eventos mostra imediatamente uma nova janela no thread atual. ONewThreadWindow_Clickmanipulador de eventos cria um novo thread que começa a executar oThreadStartingPointmétodo, que, por sua vez, mostra uma nova janela, conforme descrito no próximo marcador.private void SameThreadWindow_Click(object sender, RoutedEventArgs e) => new MultiWindow().Show(); private void NewThreadWindow_Click(object sender, RoutedEventArgs e) { Thread newWindowThread = new Thread(ThreadStartingPoint); newWindowThread.SetApartmentState(ApartmentState.STA); newWindowThread.IsBackground = true; newWindowThread.Start(); }Private Sub SameThreadWindow_Click(sender As Object, e As RoutedEventArgs) Dim window As New MultiWindow() window.Show() End Sub Private Sub NewThreadWindow_Click(sender As Object, e As RoutedEventArgs) Dim newWindowThread = New Thread(AddressOf ThreadStartingPoint) newWindowThread.SetApartmentState(ApartmentState.STA) newWindowThread.IsBackground = True newWindowThread.Start() End SubO
ThreadStartingPointmétodo é o ponto de partida para o novo thread. A nova janela é criada sob o controle desse thread. O WPF cria automaticamente um novo System.Windows.Threading.Dispatcher para gerenciar o novo thread. Tudo o que precisamos fazer para tornar a janela funcional é iniciar o System.Windows.Threading.Dispatcher.private void ThreadStartingPoint() { new MultiWindow().Show(); System.Windows.Threading.Dispatcher.Run(); }Private Sub ThreadStartingPoint() Dim window As New MultiWindow() window.Show() System.Windows.Threading.Dispatcher.Run() End Sub
Um aplicativo de exemplo que demonstra os conceitos desta seção pode ser baixado do GitHub para C# ou Visual Basic.
Manipular uma operação de bloqueio com Task.Run
A manipulação de operações de bloqueio em um aplicativo gráfico pode ser difícil. Não queremos chamar métodos de bloqueio de manipuladores de eventos porque o aplicativo parece congelar. O exemplo anterior criou novas janelas em seu próprio thread, permitindo que cada janela seja executada independentemente uma da outra. Embora possamos criar um novo thread com System.Windows.Threading.Dispatchero , torna-se difícil sincronizar o novo thread com o thread principal da interface do usuário após a conclusão do trabalho. Como o novo thread não pode modificar a interface do usuário diretamente, precisamos usar Dispatcher.InvokeAsync, , ou Dispatcher.BeginInvoke, para inserir delegados no Dispatcher.Invoke thread da Dispatcherinterface do usuário. Eventualmente, esses delegados são executados com permissão para modificar elementos da interface do usuário.
Há uma maneira mais fácil de executar o código em um novo thread enquanto sincroniza os resultados, o TAP (padrão assíncrono baseado em tarefa). Ele se baseia nos Task tipos e Task<TResult> no System.Threading.Tasks namespace, que são usados para representar operações assíncronas. O TAP usa um único método para representar o início e a conclusão de uma operação assíncrona. Existem alguns benefícios nesse padrão:
- O chamador de a
Taskpode optar por executar o código de forma assíncrona ou síncrona. - O progresso pode ser relatado no
Task. - O código de chamada pode suspender a execução e aguardar o resultado da operação.
Exemplo de Task.Run
Neste exemplo, simulamos uma chamada de procedimento remoto que recupera uma previsão do tempo. Quando o botão é clicado, a interface do usuário é atualizada para indicar que a busca de dados está em andamento, enquanto uma tarefa é iniciada para imitar a busca da previsão do tempo. Quando a tarefa é iniciada, o código do manipulador de eventos do botão é suspenso até que a tarefa seja concluída. Após a conclusão da tarefa, o código do manipulador de eventos continua a ser executado. O código é suspenso e não bloqueia o restante do thread da interface do usuário. O contexto de sincronização do WPF manipula a suspensão do código, o que permite que o WPF continue a ser executado.
Um diagrama que demonstra o fluxo de trabalho do aplicativo de exemplo. O aplicativo possui um único botão com o texto "Buscar previsão". Há uma seta apontando para a próxima fase do aplicativo depois que o botão é pressionado, que é uma imagem de relógio colocada no centro do aplicativo indicando que o aplicativo está ocupado buscando dados. Depois de algum tempo, o aplicativo retorna com uma imagem do sol ou de nuvens de chuva, dependendo do resultado dos dados.
Um aplicativo de exemplo que demonstra os conceitos desta seção pode ser baixado do GitHub para C# ou Visual Basic. O XAML para este exemplo é muito grande e não é fornecido neste artigo. Use os links anteriores do GitHub para navegar pelo XAML. O XAML usa um único botão para buscar o clima.
Considere o code-behind para o XAML:
using System;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Threading.Tasks;
namespace SDKSamples
{
public partial class Weather : Window
{
public Weather() =>
InitializeComponent();
private async void FetchButton_Click(object sender, RoutedEventArgs e)
{
// Change the status image and start the rotation animation.
fetchButton.IsEnabled = false;
fetchButton.Content = "Contacting Server";
weatherText.Text = "";
((Storyboard)Resources["HideWeatherImageStoryboard"]).Begin(this);
// Asynchronously fetch the weather forecast on a different thread and pause this code.
string weather = await Task.Run(FetchWeatherFromServerAsync);
// After async data returns, process it...
// Set the weather image
if (weather == "sunny")
weatherIndicatorImage.Source = (ImageSource)Resources["SunnyImageSource"];
else if (weather == "rainy")
weatherIndicatorImage.Source = (ImageSource)Resources["RainingImageSource"];
//Stop clock animation
((Storyboard)Resources["ShowClockFaceStoryboard"]).Stop(ClockImage);
((Storyboard)Resources["HideClockFaceStoryboard"]).Begin(ClockImage);
//Update UI text
fetchButton.IsEnabled = true;
fetchButton.Content = "Fetch Forecast";
weatherText.Text = weather;
}
private async Task<string> FetchWeatherFromServerAsync()
{
// Simulate the delay from network access
await Task.Delay(TimeSpan.FromSeconds(4));
// Tried and true method for weather forecasting - random numbers
Random rand = new Random();
if (rand.Next(2) == 0)
return "rainy";
else
return "sunny";
}
private void HideClockFaceStoryboard_Completed(object sender, EventArgs args) =>
((Storyboard)Resources["ShowWeatherImageStoryboard"]).Begin(ClockImage);
private void HideWeatherImageStoryboard_Completed(object sender, EventArgs args) =>
((Storyboard)Resources["ShowClockFaceStoryboard"]).Begin(ClockImage, true);
}
}
Imports System.Windows.Media.Animation
Public Class Weather
Private Async Sub FetchButton_Click(sender As Object, e As RoutedEventArgs)
' Change the status image and start the rotation animation.
fetchButton.IsEnabled = False
fetchButton.Content = "Contacting Server"
weatherText.Text = ""
DirectCast(Resources("HideWeatherImageStoryboard"), Storyboard).Begin(Me)
' Asynchronously fetch the weather forecast on a different thread and pause this code.
Dim weatherType As String = Await Task.Run(AddressOf FetchWeatherFromServerAsync)
' After async data returns, process it...
' Set the weather image
If weatherType = "sunny" Then
weatherIndicatorImage.Source = DirectCast(Resources("SunnyImageSource"), ImageSource)
ElseIf weatherType = "rainy" Then
weatherIndicatorImage.Source = DirectCast(Resources("RainingImageSource"), ImageSource)
End If
' Stop clock animation
DirectCast(Resources("ShowClockFaceStoryboard"), Storyboard).Stop(ClockImage)
DirectCast(Resources("HideClockFaceStoryboard"), Storyboard).Begin(ClockImage)
' Update UI text
fetchButton.IsEnabled = True
fetchButton.Content = "Fetch Forecast"
weatherText.Text = weatherType
End Sub
Private Async Function FetchWeatherFromServerAsync() As Task(Of String)
' Simulate the delay from network access
Await Task.Delay(TimeSpan.FromSeconds(4))
' Tried and true method for weather forecasting - random numbers
Dim rand As New Random()
If rand.Next(2) = 0 Then
Return "rainy"
Else
Return "sunny"
End If
End Function
Private Sub HideClockFaceStoryboard_Completed(sender As Object, e As EventArgs)
DirectCast(Resources("ShowWeatherImageStoryboard"), Storyboard).Begin(ClockImage)
End Sub
Private Sub HideWeatherImageStoryboard_Completed(sender As Object, e As EventArgs)
DirectCast(Resources("ShowClockFaceStoryboard"), Storyboard).Begin(ClockImage, True)
End Sub
End Class
Veja a seguir alguns dos detalhes a serem observados.
O manipulador de eventos de botão
private async void FetchButton_Click(object sender, RoutedEventArgs e) { // Change the status image and start the rotation animation. fetchButton.IsEnabled = false; fetchButton.Content = "Contacting Server"; weatherText.Text = ""; ((Storyboard)Resources["HideWeatherImageStoryboard"]).Begin(this); // Asynchronously fetch the weather forecast on a different thread and pause this code. string weather = await Task.Run(FetchWeatherFromServerAsync); // After async data returns, process it... // Set the weather image if (weather == "sunny") weatherIndicatorImage.Source = (ImageSource)Resources["SunnyImageSource"]; else if (weather == "rainy") weatherIndicatorImage.Source = (ImageSource)Resources["RainingImageSource"]; //Stop clock animation ((Storyboard)Resources["ShowClockFaceStoryboard"]).Stop(ClockImage); ((Storyboard)Resources["HideClockFaceStoryboard"]).Begin(ClockImage); //Update UI text fetchButton.IsEnabled = true; fetchButton.Content = "Fetch Forecast"; weatherText.Text = weather; }Private Async Sub FetchButton_Click(sender As Object, e As RoutedEventArgs) ' Change the status image and start the rotation animation. fetchButton.IsEnabled = False fetchButton.Content = "Contacting Server" weatherText.Text = "" DirectCast(Resources("HideWeatherImageStoryboard"), Storyboard).Begin(Me) ' Asynchronously fetch the weather forecast on a different thread and pause this code. Dim weatherType As String = Await Task.Run(AddressOf FetchWeatherFromServerAsync) ' After async data returns, process it... ' Set the weather image If weatherType = "sunny" Then weatherIndicatorImage.Source = DirectCast(Resources("SunnyImageSource"), ImageSource) ElseIf weatherType = "rainy" Then weatherIndicatorImage.Source = DirectCast(Resources("RainingImageSource"), ImageSource) End If ' Stop clock animation DirectCast(Resources("ShowClockFaceStoryboard"), Storyboard).Stop(ClockImage) DirectCast(Resources("HideClockFaceStoryboard"), Storyboard).Begin(ClockImage) ' Update UI text fetchButton.IsEnabled = True fetchButton.Content = "Fetch Forecast" weatherText.Text = weatherType End SubObserve que o manipulador de eventos foi declarado com
async(ouAsynccom Visual Basic). Um método "assíncrono" permite a suspensão do código quando um método aguardado, comoFetchWeatherFromServerAsync, é chamado. Isso é designado pelaawaitpalavra-chave (ouAwaitcom Visual Basic). Até que oFetchWeatherFromServerAsyncbotão seja concluído, o código do manipulador do botão é suspenso e o controle é retornado ao chamador. Isso é semelhante a um método síncrono, exceto que um método síncrono aguarda a conclusão de cada operação no método, após a qual o controle é retornado ao chamador.Os métodos aguardados utilizam o contexto de threading do método atual, que com o manipulador de botão, é o thread da interface do usuário. Isso significa que chamar
await FetchWeatherFromServerAsync();(OrAwait FetchWeatherFromServerAsync()com Visual Basic) faz com que o código sejaFetchWeatherFromServerAsyncexecutado no thread da interface do usuário, mas não é executado no dispatcher tem tempo para executá-lo, semelhante a como o aplicativo de thread único com um exemplo de cálculo de execução longa opera. No entanto, observe queawait Task.Runé usado. Isso cria um novo thread no pool de threads para a tarefa designada em vez do thread atual. EntãoFetchWeatherFromServerAsyncé executado em seu próprio tópico.Buscando o clima
private async Task<string> FetchWeatherFromServerAsync() { // Simulate the delay from network access await Task.Delay(TimeSpan.FromSeconds(4)); // Tried and true method for weather forecasting - random numbers Random rand = new Random(); if (rand.Next(2) == 0) return "rainy"; else return "sunny"; }Private Async Function FetchWeatherFromServerAsync() As Task(Of String) ' Simulate the delay from network access Await Task.Delay(TimeSpan.FromSeconds(4)) ' Tried and true method for weather forecasting - random numbers Dim rand As New Random() If rand.Next(2) = 0 Then Return "rainy" Else Return "sunny" End If End FunctionPara simplificar, não temos nenhum código de rede neste exemplo. Em vez disso, simulamos o atraso do acesso à rede colocando nosso novo thread em suspensão por quatro segundos. Nesse momento, o thread da interface do usuário original ainda está em execução e respondendo a eventos da interface do usuário enquanto o manipulador de eventos do botão é pausado até que o novo thread seja concluído. Para demonstrar isso, deixamos uma animação em execução e você pode redimensionar a janela. Se o thread da interface do usuário estivesse pausado ou atrasado, a animação não seria mostrada e você não poderia interagir com a janela.
Quando o
Task.Delayé concluído e selecionamos aleatoriamente nossa previsão do tempo, o status do tempo é retornado ao chamador.Atualizando a interface do usuário
private async void FetchButton_Click(object sender, RoutedEventArgs e) { // Change the status image and start the rotation animation. fetchButton.IsEnabled = false; fetchButton.Content = "Contacting Server"; weatherText.Text = ""; ((Storyboard)Resources["HideWeatherImageStoryboard"]).Begin(this); // Asynchronously fetch the weather forecast on a different thread and pause this code. string weather = await Task.Run(FetchWeatherFromServerAsync); // After async data returns, process it... // Set the weather image if (weather == "sunny") weatherIndicatorImage.Source = (ImageSource)Resources["SunnyImageSource"]; else if (weather == "rainy") weatherIndicatorImage.Source = (ImageSource)Resources["RainingImageSource"]; //Stop clock animation ((Storyboard)Resources["ShowClockFaceStoryboard"]).Stop(ClockImage); ((Storyboard)Resources["HideClockFaceStoryboard"]).Begin(ClockImage); //Update UI text fetchButton.IsEnabled = true; fetchButton.Content = "Fetch Forecast"; weatherText.Text = weather; }Private Async Sub FetchButton_Click(sender As Object, e As RoutedEventArgs) ' Change the status image and start the rotation animation. fetchButton.IsEnabled = False fetchButton.Content = "Contacting Server" weatherText.Text = "" DirectCast(Resources("HideWeatherImageStoryboard"), Storyboard).Begin(Me) ' Asynchronously fetch the weather forecast on a different thread and pause this code. Dim weatherType As String = Await Task.Run(AddressOf FetchWeatherFromServerAsync) ' After async data returns, process it... ' Set the weather image If weatherType = "sunny" Then weatherIndicatorImage.Source = DirectCast(Resources("SunnyImageSource"), ImageSource) ElseIf weatherType = "rainy" Then weatherIndicatorImage.Source = DirectCast(Resources("RainingImageSource"), ImageSource) End If ' Stop clock animation DirectCast(Resources("ShowClockFaceStoryboard"), Storyboard).Stop(ClockImage) DirectCast(Resources("HideClockFaceStoryboard"), Storyboard).Begin(ClockImage) ' Update UI text fetchButton.IsEnabled = True fetchButton.Content = "Fetch Forecast" weatherText.Text = weatherType End SubQuando a tarefa é concluída e o thread da interface do usuário tem tempo, o chamador de , o manipulador de
Task.Runeventos do botão, é retomado. O restante do método interrompe a animação do relógio e escolhe uma imagem para descrever o clima. Ele exibe esta imagem e ativa o botão "buscar previsão".
Um aplicativo de exemplo que demonstra os conceitos desta seção pode ser baixado do GitHub para C# ou Visual Basic.
Detalhes técnicos e pontos de tropeço
As seções a seguir descrevem alguns dos detalhes e pontos de tropeço que você pode encontrar com o multithreading.
Bombeamento aninhado
Às vezes, não é viável bloquear completamente o thread da interface do usuário. Vamos considerar o ShowMessageBox método da classe. Show não retorna até que o usuário clique no botão OK. No entanto, ele cria uma janela que deve ter um loop de mensagens para ser interativa. Enquanto aguardamos até que o usuário clique em OK, a janela do aplicativo original não responde à entrada do usuário. No entanto, ele continua processando mensagens de pintura. A janela original se redesenha quando é coberta e revelada.
Algum thread deve ser responsável pela janela da caixa de mensagem. O WPF poderia criar um novo thread apenas para a janela da caixa de mensagem, mas esse thread não poderia pintar os elementos desabilitados na janela original (lembre-se da discussão anterior sobre exclusão mútua). Em vez disso, o WPF usa um sistema de processamento de mensagens aninhado. A Dispatcher classe inclui um método especial chamado PushFrame, que armazena o ponto de execução atual de um aplicativo e inicia um novo loop de mensagem. Quando o loop de mensagem aninhado é concluído, a execução é retomada após a chamada original PushFrame .
Nesse caso, PushFrame mantém o contexto do programa na chamada para MessageBox.Show, e inicia um novo loop de mensagem para redesenhar a janela em segundo plano e manipular a entrada para a janela da caixa de mensagem. Quando o usuário clica em OK e limpa a janela pop-up, o loop aninhado é encerrado e o controle é retomado após a chamada para Show.
Eventos roteados obsoletos
O sistema de eventos roteados no WPF notifica árvores inteiras quando os eventos são gerados.
<Canvas MouseLeftButtonDown="handler1"
Width="100"
Height="100"
>
<Ellipse Width="50"
Height="50"
Fill="Blue"
Canvas.Left="30"
Canvas.Top="50"
MouseLeftButtonDown="handler2"
/>
</Canvas>
Quando o botão esquerdo do mouse é pressionado sobre a elipse, handler2 é executado. Após handler2 o término, o evento é passado para o Canvas objeto, que o usa handler1 para processá-lo. Isso acontece somente se handler2 não marcar explicitamente o objeto de evento como manipulado.
É possível que handler2 isso leve muito tempo para processar esse evento. handler2 pode ser usado PushFrame para iniciar um loop de mensagem aninhado que não retorna por horas. Se handler2 não marcar o evento como manipulado quando esse loop de mensagem for concluído, o evento será passado para cima na árvore, mesmo que seja muito antigo.
Reentrância e bloqueio
O mecanismo de bloqueio do CLR (Common Language Runtime) não se comporta exatamente como se poderia imaginar; Pode-se esperar que um thread interrompa completamente a operação ao solicitar um bloqueio. Na realidade, o thread continua recebendo e processando mensagens de alta prioridade. Isso ajuda a impedir bloqueios e torna a interface minimamente dinâmica, mas introduz a possibilidade de bugs sutis. Na grande maioria das vezes, você não precisa saber nada sobre isso, mas em circunstâncias raras (geralmente envolvendo mensagens de janela Win32 ou componentes COM STA), pode valer a pena saber disso.
A maioria das interfaces não é criada com a segurança de thread em mente porque os desenvolvedores trabalham sob a suposição de que uma interface do usuário nunca é acessada por mais de um thread. Nesse caso, esse único thread pode fazer mudanças ambientais em momentos inesperados, causando os efeitos nocivos que o mecanismo de DispatcherObject exclusão mútua deve resolver. Considere o seguinte pseudocódigo:
Na maioria das vezes, isso é a coisa certa, mas há momentos no WPF em que essa reentrada inesperada pode realmente causar problemas. Portanto, em determinados momentos-chave, o WPF chama DisableProcessing, que altera a instrução de bloqueio desse thread para usar o bloqueio livre de reentrância do WPF, em vez do bloqueio CLR usual.
Então, por que a equipe do CLR escolheu esse comportamento? Isso tinha a ver com objetos COM STA e com o thread de finalização. Quando um objeto é coletado como lixo, seu Finalize método é executado no thread do finalizador dedicado, não no thread da interface do usuário. E é aí que reside o problema, porque um objeto COM STA que foi criado no thread da interface do usuário só pode ser descartado no thread da interface do usuário. O CLR faz o equivalente a um BeginInvoke (neste caso, usando o ).SendMessage Mas se o thread da interface do usuário estiver ocupado, o thread do finalizador será interrompido e o objeto COM STA não poderá ser descartado, o que cria um vazamento de memória sério. Portanto, a equipe do CLR tomou a decisão difícil de fazer com que os bloqueios funcionassem da maneira que funcionam.
A tarefa do WPF é evitar a reentrância inesperada sem reintroduzir o vazamento de memória, e é por isso que não bloqueamos a reentrância em todos os lugares.
Confira também
.NET Desktop feedback