How to handle IO-heavy workload at WPF Application startup

Question

I'm currently trying to write a simple C#-WPF-Application that functions as a simple universal 'launcher'. For different applications we program.

It's purpose is to check the current software version of the 'real' software and if a new one is available it starts to copy the installer from a network share and runs the installer afterwards. Then it starts the 'real' application and thats it.

The user Interface mainly consists of a startup window which shows the user the currently executed action (version check, copy, installation, startup, ...).

Now I create my view and my viewModel in the overridden StartUp method in App.cs

public override OnStartup(string[] args)
{
    var viewModel = new StartViewModel();
    var view = new StartView();

    view.DataContext = viewModel;

    view.Show();

    // HERE the logic for the Launch starts
    Task.Run(() => Launch.Run(args));
}

The problem is that if I don't go async here the Main Thread is blocked and I cannot update the UI. Therefore I got it working by using the Task.Run(...). This solves my problem of blocking the UI thread, but I have some problems/questions with this:

1. I cannot await the task, because that would block the UI again. Where to await it?
2. Is my concept of starting this workflow here ok in the first place?

---

Some update to clarify: After I show the UI to the user my logic starts to do heavy IO stuff. The possible calls I came up with are the following 3 variants:

view.Show();

// v1: completely blocks the UI, exceptions are caught
DoHeavyIOWork();

// v2: doesn't block the UI, but exceptions aren't caught
Task.Run(() => DoHeavyIOWork());

// v3: doesn't block the UI, exceptions are caught
await Task.Run(() => DoHeavyIOWork());

Currently I'm not at my work PC so i apologies for not giving you the original code. This is an on the fly created version.

I guess v1 and v2 are bad because of exceptions and the UI blocking.

I thought v3 didn't work when I tried it in my office. Now it seems to work in my local example. But I'm really not sure about v3. Because I'm using async void StartUp(...) there. Is it okay here?

Answer 1

I cannot await the task, because that would block the UI again. Where to await it?

await doesn't block the UI. Using await here is fine.

Is my concept of starting this workflow here ok in the first place?

I usually recommend that some UI is shown immediately when doing any asynchronous operation. Then when the async operation is complete, you can update/replace the UI.

Answer 2

Thanks for all the replys. After reading all your comments and combining some of your answers I came up with the following example. It is working under all circumstances I tested.

Hopefully there is not to much wrong in your opinion.

Code behind from App.xaml.cs

public partial class App : Application
{
    readonly StartViewModel viewModel = new StartViewModel();

    protected override async void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);

        var view = new StartWindow
        {
            DataContext = viewModel
        };

        view.Show(); // alternative:  Run(view);

        // alternative: instead of calling it here it is possible
        //              to move these calls as callback into the Loaded of the view.
        await Task.Run(() => DoHeavyIOWork()); 
    }
        
    private string GenerateContent()
    {
        var content = new StringBuilder(1024 * 1024 * 100); // Just an example.
        for (var i = 0; i < 1024 * 1024 * 2; i++)            
            content.Append("01234567890123456789012345678901234567890123456789");

        return content.ToString();
    }

    private void DoHeavyIOWork()
    {
        var file = Path.GetTempFileName();

        for (var i = 0; i < 20; i++)
        {
            File.WriteAllText(file, GenerateContent());
            File.Delete(file);

            Dispatcher.Invoke(() => viewModel.Info = $"Executed {i} times.");
        }
    }
}

Code in StartViewModel.cs

class StartViewModel : INotifyPropertyChanged
{
    private string info;

    public event PropertyChangedEventHandler PropertyChanged;

    public string Info
    {
        get => info; 
        set
        {
            info = value;
            OnPropertyChanged();
        }
    }

    private void OnPropertyChanged([CallerMemberName] string propertyName = "")
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}