Est-ce une approche événementielle décente pour un service Windows?

Question

Je suis en train de lire sur la conception pilotée par les événements. J'ai de la difficulté à en comprendre certaines en pratique. J'envisage d'utiliser cela pour un service Windows qui surveille, analyse et gère les informations provenant d'un flux TCP tiers. Est-ce que ce qui suit est une approche décente, ou est-ce que je manque quelque chose?

Mon plan est d'avoir un service principal est tout simplement un conteneur pour les événements:

public class MyService 
{      

    public void RegisterAgent(ServiceAgent agent) 
    { 
     Log("Initializing agent " + agent); 
     agent.Initialize(this); 
     Log("Done intializing agent " + agent); 
    } 

    public void Log(string messageText) 
    { 
     OnSimpleLogEventLogged(this, new SimpleLogEventArgs(messageText)); 
    } 

    protected void Raise<T>(EventHandler<T> eventHandler, object sender, T args) where T : EventArgs 
    { 
     var handler = eventHandler; 
     if (handler == null) return;      
     handler(sender, args); 

    } 

    public event EventHandler<SimpleLogEventArgs> SimpleLogEventLogged; 
    protected void OnSimpleLogEventLogged(object sender, SimpleLogEventArgs args) 
    { 
     Raise(SimpleLogEventLogged, sender, args); 
    } 

    public event EventHandler<TextRecievedEventArgs > TextRecieved; 
    public void OnTextRecieved(object sender, TextRecievedEventArgs args) 
    { 
     Raise(TextRecieved, sender, args);    
    } 

    public event EventHandler<TextParsedEventArgs> TextParsed; 
    public void OnTextParsed(object sender, TextParsedEventArgs args) 
    { 
     Raise(TextParsed, sender, args);    
    } 

    ... 
} 

Puis, en utilisant MEF ou similaire, je vais enregistrer des cas de « ServiceAgent », qui traitent simplement et/ou augmenter événements, le cas échéant sur un thread d'arrière-plan. Par exemple:

public class TextParsingAgent : ServiceAgent 
{ 

    public override void Initialize(MyService service) 
    { 
     service.TextRecieved += TextRecieved; 
     base.Initialize(service); 
    } 

    void TextRecieved(object sender, TextRecievedEventArgs e) 
    { 
     ThreadPool.QueueUserWorkItem(TextRecievedAsync, e); 
    } 

    private void TextRecieved(object state) 
    { 
     var e = (TextRecievedEventArgs)state; 
     //TODO:Parse text into something meaningful and store in textParseEventArgs 
     service.OnTextParsed(textParseEventArgs); 
    } 
} 

Answer 1

Personnellement, je pense qu'il est assez bon structue général à votre code, il se sépare facilement des unités logiques dans leurs propres opérations, et en informant sur le service qu'elle vous permet une bonne capacité d'extension à l'avenir si vous devez configurer différents serviceagents plus tard.

Answer 2

Si la méthode Raise() est là que pour simplifier la vérification nulle, vous voudrez peut-être initialiser les gestionnaires d'événements non-nul au lieu d'utiliser une expression lambda, comme ceci:

public event EventHandler<TextParsedEventArgs> TextParsed = (sender, e) => { }; 

Ensuite, vous pouvez appeler TextParsed(...) sans la vérification null, ce qui pourrait rendre le code plus facile à suivre.