1
votes

Injecter une classe pour s'abonner à un événement interne

J'ai ce qui suit:

public class Consumer
{
    private Process _process;

    public Consumer(Process process)
    {
        _process = process;
        _process.StartProcess(Consume);
    }

    public void Consume(Result result)
    {
        Console.WriteLine("Consumer receives: {0}", result.ToString());
    }
}

Pour que cette classe soit consommée par un autre processus et capture quelque chose de manière non linéaire, la méthode OnCaptureFinished aide le processus consommateur à obtenir la capture.

/ p>

public class Process
{
    private Action<Result> CaptureFinished = null;

    public Result StartProcess(Action<Result> onCaptureFinished)
    {
        CaptureFinished = onCaptureFinished;

        Console.WriteLine("Process invokes capture");
        CaptureFinished.Invoke(new Result("This is the capture"));

        return new Result("OK");
    }
}

Je suis obligé de créer un autre processus qui obtiendra la capture livrée par la classe "Process1", cet autre processus n'est pas capable de consommer la méthode StartProcess (comme le consommateur de classe ci-dessus ), mais peut contrôler la création de la classe "Process", donc je pensais à injecter un autre objet pouvant être lié à la méthode OnCaptureFinished. Est-il possible d'utiliser un gestionnaire d'événements?

c# delegates event-handling

5 commentaires

Voulez-vous vraiment créer un autre processus ?

oui, je ne peux pas m'abonner à Process1 de manière régulière, je dois en quelque sorte le Sniffer.

par processus consiste à créer une autre classe qui sera injectée dans Process1

Le processus va donc apparaître comme un exécutable ou un domaine d'application distinct?

@keith oui en effet

3 Réponses :

2
votes

Vous pouvez utiliser .NET Remoting pour la communication inter-processus. Vous pouvez utiliser les événements .NET sur la communication à distance .NET.

Voici un article sur le sujet: https: // www. codeproject.com/Articles/62813/NET-Remoting-Events-Explained

Vous voudrez peut-être également explorer la communication asynchrone.

Si vous exécutez simplement un domaine d'application distinct dans le même processus, vous pouvez utiliser MarshalByRefObject pour proxy les appels entrant / sortant du domaine d'application.

0 commentaires

1
votes

Si vous injectez une autre classe (comme sniffer):

_sniffer = new Sniffer();
_process = new Process(_sniffer);

Dans votre classe Process existante:

public class Process
{
    private Action<Result> CaptureFinished = null;
    private Sniffer _sniffer;

    public Process(Sniffer sniffer)
    {
        _sniffer = sniffer;
    }

    public Result StartProcess(Action<Result> onCaptureFinished)
    {
        CaptureFinished = onCaptureFinished;
        ...
        CaptureFinished.Invoke(result);
        _sniffer.ProcessResult(result);

        return new Result("OK");
    }
}

Vous pourriez recevoir un message dans la classe sniffer, quand c'est fait, et invoquez-la depuis le thread principal:

public class Sniffer
{
    public Sniffer(){}

    public void ProcessResult(Result result)
    {
        Console.WriteLine("Sniffer I have: {0}", result);
    }
}

Est-ce ce que vous cherchez?

1 commentaires

oui c'est ce que je recherche, mais j'ai hâte de créer un gestionnaire d'événements sur le renifleur afin que je puisse en prendre le contrôle dans le thread principal.

0
votes

Basé sur la réponse @Juanito. J'ai conçu ce qui suit:

public class Process
{
    private Action<Result> CaptureFinished = null;
    private Action<Result> CaptureSniffed = null;
    private Sniffer _sniffer;

    public Process(Sniffer sniffer)
    {
        _sniffer = sniffer;                             //1. INJECTION
        CaptureSniffed = sniffer.CaptureFinishedSniffed;//2.Plumbing with the delegate
    }

    public Result StartProcess(Action<Result> onCaptureFinished)
    {
        CaptureFinished = onCaptureFinished;
        ...
        CaptureFinished.Invoke(result);
        CaptureSniffed.Invoke(result);                  //3.Invoking
        return new Result("OK");
    }
}

puis dans la classe Process:

public class Sniffer
{
    public Action<Result> CaptureFinishedSniffed;

    public Sniffer()
    {
        CaptureFinishedSniffed = Captured;
    }

    public void Captured(Result result)
    {
        Console.WriteLine("Proper sniffer I have: {0}", result);
    }
}

Comme vous pouvez le voir, 1. et 2. fournissent l'injection et la plomberie requise pour connecter le renifleur à son délégué à l'intérieur de la classe "Process". L'étape 3. appelle simplement la méthode souhaitée pour un traitement ultérieur en dehors du thread Process.

0 commentaires