C# / .NET Kompendium PLEN
.NET / C# / WPF

SynchronizationContext i ConfigureAwait - dogłębne wyjaśnienie

Punkt wyjścia: co to jest SynchronizationContext

SynchronizationContext to abstrakcja w .NET reprezentująca "gdzie" powinien wykonać się kod - a konkretniej, dostarcza mechanizm do "zaplanowania" wykonania delegata na odpowiednim wątku/kontekście.

Różne środowiska mają różne implementacje: - WPF/WinForms - DispatcherSynchronizationContext - kolejkuje pracę na jeden konkretny wątek UI (bo WPF ma model STA - Single Threaded Apartment, tylko wątek UI może dotykać obiektów wizualnych) - ASP.NET Core - nie ma SynchronizationContext (celowo usunięty w Core, w przeciwieństwie do starego ASP.NET), bo w Core nie ma pojęcia "wątku żądania" - requesty są obsługiwane przez pulę wątków bez przywiązania - Konsola / usługa w tle - brak SynchronizationContext (jest null)

Co dokładnie robi await

To jest sedno sprawy - await to nie magia, tylko cukier składniowy nad maszyną stanów. Kompilator generuje coś na kształt:

// To co piszesz:
public async Task LoadUserAsync()
{
    var user = await _userService.GetUserAsync("123");
    User = user; // UI update
}

...kompiluje się (w uproszczeniu) do czegoś takiego:

public Task LoadUserAsync()
{
    // 1. ZANIM await się zacznie - przechwytuje bieżący SynchronizationContext
    var capturedContext = SynchronizationContext.Current;

    var task = _userService.GetUserAsync("123");

    task.ContinueWith(completedTask =>
    {
        var user = completedTask.Result;

        // 2. PO zakończeniu await - jeśli kontekst był przechwycony,
        // "wraca" na niego zamiast wykonać kontynuację na wątku,
        // na którym task się zakończył
        if (capturedContext != null)
        {
            capturedContext.Post(_ =>
            {
                User = user; // ✅ wykonuje się z powrotem na UI thread
            }, null);
        }
        else
        {
            User = user; // wykonuje się na tym wątku, na którym task się skończył
        }
    });

    return task;
}

Kluczowy moment: w momencie napotkania await, runtime robi zdjęcie SynchronizationContext.Current z wątku, na którym await zostało wywołane. Jeśli to jest wątek UI WPF, SynchronizationContext.Current to DispatcherSynchronizationContext powiązany z konkretnym Dispatcher-em tego okna.

Gdy asynchroniczna operacja się skończy (np. HttpClient.GetAsync zakończy się na jakimś wątku z puli wątków w tle), runtime nie wykonuje dalszej części metody na tym wątku tła - zamiast tego woła capturedContext.Post(...), co przekazuje pracę z powrotem do kolejki Dispatchera wątku UI. Dispatcher wykona tę kontynuację, gdy tylko przetworzy swoją kolejkę wiadomości (message loop) - czyli "gdy będzie wolny".

Dlaczego to jest potrzebne - konkretny scenariusz

private async Task LoadUserAsync()
{
    IsLoading = true; // (A) UI thread

    var user = await _userService.GetUserAsync("123"); // request HTTP - wątek tła

    User = user;        // (B) - MUSI wrócić na UI thread
    IsLoading = false;   // (C) - MUSI wrócić na UI thread
}

User to prawdopodobnie właściwość bindowana w XAML ({Binding User.Name}). Gdy ją ustawisz, WPF wywoła PropertyChanged, co triggeruje aktualizację elementów wizualnych (TextBlock, etc.). Elementy wizualne w WPF mają wbudowaną kontrolę wątku (tzw. "thread affinity") - próba dotknięcia ich z innego wątku niż ten, na którym zostały utworzone, rzuca:

System.InvalidOperationException: The calling thread cannot access this object
because a different thread owns it.

Dzięki temu, że await domyślnie "pamięta" skąd wystartował i wraca tam automatycznie, linie (B) i (C) bezpiecznie wykonują się z powrotem na wątku UI - mimo że fizyczne pobieranie danych z API działo się w tle, na wątku z puli. To jest dokładnie dlatego kod, który pisaliśmy wcześniej w ViewModelu, po prostu "działał" bez ręcznego Dispatcher.Invoke.

Co robi ConfigureAwait(false)

var user = await _userService.GetUserAsync("123").ConfigureAwait(false);
User = user; // ⚠️ NIE MA GWARANCJI, że to jest UI thread!

ConfigureAwait(false) mówi runtime: "nie przechwytuj SynchronizationContext, kontynuuj na jakimkolwiek wątku, na którym task się skończył" (zwykle jakiś wątek z ThreadPool). Efekt:

  • Pomija krok "zdjęcia" kontekstu i powrotu przez Post()
  • Trochę szybsze (mniej narzutu na przełączanie kontekstu)
  • Ale: wszystko po tym await w tej metodzie wykonuje się na nieznanym wątku tła - a jeśli spróbujesz stamtąd dotknąć czegokolwiek związanego z UI (property bindowane w XAML, elementy wizualne), dostaniesz InvalidOperationException

