Click here to Skip to main content
13,141,576 members (56,411 online)
Click here to Skip to main content

Stats

68.9K views
1.4K downloads
176 bookmarked
Posted 30 Aug 2010

The Super Pool Framework

, 31 Aug 2010
The Super Pool is a framework for decoupled communication and management of components. The Super Pool introduces a natural asynchronous communication environment into your solution that can be fluently spread over different components, threads, processes, or even computers or networks.
Lib
PowerCollections.dll
Matrix.Framework.SuperPool.Standalone
bin
Debug
Release
Common.Sockets
Common
Core
Matrix.Common.Core
Collections
Identification
Results
Serialization
Matrix.Common.Extended
FastSerialization
Operationals
ThreadPools
Matrix.Common.Sockets
Common
Core
Matrix.Framework.MessageBus
Client
Clients
ExecutionStrategies
Core
Net
Messages
Matrix.Framework.SuperPool
Call
Clients
Core
DynamicProxy
Subscription
Matrix.Framework.SuperPool.Standalone.csproj.user
Properties
Tests
Lib
log4net.dll
Matrix.Common.Core.dll
Matrix.Common.Diagnostics.dll
Matrix.Common.Diagnostics.FrontEnd.dll
Matrix.Common.Extended.dll
Matrix.Common.FrontEnd.dll
Matrix.Common.Sockets.dll
Matrix.Framework.TestFramework.dll
nunit.framework.dll
Matrix.Framework.SuperPool.Demonstration
bin
Debug
Release
FormServer.cs.bak
Properties
Matrix.Framework.SuperPool.Test
bin
Debug
Release
Matrix.Framework.SuperPool.Test.vshost.exe.manifest
MultiThreadTests
Properties
SpeedTests
Matrix.Framework.SuperPool.UnitTest
bin
Debug
Release
Matrix.Framework.SuperPool.UnitTest.csproj.user
Properties
// -----
// Copyright 2010 Deyan Timnev
// This file is part of the Matrix Platform (www.matrixplatform.com).
// The Matrix Platform is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, 
// either version 3 of the License, or (at your option) any later version. The Matrix Platform is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
// without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
// You should have received a copy of the GNU Lesser General Public License along with the Matrix Platform. If not, see http://www.gnu.org/licenses/lgpl.html
// -----
using System;
using System.Windows.Forms;
using System.Diagnostics;
using System.Reflection;
using Matrix.Common.Diagnostics;
using Matrix.Common.Diagnostics.TracerCore;
using Matrix.Common.Extended;
using Matrix.Framework.MessageBus.Net;
using Matrix.Framework.SuperPool.Clients;
using Matrix.Framework.SuperPool.Core;
using Matrix.Framework.MessageBus.Core;
using System.Threading;

namespace Matrix.Framework.SuperPool.Demonstration
{
    /// <summary>
    /// The main Server form. It also implements the [ICommunicationInterface] and
    /// uses a SuperPoolClient to participate as a end point in the Super Pool communication.
    /// </summary>
    public partial class FormServer : Form, ICommunicationInterface
    {
        Matrix.Framework.SuperPool.Core.SuperPool _pool;
        SuperPoolClient _poolClient;

        /// <summary>
        /// Constructor.
        /// </summary>
        public FormServer()
        {
            InitializeComponent();
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            //// [Optional] Assign the default tracer, to provide system wide tracing functionality.
            //SystemMonitor.AssignTracer(new Tracer());
            //this.tracerControl1.Tracer = SystemMonitor.Tracer;

            // Create the underlying (server) message bus and put the pool on it.
            ServerMessageBus messageBus = new ServerMessageBus("Server", null, null);
            _pool = new Matrix.Framework.SuperPool.Core.SuperPool(messageBus);

            // Create the client that will server as a connection between this
            // class and the super pool and add the client to the pool.
            _poolClient = new SuperPoolClient("Server", this);
            _pool.AddClient(_poolClient);

            // Finally subscribe to the event of having a client added to the bus/pool.
            _pool.MessageBus.ClientAddedEvent += new MessageBus.Core.MessageBusClientUpdateDelegate(MessageBus_ClientAddedEvent);
        }

        void MessageBus_ClientAddedEvent(MessageBus.Core.IMessageBus messageBus, ClientId clientId)
        {// Once a new client has been added, we want to subscribe to its event.

            // Do the report on an invoke thread, since this message bus system event is raised on a non UI thread.
            this.Invoke(new GeneralHelper.GenericDelegate<string>(Report), "Subscribing client " + clientId.ToString());

            // We could also do a full subscribe like this _poolClient.Subscribe<ICommunicationInterface>() 
            // but since this only works on local components (attached to this super pool instance) and not
            // ones that are remoted (TCP), we need to subscribe to each one separately.
            _poolClient.Subscribe<ICommunicationInterface>(clientId).EventOne += new HelperDelegate(FormServer_EventOne);
        }

        /// <summary>
        /// Process an event anonymously raised from a member of the pool.
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        object FormServer_EventOne(string param)
        {
            if (this.InvokeRequired)
            {
                throw new Exception("Wrong thread was applied by the super pool.");
            }

            // It is safe to directly access the UI elements here... see full description in DoWork method.
            Report("Received event raised..." + param);

            return "Accepted";
        }

        void Report(string message)
        {
            textBoxReport.AppendText(message + Environment.NewLine);
        }

        /// <summary>
        /// Create a new client instance, by launching the current "exe" with client parameter(s).
        /// </summary>
        private void toolStripButtonCreateClient_Click(object sender, EventArgs e)
        {
            Process notePad = new Process();
            notePad.StartInfo.FileName = Assembly.GetEntryAssembly().Location;
            notePad.StartInfo.Arguments = "client " + toolStripTextBoxClientName.Text;
            notePad.Start();
        }

        #region ICommunicationInterface Members

        public event HelperDelegate EventOne;

        public string DoWork(string parameter1)
        {
            // It is safe to directly access the UI elements here; since we are inside a [Win.Forms.Control] class child,
            // the super pool will automatically execute the calls we receive on the UI thread. This default behaviour 
            // is controllable trough the MessageSuperPoolClient.AutoControlInvoke flag, and can be disabled.
            Report(string.Format("Doing work [{0}].", parameter1));

            return "Server did some work.";
        }

        #endregion

        private void toolStripButtonCall_Click(object sender, EventArgs e)
        {
            Report("Sending work to all clients...");
            _poolClient.CallAll<ICommunicationInterface>().DoWork(toolStripTextBoxWorkParameter.Text);
        }

        private void toolStripButtonRaiseEvent_Click(object sender, EventArgs e)
        {
            HelperDelegate delegateInstance = EventOne;
            if (delegateInstance != null)
            {
                delegateInstance("Raise param");
                Report("Event raised...");
            }
        }
    }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Deyan Timnev
Product Manager Ingenious Ltd, Bulgaria
Bulgaria Bulgaria
I worked for a few years as a C++/Win32 developer and software architect, and then moved on to the .NET environment where I was able to discover the beauty of managed programming.

I am currently involved in the development and management of Open Forex Platform (www.openforexplatform.com) and the Matrix Platform (www.matrixplatform.com).

You may also be interested in...

Permalink | Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.170915.1 | Last Updated 31 Aug 2010
Article Copyright 2010 by Deyan Timnev
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid