What is the difference between using MessagingCenter and standard .NET event handlers for informing interested parties of changes?

Question

What is the difference between using MessagingCenter and standard .NET event handlers for informing interested parties of changes?

Two (untested) implementations of the same thing are below to demonstrate:

public class FooClass {
  public event EventHandler SomeEvent;

  public void DoSomeWork() {
     // ... stuff
    if(SomeEvent != null)
      SomeEvent(this, EventArgs.Empty);
  }
}

public class BarClass {
  FooClass _foo;

  public BarClass() {
    _foo = new FooClass();
    _foo.SomeEvent += delegate {
      // ... did something
   };
  }
}

Verses:

public class FooClass {
  public const string SomeEventName = "SomeEvent";
  public void DoSomeWork() {
    // ... stuff
    MessagingCenter.Send<FooClass>(this, SomeEventName);
  }
}

public class BarClass : IDisposable {
  public BarClass() {
    MessagingCenter.Subscribe<FooClass>(this, FooClass.SomeEventName, delegate {
      // .. did something
   });
  }

  public void Dispose() {
    MessagingCenter.Unsubscribe<FooClass>(this, FooClass.SomeEventName);
  }
}

From what I can tell there doesn't seem to be any difference, but if anyone can suggest any pros or cons for either, that'd help me understand. Currently, I've been using event handlers.

Is there any point in switching to using MessagingCenter? Or any new best practice?

Answer 1

The MessagingCenter from Xamarin is used to reduce coupling between ViewModels, as the sender and receiver do not need to know each other.

You can still build a similar structure by creating something like an "EventHub"/"EventAggregator" which knows sender and receiver and uses .NET events.

The MessagingCenter itself is kind of an EventAggregator

ImageSource : https://msdn.microsoft.com/en-us/library/ff921122.aspx

Here is a nice explanation of EventAggregators.

An Event Aggregator is a simple element of indirection. In its simplest form you have it register with all the source objects you are interested in, and have all target objects register with the Event Aggregator. The Event Aggregator responds to any event from a source object by propagating that event to the target objects.

To Answer the question:

Is there any point in switching to using MessagingCenter? Or any new best practice?

If you are not using something like an EventAggregator it is a good choice to switch to the MessagingCenter, or build an EventAggregator on your own. As Saruman made a good hint on explaining what coupling is. You allways want to reduce coupling for a clean code.

Answer 2

If you have access to those classes (i.e from where you want to call your methods) then there really is not a lot of difference.

However if you don't have access to those classes(i.e inside a view model or decoupled class) then message subscription event aggregation is a useful tool

Message center reduces coupling and enables view models and other components to communicate with without having to know anything about each other besides a simple Message contract.

Coupling

In software engineering, coupling is the degree of interdependence between software modules; a measure of how closely connected two routines or modules are the strength of the relationships between modules.

Answer 3

• MessagingCenter is basically used in the Model-View-ViewModel pattern.
• It is a great way to communicate and pass data or notify about updates among ViewModels without knowing who sent it to whom via a simple Message Contract.
• Ex. In one screen if you make any service call to fetch the new data and you want to notify other screens to update their UI via broadcasting message from your current screen, then MessagingCenter is the best approach.
• It decouples them without making any dependency among ViewModels, while EventHandlers makes dependency and may prohibit something from being released. You explicitly have to decouple event handlers from the events to better release the resources.
• MessagingCenter should be applied when the receiver doesn't care who sent the message and the sender doesn't care who will receive it. Events should be used when the receiver needs to know who sent the message, but the sender still doesn't care who handles it.
• It is good to use MessagingCenter over Events but, if you make too much use of too many Messages using MessagingCenter, it would be hard to identify who sent it and when sent it, the relation between messages would be hard to guess, thus making it hard time while debugging the app.