Starten Sie die zweite Methode, nachdem die erste Methode mit Thread-Funktionalität beendet wurde C#

Question

Ich habe eine Methode, die den Produktkatalog eines Webshops neu erstellt. Dies ist notwendig, nachdem ich einige Produktinformationen geändert habe. Nach der Wiederherstellungs-Methode möchte ich eine zweite Methode starten, um den Volltextindex des Webshops zu erstellen. Ich kann den Status der ersten Methode (RebuildCatalog) beobachten. Wenn der Status "RebuildFinished" lautet, möchte ich die zweite Methode (GenerateFullTextIndex) starten. Ich möchte Thread-Funktionalität verwenden. Kann jemand ein Beispiel für die Implementierung dieses Szenarios erstellen?

Answer 1

Ich möchte Thread-Funktionalität verwenden.

Es klingt wirklich nicht wie du es tust. Das Starten einer Methode nach der anderen ist so einfach wie:

var status = RebuildCatalog(); 
if (status == Status.RebuildFinished) 
{ 
    GenerateFullTextIndex(); 
} 

Kein Threading erforderlich. Wenn Sie wirklich denken, Sie brauchen mehrere Threads, sollten Sie erklären warum Sie denken, sie werden Ihnen helfen. An welchem ​​Punkt müssen Sie mehrere Aufgaben gleichzeitig ausführen?

Answer 2

Da ich von Ihrer Frage ausgehen kann, benötigt Ihre Wiederherstellungsmethode wahrscheinlich viel Zeit und deshalb möchten Sie in einem separaten Thread laufen. Daher würde ich vorschlagen, Event based async pattern zu implementieren. Wenn die Methode zum erneuten Erstellen (async) abgeschlossen ist, wird das fertige Ereignis mit AsyncCompletedEventArgs (das Sie zur Weitergabe des Ergebnisstatus ableiten können) ausgelöst und von dort aus starten Sie Ihre zweite Methode.

Answer 3

Nun, wenn Sie ein mehrere Threads verwenden möchten, und Ihre Anrufe in Kette organisierne so werden sie auf einem anderen Thread ausgeführt werden, sondern in der Reihenfolge, und Sie verwenden .NET Framework 4.0>, können Sie eine Task Parallelism verwenden, wie zum Beispiel unter Verwendung von Task::ContinueWith Methode.

Beispiel (preudocode von MSDN):

Task<byte[]> getData = new Task<byte[]>(() => GetFileData()); 
Task<double[]> analyzeData = getData.ContinueWith(x => Analyze(x.Result)); 
Task<string> reportData = analyzeData.ContinueWith(y => Summarize(y.Result)); 
getData.Start(); 

      //or... 
Task<string> reportData2 = Task.Factory.StartNew(() => GetFileData()) 
       .ContinueWith((x) => Analyze(x.Result)) 
       .ContinueWith((y) => Summarize(y.Result)); 

Answer 4

Ereignisse verwenden würde zu sein scheinen einfacher als den Status beobachten.

In Ihrem Katalog Code Feuer einer "fertigen" Veranstaltung nach Abschluss neu zu erstellen:

public event EventHandler<EventArgs> RebuildFinished; 

private void Rebuild(...) 
{ 
    // Rebuild the catalog 

    this.RebuildFinished(this, new EventArgs(...)); 
} 

es dann handhaben:

this.catalog.RebuildFinished += this.RebuildFinished; 

private void RebuildFinished(object sender, EventArgs e) 
{ 
    // Rebuild the index 
} 

nun diese beiden können (und wahrscheinlich sollte) auf die Verwendung von Threads sein sicherzustellen, dass die Benutzeroberfläche der Anwendung bleibt ansprechbar:

this.catalogThread = new Thread(new ThreadStart(this.catalog.Rebuild)); 

Answer 5

BackgroundWorker bw1 = new BackgroundWorker();//To rebuild catalog. 
BackgroundWorker bw2 = new BackgroundWorker();//To generate text. 

public Form1() 
{ 
    InitializeComponent(); 

    bw1.DoWork += bw1_DoWork; 
    bw1.RunWorkerCompleted += bw1_RunWorkerCompleted; 
    bw2.DoWork += bw2_DoWork; 
    bw2.RunWorkerCompleted += bw2_RunWorkerCompleted; 

    bw1.RunWorkerAsync();//Start new thread. - Rebuild catalog. 
} 

void bw1_DoWork(object sender, DoWorkEventArgs e) 
{ 
    //Rebuild catalog. 
} 

void bw1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) 
{ 
    bw2.RunWorkerAsync();//Generate text. 
} 

void bw2_DoWork(object sender, DoWorkEventArgs e) 
{ 
    //Generate text. 
} 

void bw2_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) 
{ 
    //Whatever... 
}