Versuche zu verstehen, die AsyncToken-in Flex/Actionscript

Ich versuche zu verstehen, wie sich die AsyncToken-Werke in actionscript. Wie kann ich rufen Sie einen remote-Dienst und stellen Sie sicher, dass ein bestimmter parameter ist verfügbar, in den Ergebnis-oder fault-Ereignis-Funktionen? Ich denke, es ist die async-Funktionalität, die ich verwenden möchten.

Dem folgenden code wird hoffentlich erklären, was ich zu tun versuche. Fühlen Sie sich frei ändern Sie den code-block als Ihre Erklärung.

Dank.

public function testSerivceCall(data:Object, callBackCommand:String):void
{
    //Assume callBackCommand == "FOO";
    //How can I pass in callBackCommand as a parameter to the result or fault events?
    //How do I create an async token here?

    var remoteObject:RemoteObject;
    remoteObject = new RemoteObject();
    remoteObject.destination = "zend";
    remoteObject.source = "MyService";
    remoteObject.endpoint = "http://example.com/service";
    remoteObject.test.addEventListener(ResultEvent.RESULT, _handleTestResult);
    remoteObject.test.addEventListener(FaultEvent.FAULT, _handleTestFault);
    remoteObject.test(data);
}

private function _handleTestResult( event:ResultEvent ) : void 
{ 
    //How do I get the async token value?
    //How can I get the value of callBackCommand in this code block?

    if (callBackCommand == "FOO")
    { 
        //do something related to "FOO"
    }
    else
    {
        //do something else with the result event
    }


} 

private function _handleTestFault( event:FaultEvent ) : void 
{ 
    //How do I get the async token value?
    //How can I get the value of callBackCommand in this code block?
}

Einen edit zu machen, diese Frage klar:

Nehme ich folgende Methode aufrufen, irgendwo in meinem code:

testSerivceCall(personObject, "LoginCommand");

Wie bekomme ich Zugang zu den eigentlichen string "LoginCommand" in der _handleTestResult Funktion blockieren?

Der Grund, warum ich dies tun wollen ist, weil ich möchte dynamisch zurück rufen bestimmte Funktionen und die Ergebnis-Daten auf bestimmte Befehle, die ich im Voraus wissen, wenn ich die service-Aufruf.

Ich bin nur eine Zeit grokking der AsyncToken-syntax und Funktionalität.

InformationsquelleAutor Gordon Potter | 2009-08-04

Wenn Sie wollen, um den Zugriff auf die Eigenschaften, die während der remote-Aufruf (Parameter, die dem Aufruf und/oder AsycToken), können Sie Gebrauch machen von Schließungen. Nur definieren Sie das result-Ereignis-handler im aufrufenden Methode als Verschluss. Es kann dann auf eine beliebige variable in der aufrufenden Funktion.

public function testSerivceCall(data:Object, callBackCommand:String):void
{
    var _handleTestResult:Function = function( event:ResultEvent ) : void 
    { 
        //token is visible here now
        if (callBackCommand == "FOO")
        { 
            //do something related to "FOO"
        }
        else
        {
            //do something else with the result event
        }
    }

    var remoteObject:RemoteObject;
    remoteObject = new RemoteObject();
    remoteObject.destination = "zend";
    remoteObject.source = "MyService";
    remoteObject.endpoint = "http://example.com/service";
    remoteObject.test.addEventListener(ResultEvent.RESULT, _handleTestResult);
    remoteObject.test.addEventListener(FaultEvent.FAULT, _handleTestFault);
    var token = remoteObject.test(data);
}

Ok, das macht Sinn, danke! Noch immer Griff-Verschlüsse.

InformationsquelleAutor Chetan Sastry

Habe ich noch nicht einmal Verschlüsse. Ich habe eine Klasse als unten, die ich extern aufgerufen.

Den Aufruf war so:

 public class MyClass
 {
    ...
    var adminServerRO:AdminServerRO = new AdminServerRO();
    adminServerRO.testSerivceCall("FOO",cptyId);
 }

public class AdminServerRO
{

   private function extResult( event:ResultEvent, token:Object ) : void
   {
       //the token is now accessed from the paremeter
        var tmp:String = "in here";
   }

