Sujet Safe Publier S'abonner à .Net

Question

J'ai créé un ensemble simple d'interfaces et une classe qui me permettent de publier les ajouts et les suppressions d'éléments dans un dictionnaire générique. Les abonnés reçoivent la liste entière quand ils s'abonnent et après cela, ils obtiennent seulement les changements.

Bien que mes solutions fonctionnent, je cherche quelque chose d'un peu plus standard, un peu moins de chez moi. Avez-vous des suggestions?

Notes sur ce que j'ai trouvé à ce jour:

J'ai regardé Reactive Extensions de Microsoft (Rx). Selon l'article de Jon Skeet "LINQ to Rx: seconde impressions" [1], il dit "dès qu'un observateur s'abonne, l'observable publie tout dans la séquence (sur un fil différent, par défaut). faire l'itération observable sur la séquence plusieurs fois. " Cela ressemble à l'idée de base, mais je ne trouve pas d'exemples spécifiques et je ne suis pas vraiment sûr de la sécurité des threads de "Sujet" ou "AsyncSubject" pour le moment.

Notes sur ma solution home-grown:

La structure qui est livrée aux abonnés ressemble à ceci:

/// <summary> 
/// Interface for a set of changes that are being published. 
/// </summary> 
/// <typeparam name="TKey"></typeparam> 
/// <typeparam name="TItem"></typeparam> 
public interface IPublication<TKey, TItem> 
{ 
    /// <summary> 
    /// Version of the list. 
    /// </summary> 
    long Version { get; } 
    /// <summary> 
    /// Items that were added or updated. 
    /// </summary> 
    IEnumerable<TItem> ChangedItems { get; } 
    /// <summary> 
    /// Keys to items that were removed. 
    /// </summary> 
    IEnumerable<TKey> RemovedKeys { get; } 
} 

Les abonnés eux-mêmes doivent implémenter cette interface:

/// <summary> 
/// Interface for a subscriber that will receive IPublication{TKey, TItem} deliveries from a publisher. 
/// </summary> 
/// <typeparam name="TKey"></typeparam> 
/// <typeparam name="TItem"></typeparam> 
public interface ISubscribe<TKey, TItem> 
{ 
    void Deliver(IPublication<TKey, TItem> pub); 
} 

Et bien sûr, ma classe d'éditeur de dictionnaire générique a cette méthode:

/// <summary> 
/// Adds the give subscriber to the list of subscribers and immediately publishes the 
/// dictionary contents to the new subscriber. The return value may be disposed when 
/// the subscriber wishes to terminate it's subscription. 
/// </summary> 
/// <param name="subscriber"></param> 
/// <returns></returns> 
public IDisposable Subscribe(ISubscribe<TKey, TItem> subscriber); 

[1] http://msmvps.com/blogs/jon_skeet/archive/2010/01/19/linq-to-rx-second-impressions.aspx

Answer 1

Ce n'est pas vraiment une réponse, mais fastidieux à mettre dans les commentaires afin de le mettre ici ... Je ne sais pas pourquoi regardez-vous à une norme hors de la boîte solution lorsque votre solution personnalisée est facile à construire et fonctionnera? Les événements sont le moyen le plus simple (et standard) d'obtenir un modèle d'éditeur-abonné, mais ils ne sont pas adaptés aux threads et souffrent également d'un couplage étroit entre l'abonné et l'éditeur. MS modèles & groupe de pratique avait publié WCF basé pattern mais je pense que vous cherchez un type de code rapide en cours de processus. De même, de nombreuses autres solutions de publication-abonnement standard cibleront l'intégration d'applications (ESB). Si vous n'avez trouvé aucune solution de rechange et avez décidé d'utiliser votre solution personnalisée, vous devez vous reporter à artcile pour décrire les problèmes liés à l'implémentation de ce modèle de conception.