/// <summary>
/// Adds the data to already serialized data.
/// </summary>
/// <remarks>
/// It creates the <see cref="WrappedData"/> from the given data and serializes it with the provided serializer.<br/>
/// </remarks>
/// <param name="addedData">Added data. It must a basic .Net type. Otherwise the serialization will fail.</param>
/// <param name="originalData">Already serialized data - it is type of string or byte[].</param>
/// <param name="serializer">serializer</param>
public static object Wrap(object addedData, object originalData, ISerializer serializer)
{
using (EneterTrace.Entering())
{
WrappedData aWrappedData = new WrappedData(addedData, originalData);
return(serializer.Serialize <WrappedData>(aWrappedData));
}
}
/// <summary>
/// The method is called when a reponse message is received from the duplex output channel.
/// The received response is unwrapped and sent as a response to the matching duplex input channel.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected override void OnResponseMessageReceived(object sender, DuplexChannelMessageEventArgs e)
{
using (EneterTrace.Entering())
{
try
{
ISerializer aSerializer = mySerializer.ForResponseReceiver(e.ResponseReceiverId);
WrappedData aWrappedData = DataWrapper.Unwrap(e.Message, aSerializer);
// WrappedData.AddedData represents the channel id.
// Therefore if everything is ok then it must be string.
if (aWrappedData.AddedData is string)
{
// Get the output channel according to the channel id.
TDuplexInputChannel aDuplexInputChannel = null;
using (ThreadLock.Lock(myDuplexInputChannels))
{
myDuplexInputChannels.TryGetValue((string)aWrappedData.AddedData, out aDuplexInputChannel);
}
if (aDuplexInputChannel != null)
{
aDuplexInputChannel.DuplexInputChannel.SendResponseMessage(aDuplexInputChannel.ResponseReceiverId, aWrappedData.OriginalData);
}
else
{
EneterTrace.Warning(TracedObject + "could not send the response message to the duplex input channel '" + (string)aWrappedData.AddedData + "' because the channel is not attached to the unwrapper.");
}
}
else
{
EneterTrace.Error(TracedObject + "detected that the unwrapped message does not contain the channel id as the string type.");
}
}
catch (Exception err)
{
EneterTrace.Error(TracedObject + "failed to process the response message.", err);
}
}
}
protected override void OnRequestMessageReceived(object sender, DuplexChannelMessageEventArgs e)
{
using (EneterTrace.Entering())
{
WrappedData aWrappedData = null;
try
{
ISerializer aSerializer = mySerializer.ForResponseReceiver(e.ResponseReceiverId);
// Unwrap the incoming message.
aWrappedData = DataWrapper.Unwrap(e.Message, aSerializer);
}
catch (Exception err)
{
EneterTrace.Error(TracedObject + "failed to unwrap the message.", err);
return;
}
// WrappedData.AddedData represents the channel id.
// Therefore if everything is ok then it must be string.
if (aWrappedData.AddedData is string)
{
string aMessageReceiverId = (string)aWrappedData.AddedData;
TDuplexConnection aConectionToOutput = null;
// Try to find if the output channel with the required channel id and for the incoming response receiver
// already exists.
using (ThreadLock.Lock(myConnections))
{
aConectionToOutput = myConnections.FirstOrDefault(x => x.DuplexOutputChannel.ChannelId == aMessageReceiverId && x.ResponseReceiverId == e.ResponseReceiverId);
// If it does not exist then create the duplex output channel and open connection.
if (aConectionToOutput == null)
{
IDuplexOutputChannel aDuplexOutputChannel = null;
try
{
aDuplexOutputChannel = myOutputMessagingFactory.CreateDuplexOutputChannel(aMessageReceiverId);
aDuplexOutputChannel.ResponseMessageReceived += OnResponseMessageReceived;
aDuplexOutputChannel.OpenConnection();
}
catch (Exception err)
{
EneterTrace.Error(TracedObject + "failed to create and connect the duplex output channel '" + aMessageReceiverId + "'", err);
if (aDuplexOutputChannel != null)
{
aDuplexOutputChannel.ResponseMessageReceived -= OnResponseMessageReceived;
aDuplexOutputChannel.CloseConnection();
aDuplexOutputChannel = null;
}
}
if (aDuplexOutputChannel != null)
{
aConectionToOutput = new TDuplexConnection(e.ResponseReceiverId, aDuplexOutputChannel);
myConnections.Add(aConectionToOutput);
}
}
}
if (aConectionToOutput != null)
{
try
{
// Send the unwrapped message.
aConectionToOutput.DuplexOutputChannel.SendMessage(aWrappedData.OriginalData);
}
catch (Exception err)
{
EneterTrace.Error(TracedObject + "failed to send the message to the output channel '" + aConectionToOutput.DuplexOutputChannel.ChannelId + "'.", err);
}
}
}
else
{
EneterTrace.Error(TracedObject + "detected that the unwrapped message contian the channel id as the string type.");
}
}
}