   private function extFault( event:FaultEvent ) : void
   {
     var tmp:String = "in here";
   }


   public function testSerivceCall(callBackCommand:String, cptyId:String):void 
   { 
      var remoteObject:RemoteObject = new RemoteObject(); 
      remoteObject.destination = "adminServer"; 
      var token:AsyncToken = remoteObject.getCounterpartyLimitMonitorItemNode(cptyId);
      token.addResponder(new AsyncResponder(extResult,extFault,cptyId));
   }

}

InformationsquelleAutor will edwards

Während die akzeptierte Antwort wird erreichen, was mit dem ursprünglichen Urheber will es eigentlich nicht die Frage beantworten, was gefragt wurde. Ein AsyncToken-erstellt als Ergebnis ein Aufruf einer entfernten Methode und ist zugänglich von der ResultEvent. Da AsyncToken ist eine dynamische Klasse, die Sie hinzufügen können, was auch immer Eigenschaft, die Sie möchten. Der code unten soll veranschaulichen dies:

public function testSerivceCall(data:Object, callBackCommand:String):void
{

     var remoteObject:RemoteObject;
     remoteObject = new RemoteObject();
     remoteObject.destination = "zend";
     remoteObject.source = "MyService";
     remoteObject.endpoint = "http://example.com/service";
     remoteObject.test.addEventListener(ResultEvent.RESULT, _handleTestResult);
     remoteObject.test.addEventListener(FaultEvent.FAULT, _handleTestFault);
     var token:AsyncToken = remoteObject.test(data);
     token.callBackCommand = callBackCommand;
}

private function _handleTestResult( event:ResultEvent ) : void 
{ 

     if (event.token.callBackCommand == "FOO")
     { 
         //do something related to "FOO"
     }
     else
     {
         //do something else with the result event
     }


 } 

 private function _handleTestFault( event:FaultEvent ) : void 
 { 
      //event.token.callBackCommand should be populated here too
 }

InformationsquelleAutor Joe Newton

1

Wenn ich lese Ihre Frage richtig, Sie versuchen herauszufinden, wie der Zugriff auf die eigentlichen Daten zurückgegeben, die von der ResultEvent ?

Wenn das so ist, vorausgesetzt, Sie haben den Aufruf richtig und haben Sie bekommen die Daten zurück in ein format, das Sie erwarten sind:
```
private function _handleTestResult( event:ResultEvent ) : void 
{ 
  //you get the result from the result property on the event object
  //edit: assuming the class Person exists with a property called name
  //      which has the value "John"
  var person : Person = event.result as Person;

  if (person.name == "John")
  { 
      Alert.show("John: " + person.name);
  }
  else
  {
      Alert.show("Not John: " + person.name);
  }
} 

private function _handleTestFault( event:FaultEvent ) : void 
{ 
  //Maybe you know the type of the returned fault
  var expectedFault : Object = event.fault as MyPredefinedType

  if (expectedFault.myPredefinedTypesPredefinedMethod() == "BAR")
  {
    //something here
  }
}
```
Des ResultEvent hat eine Eigenschaft, die man als Ergebnis halten Sie eine Instanz des Objekts zurückgegeben, die durch das Ergebnis (es kann sein das die Ausgabe einer XML-Datei, wenn über einen web-service, oder ein serialisiertes Objekt, wenn die AMF, zum Beispiel). Dies ist, was Sie zugreifen möchten. Ebenso FaultEvent hat eine fault-Eigenschaft, gibt die Fehler-Informationen.

Edit: code Geändert in _handleTestResult() Antwort auf Gordon Potter ' s Kommentar.

Ok, ich denke, dies teilweise sinnvoll. Aber ich muss klarer sein, denke ich. Übernehmen Sie den obigen code, und dann nehme ich die folgenden Funktionsaufruf irgendwo in meinem Projekt: testSerivceCall(personObject, "John"); Jetzt in meinem Dienst Ergebnis wie erhalten Sie Zugriff auf die tatsächliche Zeichenfolge "John"? Vielleicht möchte ich einige sehr spezifische, wenn es ein person-Objekt enthält "John". Macht das Sinn?

InformationsquelleAutor Hooray Im Helping

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.