Event Aggregator

New Post: Unsubscribe Method

signoff — Wed, 06 Feb 2013 17:30:03 GMT

Yes I found it in sources. But it no so obvious looking simply on the class (extention class)

New Post: Unsubscribe Method

timothy_makarov — Wed, 06 Feb 2013 16:54:04 GMT

Hello,

When you call the Subscribe method, it returns EventMessageHandler which implements IDisposable.
Call Dispose method, if you want to unsubscribe a handler.

New Post: Unsubscribe Method

SignOff — Wed, 06 Feb 2013 06:22:57 GMT

un subscribe method should be public at least ?

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.

Reviewed: Event Aggregator v1.0 (Jan 20, 2013)

sotronix — Sun, 20 Jan 2013 10:33:43 GMT

Rated 5 Stars (out of 5) - Using MVP-VM Eventaggregator saves me a lot of work and decouples my designs in a greatfull manner. Thanks a lot for your efforts and sharing this with the community.

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.

Source code checked in, #19162

Project Collection Service Accounts — Mon, 01 Oct 2012 20:50:51 GMT

Upgrade: New Version of LabDefaultTemplate.xaml. To upgrade your build definitions, please visit the following link: http://go.microsoft.com/fwlink/?LinkId=254563

Source code checked in, #19161

Project Collection Service Accounts — Mon, 01 Oct 2012 20:49:54 GMT

Checked in by server upgrade

Source code checked in, #17271

DarkVasya — Sat, 28 Jul 2012 22:00:15 GMT

Changed project structure

Source code checked in, #17270

DarkVasya — Sat, 28 Jul 2012 21:56:11 GMT

Performance optimizations (removed LINQ from EventHub)

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!

Project License Changed

Wed, 27 Jun 2012 08:43:58 GMT

Microsoft Public License (Ms-PL) This license governs use of the accompanying software. If you use the software, you accept this license. If you do not accept the license, do not use the software. 1. Definitions The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under U.S. copyright law. A "contribution" is the original software, or any additions or changes to the software. A "contributor" is any person that distributes its contribution under this license. "Licensed patents" are a contributor's patent claims that read directly on its contribution. 2. Grant of Rights (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create. (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software. 3. Conditions and Limitations (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks. (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your patent license from such contributor to the software ends automatically. (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution notices that are present in the software. (D) If you distribute any portion of the software in source code form, you may do so only under this license by including a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object code form, you may only do so under a license that complies with this license. (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular purpose and non-infringement.