Rappels en C #

Je veux avoir une bibliothèque qui aura une fonction qui accepte un objet pour ce paramètre.

Avec cet objet, je veux être en mesure d'appeler une fonction spécifiée lorsque X est fini. La fonction qui sera appelée doit être spécifié par l'appelant, et X sera effectué et contrôlé par la bibliothèque.

Comment puis-je faire cela?

Pour référence, je suis à l'aide de C# et de .NET 3.5

source d'informationauteur Malfist

  1. 38

    Offre un délégué et d'utiliser un délégué anonyme ou une Expression Lambda

    public static void DoWork(Action processAction)
{
  //do work
  if (processAction != null)
    processAction();
}

public static void Main()
{
  //using anonymous delegate
  DoWork(delegate() { Console.WriteLine("Completed"); });

  //using Lambda
  DoWork(() => Console.WriteLine("Completed"));
}

    Ou l'utilisation d'une interface

    public interface IObjectWithX
{
  void X();
}

public class MyObjectWithX : IObjectWithX
{
  public void X()
  {
    //do something
  }
}

public class ActionClass
{
  public static void DoWork(IObjectWithX handlerObject)
  {
    //do work
    handlerObject.X();
  }
}

public static void Main()
{
  var obj = new MyObjectWithX()
  ActionClass.DoWork(obj);
}
  2. 6

    Sonne comme une recette parfaite pour les délégués, en particulier, des rappels avec les délégués sont exactement comment cela est géré dans le modèle asynchrone .NET.

    L'appelant généralement de vous passer de l'état et d'un délégué, et que vous stockez les deux d'entre eux quel que soit le contexte que vous avez, puis appeler le délégué de la transmettre à l'état, et quelle que soit la suite que vous pourriez avoir.

    Vous pouvez soit faire de l'état juste object ou éventuellement utiliser un délégué générique et de prendre de l'etat du type approprié, par exemple

    public delegate void Callback<T>(T state, OperationResult result)

    Alors:

    public void DoSomeOperation(int otherParameterForWhateverReason,
                            Callback<T> callback, T state)

    Que vous utilisez .NET 3.5, vous pourriez vouloir utiliser l'existant Func<...> et Action<...>
    délégué types, mais vous peut trouver le rend plus clair de déclarer votre propre. (Le nom peut le rendre plus clair ce que vous l'utilisez.)

  3. 1

    L'objet en question devront mettre en place une interface fournie par vous. Prendre de l'interface comme un paramètre, puis vous pouvez appeler n'importe quelle méthode que l'interface expose. Sinon, vous n'avez aucun moyen de savoir ce que l'objet est capable de faire. Que, ou vous pouvez prendre un délégué en tant que paramètre et l'appeler.

  4. 1

    Est-il une raison de ne pas avoir votre bibliothèque d'un événement public pour être déclenché lorsque l'opération est terminée? Ensuite, l'appelant pouvait juste s'inscrire pour gérer l'événement et vous n'avez pas à vous soucier de passer autour des objets ou des délégués.

    L'objet de la mise en œuvre d'une interface que vous avez fournies, mais il semble être plus le Java approche de l' .NET approche. Les événements semblent un peu plus propre pour moi.

  5. -2

    Vous pouvez utiliser le Système.Action disponible en C#.NET pour les fonctions de rappel. Veuillez vérifier cet échantillon de exemple:

        //Say you are calling some FUNC1 that has the tight while loop and you need to 
    //get updates on what percentage the updates have been done.
    private void ExecuteUpdates()
    {
        Func1(Info => { lblUpdInfo.Text = Info; });
    }

    //Now Func1 would keep calling back the Action specified in the argument
    //This System.Action can be returned for any type by passing the Type as the template.
    //This example is returning string.
    private void Func1(System.Action<string> UpdateInfo)
    {
        int nCount = 0;
        while (nCount < 100)
        {
            nCount++;
            if (UpdateInfo != null) UpdateInfo("Counter: " + nCount.ToString());
            //System.Threading.Thread.Sleep(1000);
        }
    }