Dlaczego w ViewModelu WPF zwykle NIE chcesz ConfigureAwait(false)

W typowym ViewModelu prawie każda metoda kończy się aktualizacją jakiejś właściwości bindowanej do UI:

private async Task LoadUserAsync()
{
    IsLoading = true;
    var user = await _userService.GetUserAsync("123").ConfigureAwait(false);

    // ❌ BŁĄD w runtime - jesteśmy teraz na wątku tła (ThreadPool),
    // a User jest bindowane do TextBlock w UI
    User = user;
    IsLoading = false; // też błąd
}

Gdybyś chciał użyć ConfigureAwait(false), musiałbyś ręcznie wrócić na UI thread za każdym razem, kiedy chcesz zaktualizować cokolwiek bindowanego:

private async Task LoadUserAsync()
{
    IsLoading = true;
    var user = await _userService.GetUserAsync("123").ConfigureAwait(false);

    await Application.Current.Dispatcher.InvokeAsync(() =>
    {
        User = user;
        IsLoading = false;
    });
}

To dużo więcej boilerplate'u i łatwo o pomyłkę (zapomnisz raz i masz trudny do odtworzenia bug produkcyjny). Dlatego domyślne zachowanie (bez ConfigureAwait(false)) jest w ViewModelach po prostu wygodniejsze i bezpieczniejsze - piszesz kod liniowo, "jakby" był synchroniczny, a await sam gwarantuje powrót na właściwy wątek.

Gdzie ConfigureAwait(false) faktycznie ma sens

W kodzie, który nie dotyka UI - typowo warstwa serwisów/repozytoriów/bibliotek, gdzie nie wiadomo (i nie powinno obchodzić), na jakim wątku się wykonasz:

// Serwis/repozytorium - nie ma pojęcia o WPF, UI, Dispatcherze
public class UserService : IUserService
{
    private readonly HttpClient _httpClient;

    public async Task<User> GetUserAsync(string id)
    {
        // Tu ConfigureAwait(false) ma sens - ten kod nigdy nie dotyka UI,
        // więc nie ma powodu "płacić" za przechwytywanie i powrót na kontekst
        var response = await _httpClient.GetAsync($"api/users/{id}").ConfigureAwait(false);
        var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
        return JsonSerializer.Deserialize<User>(json);
    }
}

To była (i częściowo nadal jest) rekomendowana praktyka w bibliotekach: "używaj ConfigureAwait(false) we wszystkim poza kodem, który musi wrócić na oryginalny kontekst" - żeby unikać zbędnego narzutu wydajnościowego i ryzyka deadlocków (patrz niżej) w kodzie biblioteki, który nie wie, kto go wywoła.

Bonus: klasyczny deadlock, który to tłumaczy jeszcze lepiej

To częste pytanie typu "gotcha" na rozmowach:

// W ViewModelu - ktoś próbuje "oszukać" async przez blokowanie
private void OnButtonClick(object sender, RoutedEventArgs e)
{
    var user = GetUserAsync().Result; // ❌ DEADLOCK w WPF!
}

private async Task<User> GetUserAsync()
{
    return await _userService.GetUserAsync("123"); // domyślnie przechwytuje kontekst UI
}

Co się dzieje krok po kroku: 1. OnButtonClick wykonuje się na UI thread, woła .Result - blokuje UI thread, czekając aż Task się skończy 2. GetUserAsync() startuje, dochodzi do await, przechwytuje SynchronizationContext (UI thread'a) 3. Faktyczny HTTP request kończy się na wątku z puli 4. Kontynuacja (return user) próbuje wrócić przez Post() na UI thread - ale UI thread jest zablokowany w kroku 1, czekając na .Result! 5. Deadlock - UI thread czeka na wynik Taska, a Task czeka, aż UI thread będzie wolny, żeby dokończyć

Gdyby GetUserAsync() użyło ConfigureAwait(false) wewnątrz, kontynuacja nie próbowałaby wracać na UI thread - wykonałaby się na wątku z puli, Task by się zakończył, i .Result w kroku 1 by się odblokował. To nadal zła praktyka (.Result w UI kodzie to code smell), ale pokazuje mechanikę problemu.

Poprawne rozwiązanie: nigdy nie blokuj async przez .Result/.Wait() w kodzie UI - używaj await od góry do dołu (tzw. "async all the way").


Podsumowanie w jednym zdaniu

await bez ConfigureAwait(false) domyślnie zapamiętuje, na jakim wątku/kontekście wystartował, i automatycznie tam wraca po zakończeniu operacji asynchronicznej - w WPF gwarantuje to bezpieczny powrót na UI thread bez ręcznego Dispatcher.Invoke; ConfigureAwait(false) wyłącza to zachowanie, co jest szybsze i bezpieczniejsze w bibliotekach/serwisach, ale niebezpieczne w ViewModelu, gdzie prawie zawsze kończysz dotykając czegoś bindowanego do UI.

Postaw mi kawę