C＃（WPF）非同期スレッド、GUIへのインターフェイス

Question

このトピックを読んでいただきありがとうございます。

新しいWPFアプリケーション（C＃でビルド）については、デザインに関する質問があります。 ここ数日、私はC＃（.NET 4.5ベース）で非同期プログラミングについて多くのことを読んできました。

私たちがしたいことは：独立したバックグラウンドタスクを実行する新しい非同期スレッドを作成することです。このスレッドに利用可能なデータがある場合は、このデータを（パブリックインターフェイスによって）メインプログラムに送信します。したがって、スレッドはメインプログラムのデータを設定し、すぐに再びスレッドに戻ります。メインプログラムは、データが変更されたときにイベント（INotifyPropertyChanged）を発生させます。

この非同期スレッドを作成するにはどうすればよいでしょうか？または、少なくとも、この機能を設計するにはどうすればよいでしょうか？

現時点では、スレッドを作成するアプリケーションをビルドしました。 これは、現時点では非同期に動作しません。

public MainWindow() 
    { 
     InitializeComponent(); 

     InitGuiInterface(this); 

     //Create thread 
     new OuterLabel_Thread(this); 
    } 

そしてここで、以下のクラス "OuterLabel_Thread.cs"：事前に

public class OuterLabel_Thread 
{ 
    private MainWindow context = null; 
    private bool exit = false; 
    private int count = 0; 

    public OuterLabel_Thread(MainWindow context) 
    { 
     this.context = context; 

     Console.WriteLine("Running sample thread"); 
     Thread thread = new Thread(delegate() 
     { 
      Console.WriteLine("Sample thread started"); 

      //start new task 
      //run(); 
      Task.Factory.StartNew(run); 
     }); 
     thread.Start(); 
    } 

    public void Exit() 
    { 
     exit = true; 
    } 

    private void run() 
    { 
     while (!exit) 
     { 
      DateTime Time1 = DateTime.Now; 

      if (context != null && context.GuiInterface != null) 
      { 
       //context.GuiInterface.UpdateThreadCount(count, "label_code_content"); 
      } 
      Console.WriteLine("Background thread count = " + count); 

      count++; 
      if (count > 1000) 
      { 
       exit = true; 
      } 
      //Console.WriteLine((DateTime.Now - Time1).TotalMilliseconds.ToString()); 
      Thread.Sleep(10); 
     } 
    } 
} 

感謝を！ 種類：

Rein。

Answer 1

最良の方法は、非同期を使用しても+待つとタスクです。

private async void LaunchButton_OnClick(object sender, RoutedEventArgs e) 
    { 
     resultLabel.Content = "Task running"; 
     resultLabel.Content = await SomeLongRunningTaskAsync(); 
    } 

    private Task<string> SomeLongRunningTaskAsync() 
    { 
     return Task.Run(
      () => 
      { 
       // Put your background work in here. with Task.Run it's not going to run on UI 
       int count = 0; 
       while (count < 1000) 
       { 
        count++; 
        Thread.Sleep(10); 
       } 

       return "Task done"; 
      }); 
    } 

Answer 2

あなたはスレッドを生かしておきたいと思っていますが、わかっている限り、あなたは1000マークに到達するタイミングを正確にはわからないので、asyncが間違った選択になることがあります。私が間違っているなら私を訂正してください。あなたのケースでは

私は、BackgroundWorkerのを使用することをお勧めします：

private void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e) 
{ 
    int count = 0; 
    BackgroundWorker worker = sender as BackgroundWorker; 
     while (!exit) 
     { 
      DateTime Time1 = DateTime.Now; 
      worker.ReportProgress(count); 
      count++; 
      if (count > 1000) 
      { 
       exit = true; 
      } 
      Thread.Sleep(10); 
     } 
} 

// This event handler updates the progress. 
     private void BackgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e) 
     { 
      resultLabel.Text = ("Background thread count = " + e.ProgressPercentage.ToString()); 
     } 

    private void BackgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) 
    { 
     if (e.Cancelled == true) 
     { 
      resultLabel.Text = "Canceled!"; 
     } 
     else if (e.Error != null) 
     { 
      resultLabel.Text = "Error: " + e.Error.Message; 
     } 
     else 
     { 
      resultLabel.Text = "Done!"; 
     } 
    } 

Answer 3

サービスや長期実行タスクを探しているかどうかわかりません。

他の人が、私はそれはあなたが生産コードでこれを使用する前に、最大読みくださいSynchronizationContextのようないくつかの先進的なconcpetsを使用してサービス

を作った長時間実行されるタスクの良い例を持っているので。 Google asyncとStephen Clearyが待っています。

public partial class MainWindow : Window 
{ 
    public MainWindow() 
    { 
     InitializeComponent(); 

     var foo = new FooService(); 
     foo.StartService(); // UI thrad calling 
    } 
} 

public class FooService 
{ 
    private SynchronizationContext _context; 
    private CancellationTokenSource _cts; 
    private CancellationToken _token; 
    private Task _task; 

    public void StartService() 
    { 
     _context = SynchronizationContext.Current; // Depends on the UI thread being the one to start the service or this will fail 
     _cts = new CancellationTokenSource(10000); // Run for 10 seconds 
     _token = _cts.Token; 
     _task = Task.Run(() => Run(), _token); 
    } 

    public async Task Stop() 
    { 
     _cts.Cancel(); 
     await _task; // wait for task to finish 
    } 

    private void Run() 
    { 
     while (!_token.IsCancellationRequested) 
     { 
      // Do work     
      Thread.Sleep(1000); 
      // Alternative use Control.Invoke() if you have access to a UI element, to delegate to the UI thread 
      _context.Send((id) => Console.WriteLine($"Delegate from thread {id} to thread {Thread.CurrentThread.ManagedThreadId}"), Thread.CurrentThread.ManagedThreadId); 
     } 
    } 
}