eventaggregator Wiki Rss Feed

Updated Wiki: Home

timothy_makarov — Sat, 02 Feb 2013 10:42:35 GMT

[ Asynchronous Event Aggregator ]

C# .NET TPL Based Event Aggregator with Subscribe/Publish Interface

Loosely coupled design with event aggregation

Description

Event Aggregator aggregates events from multiple objects into itself, passing that same event onto its observers.

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance

It is very fast.
Single event processing takes 25-30 μs depending on the system.
See performance test results.

Updated Wiki: Home

timothy_makarov — Sat, 02 Feb 2013 10:41:55 GMT

[ Async Event Aggregator ]

C# .NET TPL Based Event Aggregator with Subscribe/Publish Interface

Loosely coupled design with event aggregation

Description

Event Aggregator aggregates events from multiple objects into itself, passing that same event onto its observers.

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance

It is very fast.
Single event processing takes 25-30 μs depending on the system.
See performance test results.

Updated Wiki: Home

timothy_makarov — Tue, 22 Jan 2013 18:22:44 GMT

Loosely coupled design with event aggregation

Description

Event Aggregator aggregates events from multiple objects into itself, passing that same event onto its observers.

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance

It is very fast.
Single event processing takes 25-30 μs depending on the system.
See performance test results.

Updated Wiki: Home

timothy_makarov — Mon, 21 Jan 2013 09:06:44 GMT

Loosely coupled design with event aggregation

Description

Event Aggregator aggregates events from multiple objects into itself, passing that same event onto its observers.

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance

It is very fast. Single event processing takes 25-30 μs depending on the system.
See performance test results.

Updated Wiki: Home

timothy_makarov — Mon, 21 Jan 2013 09:05:51 GMT

Loosely coupled design with event aggregation

Description

Event Aggregator aggregates events from multiple objects into itself, passing that same event onto its observers.

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance

It is very fast. Single event processing takes 25-30 μs depending on the system.
See performance test results.

Updated Wiki: Home

timothy_makarov — Mon, 21 Jan 2013 09:05:25 GMT

Loosely coupled design with event aggregation

Description

Event Aggregator aggregates events from multiple objects into itself, passing that same event onto its observers.

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance

It is very fast. Single event processing takes 25-30 μs depending on the system.
See performance test results.

Updated Wiki: Home

timothy_makarov — Mon, 21 Jan 2013 09:05:05 GMT

Loosely coupled design with event aggregation

Description

Event Aggregator aggregates events from multiple objects into itself, passing that same event onto its observers.

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance

It is very fast. Single event processing takes 25-30 μs depending on the system.
See performance test results.

Updated Wiki: Home

DarkVasya — Wed, 19 Dec 2012 14:29:20 GMT

Loosely coupled design with event aggregation

Description

Event Aggregator aggregates events from multiple objects into itself, passing that same event onto its observers.

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance

It is very fast. Single event processing takes 25-30 μs depending on the system! See performance test results.

Updated Wiki: Home

DarkVasya — Wed, 19 Dec 2012 14:03:33 GMT

Loosely coupled design with message coupling and event aggregation

Description

One of the key aspects in application design is managing dependencies between modules. Good architecture might begin to suffer from strong coupling as long as the project grows. All this affects further development by making it harder to change modules (a change in one module usually forces a ripple effect of changes in other modules), also strongly coupled modules are harder to reuse and test.

Message coupling is a good choice in developing loosely coupled architecture. This is the loosest type of coupling. It can be achieved by state decentralization and module communication is done via message passing.

The Event Aggregator aggregates events from multiple objects into itself, passing that same event onto its observers.

Event Aggregator project allows you to use event aggregation via extension methods, so you do not have to implement extra interfaces in order to support event aggregation in your code. Event Aggregator implements observer pattern and dispose pattern to manage event messaging, making your code more flexible and easier to test.

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance

It is very fast. Single event processing takes 25-30 μs depending on the system! See performance test results.

Updated Wiki: EventAggregatorPerfTest

DarkVasya — Wed, 04 Jul 2012 08:01:22 GMT

Performance Test

Figure 1. Time dependency of a single event processing from total processed event count for one sender and one subscriber.

Figure 2. Time dependecy of total processing time from total processed event count for one sender and one subscriber.

Figure 3. Time dependecy of a single event processing from total processed event count for one sender and multiple receivers.

Figure 4. Time dependecy of total processing time from total processed event count for one sender and multiple receivers.

Updated Wiki: Home

DarkVasya — Wed, 04 Jul 2012 07:57:21 GMT

Loosely coupled design with message coupling and event aggregation

Description

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance

It is very fast. You can see for yourself the performance test results for Event Aggregator. Single event processing takes 25-30 μs no matter how many senders or subscribers you have!

Updated Wiki: Home

DarkVasya — Mon, 04 Jun 2012 10:45:59 GMT

Loosely coupled design with message coupling and event aggregation

Description

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance

It is very fast. You can see for yourself the performance test results for Event Aggregator.
Single event processing takes 25-30 μs no matter how many senders or subscribers you have!

More information can be found here at Event Aggregator Performance Test Page.

Updated Wiki: SubscribeExtension

