如何在无限循环中使用异步/等待？

Question

I want to loop infinity to check all time n=0 or n=1

    public int check()
    {

        int n;

        Int32 nTest = 0;
        nTest = RID.Read(obj);

        if (nTest != 0)
        {
            n = 0;
        }
        else
        {
            n = 1;
        }

        return n;
    }

    private async void Form1_Load(object sender, EventArgs e)
    {
        Task<int> task = new Task<int>(check);
        task.Start();

        while (true)
        {
            int c = await task;

            label7.Text = c.ToString();
        }
    }

I try to while true in Form1_Load for start check n value. when I run program it will freezes and can not click anything. How to fix it ?

Answer 1

Async-await is meant to stop your program from waiting idly for another process to finish during a relatively short time. Think about waiting for the results of a database query, reading a file, fetching data from a database etc.

If you use async-await your thread won't wait idly while the other processing is doing the request. Instead if can look around to see if there are other things to do.

Of course you could accomplish the same effect by creating a separate thread to do the waiting for you. Apart from that this will make your code more complicated, creating a separate thread is fairly time consuming.

If you want to start a long-running process, think of seconds, maybe minutes or even longer, the time needed to start this separate thread is not important anymore.

So in your case, I'd advise to use a BackgroundWorker

If your background worker needs a lot of procedures to do its work, consider deriving from BackgroundWorker and start working in an override of BackgroundWorker.OnDoWork .

In your case the backgroundworker needs only a small function, so it will be enough to subscribe to the DoWork event.

Use your visual studio toolbox to add a backgroundworker, or add it manually in your constructor:

// Constructor:
public Form1()
{
    InitializeComponent();

    // Create a backgroundworker
    this.backgroundWorker = new BackgroundWorker
    {
        // only if you want to display something during processing:
        WorkerReportsProgress = true,

        WorkerSupportsCancellation = true; // to  neatly close your form 
    };

    this.backgroundWorker.DoWork += this.BackgroundProcedure;
    this.backgroundWorker.ProgressChanged += this.BackgroundProcessReport;
    this.backgroundWorker.RunworkerCompleted += this.BackgroundWorkerFinished;
}

Starting and stopping is easy:

bool IsBackGroundWorkerBusy => this.backgroundWorker.IsBusy;
void StartBackgroundWork()
{
    if (this.IsBackGroundWorkerbusy) return; // already started;

    this.DisplayBackgroundWorkerActive(); // for example, show an ajax loader 
    this.backgroundWorker.RunworkerAsync();

    // or if you want to start with parameters:
    MyParameters backgroundWorkerParameters = new MyParameters(...);
    this.backgroundWorker.RunworkerAsync(backgroundWorkerParameters);

}
void RequestCancelBackgroundWork()
{
    this.DisplayBackgroundWorkerStopping();
    this.backgroundWorker.CancelAsync();
}

Background procedure . It is executed by the background thread. You can't call any UI related function in this procedure. If you want to update anything in the UI, use ReportProgress.

void BackGroundProcedure(object sender, DoworkEventArgs e)
{
    // if you know that the backgroundworker is started with parameters:
    MyParameters parameters = (MyParameters)e.Argument;

    // do you work, regularly check if cancellation is requested:
    while (!e.Cancel)
    {
        ...

        // only if progress reports are needed: report some progress, not too often!
        MyProgressParams progressParams = new MyProgressParams(...);
        this.ReportProgress(..., progressParams);
    }

    // if here, the thread is requested to cancel
    // if needed report some result:
    e.Result = ...;
}

Progress Report . It is executed by your UI thread, so if desired you can update UI elements. This is the major functionality of this method.

The first parameter in report progress is a number, usually from 0..100, used by receivers of the progress event to update some visual display about progress. If you don't have any indication how long the progress needs, don't use the value. The progressParams can be any object.

void BackgroundProcessReport(object sender, ProgressChangedEventArgs e)
{
     // the background worker reported some progress.
     ... // update UI
}

Runworker Completed is called when the thread finishes. It contains the data assigned to e.Result. It is executed by the UI thread, so you can do any UI related stuff that you want:

void BackgroundWorkerFinished(object sender, RunWorkerCompletedEventArgs e)
{
    this.DisplayBackgroundWorkerFinished(); // for example: hide ajax loader

    ... // use e to process result
}

Neat Closure of your form

If your form is closing, the backgroundworker has to be finished before the window can be disposed. A proper method is using the OnClosing event:

bool closeFormRequested = false;

void OnFormClosing(object sender, CancelEventArgs e)
{
     // if background worker busy: request cancellation; can't close the form right now
     if (this.IsBackgroundworkerBusy)
     {
         this.closeFormRequested = true;
         e.Cancel = true;
         this.RequestCancelBackgroundWork();
     }
     else
     {   // background worker not busy, OK to close
         e.Cancel = false;
     }
}

After a while the backgroundworker reports that it is finished:

void BackgroundWorkerFinished(object sender, RunWorkerCompletedEventArgs e)
{
    this.DisplayBackgroundWorkerFinished(); 
    ... // process result

   // if requested: close the form:
   if (this.closeFormRequested)
       this.Close();
}

this.Close() will lead to OnFormClosing , but this time the background worker will not be busy, and closing will continue

Finally: a background worker implements IDisposable, don't forget to Dispose it when your form is Disposed.

Answer 2

You should use Microsoft's Reactive Framework (aka Rx) - NuGet System.Reactive.Windows.FOrms and add using System.Reactive.Linq; - then you can do this:

private async void Form1_Load(object sender, EventArgs e)
{
    IDisposable subscription =
        Observable
            .While(() => true, Observable.Start(() => RID.Read(obj) == 0 ? 1 : ))
            .ObserveOn(this)
            .Subscribe(c => label7.Text = c.ToString());
}

That's your entire code.

Answer 3

when I run program it will freezes and can not click anything.

This is because the task is only started once. After it completes, it stays completed, so the first await asynchronously waits for the task to complete, but all the other await s just return that first value, immediately and synchronously. This is why you can't click anything: you end up with a synchronous infinite loop on your UI thread.

To fix this, I recommend using Task.Run to start the background task. Task.Run is far less error-prone than the task constructor and Start .

private async void Form1_Load(object sender, EventArgs e)
{
  while (true)
  {
    int c = await Task.Run(() => check());
    label7.Text = c.ToString();
  }
}

Alternatively, if you wanted the infinite loop in your background code, you could use IProgress<T> to report progress to the UI thread:

private Task CheckForever(IProgress<int> progress)
{
  while (true)
  {
    var c = check();
    progress?.Report(c);
  }
}

private async void Form1_Load(object sender, EventArgs e)
{
  var progress = new Progress<int>(c => label7.Text = c.ToString());
  await CheckForever(progress);
}

Note that Task.Run code is always cleaner, easier to maintain, and more type-safe than BackgroundWorker code.