C# einfachen Hintergrund Thread

Question

Ich bin auf der Suche nach einer einfachen Möglichkeit, eine Aufgabe im Hintergrund zu tun, dann etwas (im Haupt-Thread) zu aktualisieren, wenn es abgeschlossen ist. Es ist in einer niedrigen 'Model' Klasse, so dass ich InvokeOnMainThread nicht aufrufen kann, da ich kein NSObject habe. Ich habe diese Methode:

public void GetItemsAsync(Action<Item[]> handleResult) 
{ 
    Item[] items=null; 
    Task task=Task.Factory.StartNew(() => 
    { 
    items=this.CreateItems(); // May take a second or two 
    }); 
    task.ContinueWith(delegate 
    { 
    handleResult(items); 
    }, TaskScheduler.FromCurrentSynchronizationContext()); 
} 

Dies scheint gut zu funktionieren, aber

1) Ist dies der beste (einfachste) Weg?

2) Ich mache mir Sorgen um die lokale Variable:

Item{} items=null 

Was hört auf, dass verschwindet, wenn die Methode zurückgibt, bevor der Hintergrund-Thread beendet?

Danke.

Answer 1

Ich denke, Ihre Methode leicht ein Single Responsibility Principle verletzt, weil es zu viel zu tun.

Vor allem schlage ich vor, CreateItems zu ändern zurückzukehren Task anstatt es in den GetItemsAsync die Verpackung:

public Task<Item[]> CreateItems(CancellationToken token) 
{ 
    return Task.Factory.StartNew(() => 
    // obtaining the data... 
    {}); 
} 

CancellationToken optional ist, aber können Ihnen helfen, wenn Sie diesen langen Lauf Vorgang abbrechen können.

Mit dieser Methode können Sie GetItemsAsync ganz, weil sein so einfach entfernen Ergebnisse von Ihrem Kunden zu handhaben, ohne diese Delegierten vorbei:

// Somewhere in the client of your class 
var task = yourClass.CreateItems(token); 
task.ContinueWith(t => 
// Code of the delegate that previously 
// passed to GetItemsAsync method 
{}, TaskScheduler.FromCurrentSynchronizationContext()); 

Mit diesem Ansatz Sie freiere Code mit nur einer Verantwortung bekommen. Task Klasse selbst ist ein perfektes Werkzeug für die Darstellung asynchroner Betrieb als first class object. Mit der vorgeschlagenen Technik können Sie Ihre aktuelle Implementierung mit einem falschen Verhalten für Komponententests leicht verspotten, ohne den Code Ihres Clients zu ändern.

Answer 2

Ihr Code sieht gut aus.

Es ist ein perfektes Beispiel für die Verwendung async/await, wenn Sie C# 5 verwenden können, aber wenn nicht, müssen Sie es schreiben, wie Sie mit Fortsetzungen getan haben.

Die items Variable wird in Ihren Lambdas erfasst, also ist das auch in Ordnung.

Wenn Sie ein Lambda schreiben, das eine äußere Variable verwendet, erstellt der C# -Compiler eine Klasse, die die Variable enthält. Dies wird als Schließung bezeichnet und bedeutet, dass Sie auf die Variable in Ihrem Lambda zugreifen können. Hier

Answer 3

ist ein schöner soultion:

public void GetItemsAsync(Action<Item[]> handleResult) 
    { 
     var task = Task.Factory.StartNew<Item[]>(() => 
     { 
      return this.CreateItems(); // May take a second or two 
     }); 

     task.ContinueWith(delegate 
     { 
      handleResult(task.Result); 
     }, TaskScheduler.FromCurrentSynchronizationContext()); 
    } 

Answer 4

Etwas wie folgt aus:

public void GetItemsAsync(Action<Item[]> handleResult) 
    { 
     int Id = 11; 
     Task<Item[]> task = Task.Factory.StartNew(() => CreateItems(Id)); // May take a second or two 
     task.ContinueWith(t => handleResult(t.Result), TaskScheduler.FromCurrentSynchronizationContext()); 
    }