DarkVasya — Thu, 19 Apr 2012 18:17:49 GMT

Subscribe extension method

Subscribes the caller instance to an event with specified ID.

Subscribe extension method signature

public static EventMessageHandler Subscribe(this object eventSource, EventHub eventHub, int id, Action<EventMessage> handler)

Input arguments

eventSource is an instance of the object, which provides the event handler
eventHub is an object that manages event messaging
id is an event message identifier
handler is an event message handler

Return value

eventMessageHandler is an instance of the EventMessageHandler class

Example

Subscribe MainWindow to EventId.Default.Dispatch event ID and use HandleDispatch method as event message handler.

Get message parameter "Dispatch" and use its value as an Action delegate to invoke a method in the Dispatcher.

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.Dispatch, HandleDispatch);
        }

        private void HandleDispatch(EventMessage eventMessage)
        {
            Dispatcher.Invoke(eventMessage.GetValue<Action>("Dispatch"));
        }
    }
}

Updated Wiki: SubscribeExtension

DarkVasya — Thu, 19 Apr 2012 18:15:53 GMT

Subscribe extension method

Subscribes the caller instance to an event with specified ID.

Subscribe extension method signature

public static EventMessageHandler Subscribe(this object eventSource, EventHub eventHub, int id, Action<EventMessage> handler)

Input arguments

eventSource is an instance of the object, which provides the event handler
id is an event message identifier
handler is an event message handler
eventHub is an object that manages event messaging

Return value

eventMessageHandler is an instance of the EventMessageHandler class

Example

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.Dispatch, HandleDispatch);
        }

        private void HandleDispatch(EventMessage eventMessage)
        {
            Dispatcher.Invoke(eventMessage.GetValue<Action>("Dispatch"));
        }
    }
}

Updated Wiki: SendExtension

DarkVasya — Thu, 19 Apr 2012 18:13:13 GMT

Send extension method

Send extension method is used to notify subscribed observers that event happened.

Send extension method signature

public static EventMessage Send(this object eventSource, EventHub eventHub, int id, params KeyValuePair<string, object>[] parameters)

Input arguments

eventSource is an event source, i.e. the object that sends an event message
eventHub is an object that manages event messaging
id is an event message identifier
parameters are optional parameters providing data for event handlers

Return value

eventMessage is an instance of the sended message processed by all subscribed handlers

Example

Send an event message with Dispatch ID (int this example EventId.settings file defines parameter with key "Dispatch" and some integer number as a value).

Provide event message with specified delegate as an event argument (parameter key "Dispatch" and parameter value is an Action delegate).

this.Send(EventId.Default.Dispatch,
  new KeyValuePair<string, object>(
    "Dispatch",
    new Action(() => IsExecutable = eventMessage.GetValue<bool>("WorkIsDone"))));

All subscribers to specified event ID (EventId.Default.Dispatch) will receive this event message.

Updated Wiki: Home

DarkVasya — Thu, 12 Apr 2012 10:36:31 GMT

Loosely coupled design with message coupling and event aggregation

Description

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance

It is very fast. You can see for yourself the performance test results for Event Aggregator.
Single event processing takes 25-30 μs (delivery time) no matter how many senders or subscribers you have!

More information can be found here at Event Aggregator Performance Test Page.

Updated Wiki: Home

DarkVasya — Thu, 12 Apr 2012 10:34:01 GMT

Loosely coupled design with message coupling and event aggregation

Description

Simple

You can fire up any type of event.

App.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);

            Current.MainWindow = new MainWindow();

            this.Send(EventId.Default.AppStartup);
        }
    }
}

Handle fired event whenever you need.

MainWindow.xaml.cs

using System.Windows;
using EventAggregator;

namespace EventAggregatorSample
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();

            this.Subscribe(EventId.Default.AppStartup, HandleAppStartup);
        }

        private void HandleAppStartup(EventMessage eventMessage)
        {
            Show();
        }
    }
}

It is simple and makes no couplings between modules.

Performance Test

Updated Wiki: Home

DarkVasya — Tue, 10 Apr 2012 17:52:43 GMT

Loosely coupled design with message coupling and event aggregation

Performance Test

You can see for yourself the performance test results for Event Aggregator.
Single event processing takes 25-30 μs no matter how many senders or subscribers you have!

More information can be found here at Event Aggregator Performance Test Page

Updated Wiki: EventAggregatorPerfTest

DarkVasya — Tue, 10 Apr 2012 17:48:38 GMT

Performance Test

You can see for yourself the performance results for Event Aggregator.

Figure 1. Time dependency of a single event processing from total processed event count for one sender and one subscriber.

Figure 2. Time dependecy of total processing time from total processed event count for one sender and one subscriber.

Figure 3. Time dependecy of a single event processing from total processed event count for one sender and multiple receivers.

Figure 4. Time dependecy of total processing time from total processed event count for one sender and multiple receivers.

Updated Wiki: Home

DarkVasya — Tue, 10 Apr 2012 17:30:32 GMT

Loosely coupled design with message coupling and event aggregation

Performance Test

You can see for yourself the performance test results for Event Aggregator.

More information can be found here at Event Aggregator Performance Test Page