protected override void OnResponseMessageReceived(object sender, DuplexChannelMessageEventArgs e)
{
using (EneterTrace.Entering())
{
if (BrokerMessageReceived == null)
{
EneterTrace.Warning(TracedObject + ErrorHandler.NobodySubscribedForMessage);
return;
}
BrokerMessageReceivedEventArgs anEvent = null;
try
{
BrokerMessage aMessage = mySerializer.ForResponseReceiver(e.ResponseReceiverId).Deserialize <BrokerMessage>(e.Message);
anEvent = new BrokerMessageReceivedEventArgs(aMessage.MessageTypes[0], aMessage.Message);
}
catch (Exception err)
{
EneterTrace.Warning(TracedObject + "failed to deserialize the request message.", err);
anEvent = new BrokerMessageReceivedEventArgs(err);
}
try
{
BrokerMessageReceived(this, anEvent);
}
catch (Exception err)
{
EneterTrace.Warning(TracedObject + ErrorHandler.DetectedException, err);
}
}
}
private void Send(EBrokerRequest request, string[] messageTypes)
{
using (EneterTrace.Entering())
{
BrokerMessage aBrokerMessage = new BrokerMessage(request, messageTypes);
Send(aBrokerMessage);
}
}
public _T Deserialize <_T>(object serializedData)
{
using (EneterTrace.Entering())
{
if (serializedData is byte[] == false)
{
throw new ArgumentException("Input parameter 'serializedData' is not byte[].");
}
if (typeof(_T) != typeof(BrokerMessage))
{
throw new InvalidOperationException("Data can be deserialized only into" + typeof(BrokerMessage).Name);
}
BrokerMessage aResult;
byte[] aData = (byte[])serializedData;
using (MemoryStream aStream = new MemoryStream(aData))
{
BinaryReader aReader = new BinaryReader(aStream);
// Read broker request.
int aBrokerRequestNumber = aReader.ReadByte();
EBrokerRequest aBrokerRequest = (EBrokerRequest)aBrokerRequestNumber;
// Read number of message types.
int aNumberOfMessageTypes = myEncoderDecoder.ReadInt32(aReader, myIsLittleEndian);
// Read message types.
string[] aMessageTypes = new string[aNumberOfMessageTypes];
for (int i = 0; i < aMessageTypes.Length; ++i)
{
string aMessageType = myEncoderDecoder.ReadPlainString(aReader, Encoding.UTF8, myIsLittleEndian);
aMessageTypes[i] = aMessageType;
}
if (aBrokerRequest == EBrokerRequest.Publish)
{
object aPublishedMessage = myEncoderDecoder.Read(aReader, myIsLittleEndian);
aResult = new BrokerMessage(aMessageTypes[0], aPublishedMessage);
}
else
{
aResult = new BrokerMessage(aBrokerRequest, aMessageTypes);
}
return((_T)(object)aResult);
}
}
}
public void SendMessage(string eventId, object message)
{
using (EneterTrace.Entering())
{
try
{
BrokerMessage aBrokerMessage = new BrokerMessage(eventId, message);
Send(aBrokerMessage);
}
catch (Exception err)
{
EneterTrace.Error(TracedObject + "failed to send the message to the broker.", err);
throw;
}
}
}
public void SendMessage(string eventId, object serializedMessage)
{
using (EneterTrace.Entering())
{
BrokerMessage aNotifyMessage = new BrokerMessage(eventId, serializedMessage);
// If one serializer is used for the whole communication then pre-serialize the message to increase the performance.
// If there is SerializerProvider callback then the serialization must be performed before sending individualy
// for each client.
object aSerializedNotifyMessage = null;
if (mySerializer.IsSameForAllResponseReceivers())
{
aSerializedNotifyMessage = mySerializer.Serialize <BrokerMessage>(aNotifyMessage);
}
Publish(myLocalReceiverId, aNotifyMessage, aSerializedNotifyMessage);
}
}
public object Serialize <_T>(_T dataToSerialize)
{
using (EneterTrace.Entering())
{
if (typeof(_T) != typeof(BrokerMessage))
{
throw new InvalidOperationException("Only " + typeof(BrokerMessage).Name + " can be serialized.");
}
object aTemp = dataToSerialize;
BrokerMessage aBrokerMessage = (BrokerMessage)aTemp;
using (MemoryStream aStream = new MemoryStream())
{
BinaryWriter aWriter = new BinaryWriter(aStream);
// Write broker request.
byte aBrokerRequestValue = (byte)aBrokerMessage.Request;
aWriter.Write((byte)aBrokerRequestValue);
// Write message types.
myEncoderDecoder.WriteInt32(aWriter, aBrokerMessage.MessageTypes.Length, myIsLittleEndian);
foreach (string aMessageType in aBrokerMessage.MessageTypes)
{
myEncoderDecoder.WritePlainString(aWriter, aMessageType, Encoding.UTF8, myIsLittleEndian);
}
// Write message.
if (aBrokerMessage.Request == EBrokerRequest.Publish)
{
myEncoderDecoder.Write(aWriter, aBrokerMessage.Message, myIsLittleEndian);
}
return(aStream.ToArray());
}
}
}
private void Send(BrokerMessage message)
{
using (EneterTrace.Entering())
{
if (AttachedDuplexOutputChannel == null)
{
string anError = TracedObject + "failed to send the message because it is not attached to any duplex output channel.";
EneterTrace.Error(anError);
throw new InvalidOperationException(anError);
}
try
{
object aSerializedMessage = mySerializer.ForResponseReceiver(AttachedDuplexOutputChannel.ResponseReceiverId).Serialize <BrokerMessage>(message);
AttachedDuplexOutputChannel.SendMessage(aSerializedMessage);
}
catch (Exception err)
{
string anError = TracedObject + "failed to send a message to the Broker.";
EneterTrace.Error(anError, err);
throw;
}
}
}
private void Publish(string publisherResponseReceiverId, BrokerMessage message, object originalSerializedMessage)
{
using (EneterTrace.Entering())
{
List <TSubscription> anIdetifiedSubscriptions = new List <TSubscription>();
using (ThreadLock.Lock(mySubscribtions))
{
foreach (TSubscription aMessageSubscription in mySubscribtions)
{
if ((myIsPublisherSelfnotified || aMessageSubscription.ReceiverId != publisherResponseReceiverId) &&
aMessageSubscription.MessageTypeId == message.MessageTypes[0])
{
anIdetifiedSubscriptions.Add(aMessageSubscription);
}
}
}
Dictionary <string, IEnumerable <string> > aFailedSubscribers = new Dictionary <string, IEnumerable <string> >();
int aNumberOfSentSubscribers = 0;
foreach (TSubscription aSubscription in anIdetifiedSubscriptions)
{
if (aSubscription.ReceiverId == myLocalReceiverId)
{
if (BrokerMessageReceived != null)
{
try
{
BrokerMessageReceivedEventArgs anEvent = new BrokerMessageReceivedEventArgs(message.MessageTypes[0], message.Message);
BrokerMessageReceived(this, anEvent);
}
catch (Exception err)
{
EneterTrace.Warning(TracedObject + ErrorHandler.DetectedException, err);
}
++aNumberOfSentSubscribers;
}
}
else
{
object aSerializedMessage = originalSerializedMessage;
if (aSerializedMessage == null)
{
try
{
ISerializer aSerializer = mySerializer.ForResponseReceiver(aSubscription.ReceiverId);
aSerializedMessage = aSerializer.Serialize <BrokerMessage>(message);
}
catch (Exception err)
{
EneterTrace.Error(TracedObject + "failed to serialize BrokerMessage using GetSerializeCallback.", err);
}
}
if (aSerializedMessage != null)
{
IEnumerable <string> anUnsubscribedMessagesDueToFailure = Send(aSubscription.ReceiverId, aSerializedMessage);
if (anUnsubscribedMessagesDueToFailure.Any())
{
aFailedSubscribers[aSubscription.ReceiverId] = anUnsubscribedMessagesDueToFailure;
}
else
{
++aNumberOfSentSubscribers;
}
}
}
}
if (MessagePublished != null)
{
PublishInfoEventArgs anEvent = new PublishInfoEventArgs(publisherResponseReceiverId, message.MessageTypes[0], message.Message, aNumberOfSentSubscribers);
try
{
MessagePublished(this, anEvent);
}
catch (Exception err)
{
EneterTrace.Warning(TracedObject + ErrorHandler.DetectedException, err);
}
}
// If sending to some subscribers failed then they were unsubscribed.
foreach (KeyValuePair <string, IEnumerable <string> > aFailedSubscriber in aFailedSubscribers)
{
RaiseClientUnsubscribed(aFailedSubscriber.Key, aFailedSubscriber.Value);
}
}
}
