Progress message is not in correct order

Question

Playing with Progress class:

static async Task MyMethodAsync(IProgress<double> progress = null)
{
    int done = 0;
    while (done<100)
    {
        if (progress != null)
            progress.Report(done);
        done++;
    }
}

static async Task CallMyMethodAsync()
{
    var progress = new Progress<double>();
    progress.ProgressChanged += (sender, args) =>
        {
            Console.WriteLine("progr " + args);
        };
    await MyMethodAsync(progress);
}

public static void Main()
{
    CallMyMethodAsync();
    Console.WriteLine("done with caller");
    Console.ReadLine();
}

Got output not in correct order:

done with caller
progr 2
progr 3
progr 4
progr 5
progr 6
progr 7
progr 8
progr 9
progr 10
progr 12
progr 11
progr 0
progr 13
progr 16
progr 17
progr 18
progr 19
progr 20
progr 21
progr 22
progr 23
progr 24
progr 25
progr 26

Why and how to achieve correct order?

Answer 1

The Progress<T> class is asynchronous. It reports the progress in a different thread, since it is a console app, as Damien_The_Unbeliever explains:

Those don't have Synchronization Contexts and so Progress callbacks are serviced on the Thread Pool. So you don't know when they'll actually be scheduled and multiple callbacks may be in flight at the same time and then be competing for the Console lock to actually perform their writes

You can make your own implementation of IProgress<T>, which is synchronous. Use this one:

public class MyProgress<T> : IProgress<T>
{
    public event ProgressChangedEventHandler<T> ProgressChanged;

    public void Report(T value)
    {
        ProgressChanged?.Invoke(this, value);
    }
}

public delegate void ProgressChangedEventHandler<T>(object sender, T progress);

You just have to change your calling code to:

var progress = new MyProgress<double>();

Answer 2

What you mean with "block and done with...".

The Progress class is asynchronous. It reports the progress in a different thread, since it is a console app, as Damien_The_Unbeliever explains:

This post should explain why you can "lose" some calls.

I have feeling i'm far from details of your application but the simple question is do you really need to provide multithreading solution for this?

If you really need execute process in other thread and update UI you can use next logic:

class Class1
{
    public delegate void ProcessProgressEventHandler(int progress);
    public ProcessProgressEventHandler ProcessProgress;
    public EventHandler ProcessEnd;
    public void StartHeavyProcess()
    {
        System.Threading.Thread vThread = new System.Threading.Thread(HeavyProcess);
        ProcessProgress += OnProgress;
        ProcessEnd += OnProcessEnd;
        vThread.Start();
    }

    private void OnProcessEnd(object sender, EventArgs e)
    {
        Console.WriteLine("Process end!");
    }

    private void OnProgress(int progress)
    {
        Console.WriteLine("Progress: " + progress.ToString());
    }

    public void HeavyProcess()
    {
        int done = 0;
        while (done < 100)
        {
            if (ProcessProgress != null)
                ProcessProgress(done);
            done++;
        }
        if (ProcessEnd != null)
            ProcessEnd(this, new EventArgs());
    }
}

P.S. Pay attention if your handler call windows control moethods you must Invoke method in UI thread!

Answer 3

The result you get because you use Task which start new thread.

public static void Main()
{
    CallMyMethodAsync();
    Console.WriteLine("done with caller");
    Console.ReadLine();
}

For example first command 'CallMyMethodAsync();' just start new process and next command 'Console.WriteLine("done with caller");' is executed before end of process started on first step. If you want to execute command from line 2 after end of process started on line 1 it is:

public static void Main()
{
    CallMyMethodAsync()**.Wait();**
    Console.WriteLine("done with caller");
    Console.ReadLine();
}

Answer 4

Ok, Reason for that is you use "events" but "Event dispatcher" does not guarantee that events will be processed chronologically.

The simpliest solution I know is to use delegate to inform for progress:

static async Task MyMethodAsync(Action<double> progress = null)
{
    int done = 0;
    while (done<100)
    {
        if (progress != null)
            progress.Invoke(done);
        done++;
    }
}