Chapter.Mediation 1.5.0

Chapter.Mediation Library

Overview

Chapter.Mediation provides an implementation of the mediator pattern in the form of a sync and async message bus.

Features

• Sync Communication: Send an object to a list of receivers synchronously.
• Async Communication: Send an object to a list of receivers asynchronously.
• Custom Scheduler: Possibility to tunnel all message bus objects over and own scheduler.

Getting Started

1. Installation:

   • Install the Chapter.Mediation library via NuGet Package Manager:

   dotnet add package Chapter.Mediation
   

2. Send and receive a message synchronously:

   • Sending:

   public class SenderViewModel
   {
       private readonly IMessageBus _messageBus;
   
       public SenderViewModel(IMessageBus messageBus)
       {
           _messageBus = messageBus;
       }
   
       private void Publish()
       {
           _messageBus.Publish(new Notification());
       }
   }
   

   • Receiving:

   public class ReceiverViewModel
   {
       private readonly IMessageBus _messageBus;
       private ISubscriber _token;
   
       public SubscriptionHelper(IMessageBus messageBus)
       {
           _messageBus = messageBus;
   
           _token = _messageBus.Subscribe<Notification>(Callback);
       }
   
       private void Callback(Notification param)
       {
       }
   }
   

3. Send and receive a message asynchronously:

   • Sending:

   public class AsyncSenderViewModel : ObservableObject
   {
       private readonly IMessageBus _messageBus;
   
       public AsyncSenderViewModel(IMessageBus messageBus)
       {
           _messageBus = messageBus;
       }
   
       private async Task Publish()
       {
           await _messageBus.PublishAsync(new Notification());
       }
   }
   

   • Receiving:

   public class AsyncSubscriptionHelper<T> : ObservableObject
   {
       private readonly IMessageBus _messageBus;
       private IAsyncSubscriber _token;
   
       public AsyncSubscriptionHelper(IMessageBus messageBus)
       {
           _messageBus = messageBus;
   
           _messageBus.Subscribe<Notification>(Callback);
       }
   
       private async Task Callback(Notification param)
       {
       }
   }
   

Example

• Send and receive a message synchronously using a custom scheduler.

  public class DispatcherScheduler : IScheduler
  {
      public DispatcherScheduler(Dispatcher dispatcher)
      {
          _dispatcher = dispatcher;
      }
  
      public void Invoke(Action action)
      {
          _dispatcher.Invoke(action);
      }
  }
  

  public class SenderViewModel
  {
      private readonly IMessageBus _messageBus;
  
      public SenderViewModel(IMessageBus messageBus)
      {
          _messageBus = messageBus;
          PublishCommand = new DelegateCommand(Publish);
      }
  
      public IDelegateCommand PublishCommand;
  
      private void Publish()
      {
          _messageBus.Publish(new Notification());
      }
  }
  

  public class ReceiverViewModel
  {
      private readonly IMessageBus _messageBus;
      private ISubscriber _token;
  
      public SubscriptionHelper(IMessageBus messageBus)
      {
          _messageBus = messageBus;
          _scheduler = new DispatcherScheduler(Dispatcher.CurrentDispatcher);
          _token = _messageBus.Subscribe<Notification>(Callback).On(_scheduler);
      }
  
      private void Callback(Notification param)
      {
      }
  }
  

Links

• NuGet
• GitHub

License

Copyright (c) David Wendland. All rights reserved.
Licensed under the MIT License. See LICENSE file in the project root for full license information.