C# WPF Async at startup

Question

I try to build a simple WPF application and have a listbox in the MainWindow. The background is that it pings some machines but I want that the GUI already opens and whenever the ping finishes, the listbox should update the content.

Let me show my code. MainWindow.xaml.cs

        public ObservableCollection<String> LbStatus
        {
            get { return BL.GetStatus(); }
        }

BL.cs

        public static ObservableCollection<string> GetStatus()
        {
            List<string> hostnames = new List<String>(GetHostnames());

            ObservableCollection<string> status = new ObservableCollection<string>();
 
            foreach(string hostname in hostnames)
            {
                Task<string> task = Task.Run(async () => await 
 PingHost(HM.GetHostname(hostname)));
                status.Add(task.Result); 
            }
            return status; 
        }

        static public async Task<string> PingHost(string hostname)
        {
            Ping x = new Ping();
            try
            {
                PingReply reply = await x.SendPingAsync(hostname, 5000);
                if (reply.Status == IPStatus.Success)
                {
                    return "Online";
                }
                else
                    return "Offline";
            }
            catch (Exception excep)
            {
                //exception handling
            }
        }

I think the problem is that my program waits for task.result. But in my head, it should just skip and return nothing and whenever it's finished it should return the correct string. But (and that's the whole reason why I do this) the GUI should already start.

I hope my question makes sense and someone can help me with that :-)

Thanks!

Answer 1

Your issue is related to the property getter. First, this is a really good question to get background on before continuing: Do you have to put Task.Run in a method to make it async?

Having that reference, your method PingHost is written properly to be awaited, but it being async does not necessarily mean it is not going to block the calling thread. This has to do with how you're calling it, by a property getter - which is done synchronously. You call it from a synchronous method GetStatus, and then are accessing that synchronous method through a property getter. And so, despite calling an async method PingHost, it's not being awaited and therefore is blocking the calling thread.

Edit note: Even if this was written to properly await through different calls, property getters are accessed synchronously so the below explanation still applies.

This brings up a second reference to read up on, related to asynchronous getters. I think this answer is really touching on what you're trying to do, particularly item two in that answer:

A value that can be used in data-binding but must be calculated/retrieved asynchronously. In this case, either use an async factory method for the containing object or use an async InitAsync() method. The data-bound value will be default(T) until the value is calculated/retrieved.

This person wrote a really nice blog post explaining how to implement this, I encourage you to check it out: https://blog.stephencleary.com/2013/01/async-oop-3-properties.html

Answer 2

I would suggest you introduce a few changes.
First, you have a very dubious implementation of the LbStatus property.
In such an implementation, each time this property is accessed, a new collection will be created, which could potentially cause: their different states; simultaneous call several times of the BL.GetStatus() method. And there are many other problems associated with the presence of multiple collection instances, but when the view "thinks" that this is the same instance.
By offering you this implementation of this property:

private ObservableCollection<string> _lbStatus;
public ObservableCollection<string> LbStatus
{
    get 
    {
        if (_lbStatus == null)
            _lbStatus = BL.GetStatus();
        return _lbStatus;
    }
}

The second problem, in the method BL.GetStatus() - you need to return the collection without waiting for its completion.
Therefore, the loop for filling it should be in a separate asynchronous method.
The BL.GetStatus() method should call this asynchronous method, but not wait for it to complete.

I suggest you this implementation:

public static ObservableCollection<string> GetStatus()
{
    ObservableCollection<string> status = new ObservableCollection<string>();

    FillStatus(status);

    return status;
}

public static async Task FillStatus(ICollection<string> status)
{
    foreach (string hostname in GetHostnames())
    {
        status.Add(await PingHost(HM.GetHostname(hostname)));
    }
}

Another option for implementing the property, taking into account the division of the method into two parts.
It will only use the asynchronous part.

private ObservableCollection<string> _lbStatus;
public ObservableCollection<string> LbStatus
{
    get 
    {
        if (_lbStatus == null)
        {
            _lbStatus = new ObservableCollection<string>();
            BL.FillStatus(_lbStatus);
        }
        return _lbStatus;
    }
}

Taking into account the use of the collection in UI elements, its change should take place in the main UI thread. To do this, you will have to pass the Dispatcher to the method.

public static async Task FillStatus(ICollection<string> status, Dispatcher dispatcher)
{
    foreach (string hostname in GetHostnames())
    {
        string item = await PingHost(HM.GetHostname(hostname));
        dispatcher.BeginInvoke(new Action(() => status.Add(item)))
    }
}

private ObservableCollection<string> _lbStatus;
public ObservableCollection<string> LbStatus
{
    get 
    {
        if (_lbStatus == null)
        {
            _lbStatus = new ObservableCollection<string>();
            BL.FillStatus(_lbStatus, Dispatcher);
        }
        return _lbStatus;
    }
}