Délégués C# vers Java et traitement asynchrone des méthodes

Question

J'ai été chargé de créer du code Java avec des fonctionnalités similaires au code ci-dessous. Actuellement, j'ai du mal à comprendre exactement ce que fait le code et comment simuler l'effet en Java.

#region "Send Aggregate Event" 

    /// <summary> 
    /// Delegate for async sending the AggregateEvent 
    /// </summary> 
    /// <param name="request"></param> 
    public delegate void SendAggregateEventAsync(AE request); 
    SendAggregateEventAsync _sendAggregateEventAsync; 

    /// <summary> 
    /// IAsyncResult pattern to async send the AggregateEvent 
    /// </summary> 
    /// <param name="request"></param> 
    /// <param name="callback"></param> 
    /// <param name="state"></param> 
    /// <returns></returns> 
    public IAsyncResult BeginSendAggregateEvent(AE request, AsyncCallback callback, Object state) 
    { 
     _sendAggregateEventAsync = new SendAggregateEventAsync(SendAggregateEvent); 
     return _sendAggregateEventAsync.BeginInvoke(request, callback, state); 

    } 

    public void EndSendAggregateEvent(IAsyncResult result) 
    { 
     object state = result.AsyncState; 
     _sendAggregateEventAsync.EndInvoke(result); 
    } 

    /// <summary> 
    /// Send an aggregate event to the Device Webserver 
    /// </summary> 
    /// <param name="request">The AggregateEvent request</param> 
    public void SendAggregateEvent(AE request) 
    { 
     if (request == null) throw new ArgumentNullException("request"); 

     String message = ChangeDatesToUTC(MessageHelper.SerializeObject(typeof(AE), request), new String[] { "EventTime" }, url); 
     SendMessage(message); 
    } 
    #endregion 

Il existe plusieurs autres événements ayant tous un code similaire à celui fourni ci-dessus. À partir des commentaires, je comprends que le code est destiné à gérer de manière asynchrone la méthode SendAggregateEvent. Ce que je ne comprends pas, c'est pourquoi le modificateur delegate est utilisé, ou comment répliquer ce type de gestion asynchrone en Java.

également la lecture de ce fil

Java Delegates?

Je comprends qu'il n'y a aucun moyen « facile » pour simuler la fonctionnalité délégué en java. Est-il nécessaire d'avoir la fonctionnalité de délégué pour faire traiter la méthode SendAggregateEvent de manière asynchrone? Si non, quelqu'un peut-il suggérer comment je ferais cela?

Answer 1

Selon la réponse de How to asynchronously call a method in Java, FutureTask est un bon moyen en Java pour exécuter une méthode de manière asynchrone. Voici un code Java qui exécute une tâche de manière asynchrone (voir courir à http://ideone.com/ZtjA5C)

import java.util.*; 
import java.lang.*; 
import java.util.concurrent.FutureTask; 

class Main 
{ 
    public static void main (String[] args) throws java.lang.Exception 
    { 
     System.out.println("Before"); 
     ExecutorService executorService = Executors.newFixedThreadPool(1); 
     FutureTask<Object> futureTask = new FutureTask<Object>(new Runnable() { 
      public void run() 
      { 
       System.out.println("Hello async world!"); 
      } 
     }, null); 
     System.out.println("Defined"); 
     executorService.execute(futureTask); 
     System.out.println("Running"); 
     while (!futureTask.isDone()) 
     { 
      System.out.println("Task not yet completed."); 

      try 
      { 
        Thread.sleep(1); 
      } 
      catch (InterruptedException interruptedException) 
      { 
      } 
     } 
     System.out.println("Done"); 
    } 
} 

Answer 2

Ceci est en fait l'ancienne façon d'écrire le code async en C#, communément appelé le Async Programming Model

Je ne suis pas assez familier avec java, mais tout ce que vous avez vraiment besoin de reproduire ce code est de créer une méthode fait l'action de façon synchrone SendAggregateEvent et un moyen d'appeler cela de manière asynchrone SendAggregateEventAsync

Plus précisément à certaines de vos questions. Le délégué n'est utilisé pour encapsuler la méthode SendAggregateEvent afin qu'elle et ses paramètres peut être invoquée sur un fil potentiellement différent (en gardant à l'esprit que async est pas nécessairement multi-thread)

Il ressemble à ceci:

var referenceToTaskBeingRun = BeginSomeMethod() 
//the above wraps the actual method and calls it, returning a reference to the task 
var results = EndSomeMethod(referenceToTaskBeingRun); 
//the above sends the reference so that it can be used to get the results from the task. 
//NOTE that this is blocking because you are now waiting for the results, whether they finished or not 

La méthode préférée pour ce faire est maintenant d'utiliser le Task Parallel Library, qui a une base de code beaucoup plus facile à lire. Donc, tout cela étant dit, la clé pour se concentrer sur ce code serait que vous ayez juste besoin d'une méthode et d'une version asynchrone de cette méthode. La mise en œuvre devrait être à vous et à votre pile de programmation. N'essayez pas de forcer l'implémentation d'une autre pile là où elle n'appartient pas ... en particulier une implémentation qui n'est même plus la méthodologie préférée.