Sagen Sie zwei Methoden in WCF von der Client-Seite aufrufen, mit einem Web-Methode rekursiv (oder vielmehr iterativ), um die anderen Web-Methode in einer Art verschachtelte Weise aufrufen. Ein einfaches Beispiel unten im Pseudo-Code, das funktioniert, aber ich denke nicht, dass ich die richtige Ausnahmebehandlung an Ort und Stelle habe. Was ist die beste Entwurfsvorlage für den Client und für den Server, um Situationen zu behandeln, in denen der Server ausfällt?WCF-Design-Vorlage für verschachtelte asynchrone Methoden erforderlich (vor allem Silverlight)
las ich die Referenzen 1-3 unten, und sie scheinen Sie die Dinge auf dem Client oder Server-Seite werden Entsorgung bedeuten muss - dies richtig ist?
Ich benutze WCF in Silverlight 3.5, mit Visual Studio 2008 mit C# als die Code-hinter-Sprache, aber ich denke nicht, dass das so wichtig ist, da dies eine universelle Frage ist.
// Pseudo-Code:
// übernehmen FirstWebService eine Sammlung von Objekten zurückgibt, sagen MyObjects, in einer Liste // übernehmen SecondWebservice diese Sammlung nimmt und macht etwas mit ihm.
ServiceReference1.Service1Client AClient; private Liste myObjectList = new List();
public Page1() { InitializeComponent();
AClient = new myWebService.ServiceReference1.Service1Client();
aClient.FirstWebService + = new Eventhandler (aClient_FirstWebServiceCompleted);
aClient.SecondWebServiceCompleted + = new Eventhandler (aClient_SecondWebServiceCompleted);
}
// jetzt, wenn Sie auf die Schaltfläche klicken, werden Sie die erste Web-Service aufrufen, die dann die zweite Web-Service-Aufruf wird (oft), bis die foreach-Schleife erschöpft ist.
private void Button1_Click (Objekt Absender, RoutedEventArgs e) { aClient.FirstWebServiceAsync(); // ruft ersten Web-Service (die wiederum einen zweiten Web-Service "rekursiv" (oder tatsächlich wiederholt), siehe unten nennen)
}
Leere aClient_FirstWebServiceCompleted (object sender, myWebService.ServiceReference1.FirstWebServiceCompletedEventArgs e) {
if (e.Error == null)
{
myObjectList = e.Result; //assume both server side myObject and client side myObject are the same thing, so no type checking compiler error here with the Lists.
// Hier ist die 'rekursive' (Schleife) Teil:
foreach (myObject O in myObjectList) { aClient.SecondWebServiceAsync (O); // beachte den rekursiven, verschachtelten asynchronen Aufruf vom ersten Web-Service zum zweiten Web-Service hier ... mehrmals, bis die foreach-Schleife erschöpft ist. } }
else
{
//handle errors here
}
}
Leere aClient_SecondWebServiceCompleted (object sender, myWebService.ServiceReference1.SecondWebServiceCompletedEventArgs e) {
if (e.Error == null)
{
// do stuff here = e.Result; //etc
} sonst { // Fehlerfalle hier, seit e.Error! = null } }
/* // Ich habe das obige versucht und es funktioniert, und hat noch nicht versagt. Sie haben jeden Webservice "asynchron". Bis jetzt hat es funktioniert Ok, aber die Web-Methoden sind nicht kompliziert und vielleicht hat es deshalb funktioniert. Aber ich glaube nicht, dass ich das richtige Gerüst für den Fall habe, dass der Web-Service versagt - sagen wir, er wurde durch einen Stromausfall abgeschaltet? Ich habe das schlechte Gefühl, dass ich Fehler bekomme. Wie man es robuster macht? Die ersten und zweiten Web-Services sind LINQ to SQL-Methoden, die in 'using' -Blöcke mit TransactionScope eingebettet sind, um ein Rollback der Methoden zu ermöglichen, falls sie auf der Serverseite fehlschlagen.
*/
Referenzen 1-3: (als Noob bin ich nicht schreiben mehr als eine Verbindung von Stack-Überlauf erlaubt, so dass ich nur den zweiten Link posten)
http://old.iserviceoriented.com/blog/post/Indisposable+-+WCF+Gotcha+1.aspx
siehe auch www.bluebytesoftware.com /blog/2008/02/18/IDisposableFinalizationAndConcurrency.aspx