Publish an Event without PayLoad in Prism EventAggregator?

Question

Why can't we Publish Events without any PayLoad.

    _eventAggregator.GetEvent<SelectFolderEvent>().Publish(new SelectFolderEventCriteria() { });

Now, I don't need any pay load to be passed here. But the EventAggregator implementation mandates me to have an empty class to do that.

Event:

  public class SelectFolderEvent : CompositePresentationEvent<SelectFolderEventCriteria>
  {
  }

PayLoad:

  public class SelectFolderEventCriteria
  {
  }

Why has Prism not given a way to use just the Event and publish it like

    _eventAggregator.GetEvent<SelectFolderEvent>().Publish();

Is it by design and I don't understand it? Please explain. Thanks!

Answer 1

Good question, I don't see a reason for not publishing an event without a payload. There are cases where the fact that an event has been raised is all information you need and want to handle.

There are two options: As it is open source, you can take the Prism source and extract a CompositePresentation event that doesn't take a payload.

I wouldn't do that, but handle Prism as a 3rd party library and leave it as it is. It is good practice to write a Facade for a 3rd party library to fit it into your project, in this case for CompositePresentationEvent. This could look something like this:

public class EmptyPresentationEvent : EventBase
{
    /// <summary>
    /// Event which facade is for
    /// </summary>
    private readonly CompositePresentationEvent<object> _innerEvent;

    /// <summary>
    /// Dictionary which maps parameterless actions to wrapped 
    /// actions which take the ignored parameter 
    /// </summary>
    private readonly Dictionary<Action, Action<object>> _subscriberActions;

    public EmptyPresentationEvent()
    {
        _innerEvent = new CompositePresentationEvent<object>();
        _subscriberActions = new Dictionary<Action, Action<object>>();
    }

    public void Publish()
    {
        _innerEvent.Publish(null);
    }

    public void Subscribe(Action action)
    {
        Action<object> wrappedAction = o => action();
        _subscriberActions.Add(action, wrappedAction);
        _innerEvent.Subscribe(wrappedAction);
    }

    public void Unsubscribe(Action action)
    {
        if (!_subscriberActions.ContainsKey(action)) return;
        var wrappedActionToUnsubscribe = _subscriberActions[action];
        _innerEvent.Unsubscribe(wrappedActionToUnsubscribe);
        _subscriberActions.Remove(action);
    }
}

If anything is unclear, please ask.