Implementation of Windows like cool Notification Service

Please click on above image to see the architectural design details on large view.


This is a small but essential utility tool for any project in order to receive notifications like Windows OS. Here is the overall scenario - I have so many core applications running on different parts of the world, those are connected with different LOGIC services and there are many LOGIC services running under different / same network. We have maintained WCF connection in between LOGIC service and core ends in order to communicate, send/receive data. To communicate with LOGIC services and Central, we have used XMPP client/server mechanism. Central server broadcasts notification messages to every LOGIC service, which has an unique Id to receive and then LOGIC service send notifications among cores using request callback of each core.

important code snippets has been provided below --

/// The callback notification interface.

public interface INotifyClientCallback
{
[OperationContract(IsOneWay = true)]
void NotificationCallBack(NotifyEventArg guid);
}

/// WCF data contract

[DataContract]
public class NotifyEventArg : EventArgs
{
[DataMember]
public bool isSuccessFull { get; set; }

[DataMember]
public object Data { get; set; }
}


/// A class to keep reference of InstanceContext & INotifyClientCallback

public class CommunicationStore
{
public InstanceContext IService { get; set; }
public INotifyClientCallback NotifyCallback { get; set; }

}


/// An implementation of NotifyCallback class

public class NotifyCallback : INotifyClientCallback
{

public void NotificationCallBack(NotifyEventArg args)
{
if (ProxyHelper.OnNotificationFromServer != null)
{
ProxyHelper.OnNotificationFromServer(null, args);
}

}

}

/// An implementation of WCF service class
/// IMyService interface defines all operation contracts


[ServiceBehavior(IncludeExceptionDetailInFaults = false, InstanceContextMode = InstanceContextMode.PerSession)]
[MyServiceBehavior]
public partial class MyService : IMyService, IDisposable
{
private bool _isServiceBusy;
private string _clientIpAddress;
public static event EventHandler OnClientAdded;
public static event EventHandler OnClientRemoved;


//list that keeps the all callback reference
private static readonly Dictionary ClientSubscribers = new Dictionary();


public void InitializationService()
{
INotifyClientCallback callback =
OperationContext.Current.GetCallbackChannel();
string IPAddress = GetAddressAsString();
lock (ClientSubscribers)
{
_clientIpAddress = IPAddress;
if (!ClientSubscribers.ContainsKey(IPAddress))
{
ClientSubscribers[IPAddress] = new CommunicationStore()
{
NotifyCallback = callback,
IService = OperationContext.Current.InstanceContext
};
if (OnClientAdded != null)
{
OnClientAdded(IPAddress, null);
}
}
}
}

public string GetAddressAsString()
{

if(OperationContext.Current.IncomingMessageProperties.ContainsKey(
RemoteEndpointMessageProperty.Name))
{
//check if the IP is 127.0.0.1(XP) or ::1 (Vista)(meaning client is in
the same PC)
RemoteEndpointMessageProperty remoteEndPoint =
(RemoteEndpointMessageProperty)(OperationContext.Current.
IncomingMessageProperties.ElementAt(3).Value);

if (remoteEndPoint.Address.Equals("127.0.0.1") ||
remoteEndPoint.Address.Equals("::1"))
{
//this will execute when the service and client are on the same machine
string pipedString = this.GetServiceInformation();
string[] names = pipedString.Split('|');
return "IP: " + names[1];
}
//this will execute if the service and client are on different machines
RemoteEndpointMessageProperty clientEndpoint = OperationContext.Current.
IncomingMessageProperties[RemoteEndpointMessageProperty.Name]
as RemoteEndpointMessageProperty;

return "IP: " + clientEndpoint.Address;
}
else
{
//this will execute when the service and client are on the same machine
string pipedString = this.GetServiceInformation();
string[] names = pipedString.Split('|');
return "IP: " + names[1];
}

}


#region IDisposable Members

public void Dispose()
{
if (OnClientRemoved != null)
{
if (_clientIpAddress != null)
{
ClientSubscribers.Remove(_clientIpAddress);
OnClientRemoved(_clientIpAddress, null);
}
}

}
#endregion
}

/// Method for broadcast notification messages from LOGIC service

public static void BroadCastNotification(string ipAddress, NotifyEventArg args)
{
if (ClientSubscribers.ContainsKey(ipAddress))
{
CommunicationStore com = ClientSubscribers[ipAddress];
//subscribers.Remove(ip);
if (((ICommunicationObject)com.NotifyCallback).State ==
CommunicationState.Opened)
{
try
{
//fires the callback method
com.NotifyCallback.NotificationCallBack(args);
}
catch (Exception)
{
// throw;
}
}
}
}

// On send message event

private static void XmppNotifyConnection_OnMessage(object sender, agsXMPP.protocol.client.Message msg)
{
// On send message event from XMPP client reside in Notification Service in Central
}

// On Receive message event

private static void XmppNotifyConnection_OnMessage(object sender, agsXMPP.protocol.client.Message msg)
{
// On Receive message event to XMPP client reside in LOGIC service
}


In your client data handler project use a helper class like below—

public static class MyServiceConnectionHelper
{
public static EventHandler OnNotifyFinished;

static MyServiceConnectionHelper()
{
ProxyHelper.OnNotificationFromServer += OnNotificationReceiveFromServer;
}

private static void OnNotificationReceiveFromServer(object sender, NotifyEventArg
e)
{
OnNotifyFinished(null, e);
}

}


From Core End in your UI code behind write something like ----

MyConnectionHelper.OnNotifyFinished += OnNotificationReceive;

private void OnNotificationReceive(object sender, NotifyEventArg arg)
{
Dispatcher.BeginInvoke(DispatcherPriority.Normal, (Action)delegate
{

Use a classy cool notify icon to represent - arg.Data.ToString();
}
}


So, here it is… If you guyz have any query regarding the design or implementation, do not hesitate to ping me @ --- a.rahmanbd@yahoo.com.