public void SendOneWay(IServiceRemotingRequestMessage requestMessage)
{
IMessageBody outgoingMessageBody = null;
IMessageHeader outgoingMessageHeader = null;
try
{
var headerSerialzier = this.serializersManager.GetHeaderSerializer();
outgoingMessageHeader = headerSerialzier.SerializeRequestHeader(requestMessage.GetHeader());
var requestSerializer =
this.serializersManager.GetRequestBodySerializer(requestMessage.GetHeader().InterfaceId);
outgoingMessageBody = requestSerializer.Serialize(requestMessage.GetBody());
this.callbackChannel.SendOneWay(outgoingMessageHeader.GetSendBuffer(),
outgoingMessageBody.GetSendBuffers());
}
finally
{
if (outgoingMessageHeader != null)
{
outgoingMessageHeader.Dispose();
}
if (outgoingMessageBody != null)
{
outgoingMessageBody.Dispose();
}
}
}
public async Task <ResponseMessage> RequestResponseAsync(ArraySegment <byte> messageHeaders,
IEnumerable <ArraySegment <byte> > requestBody)
{
IMessageBody outgoingMessageBody = null;
IMessageHeader outgoingMessageHeader = null;
try
{
var headerSerializer = this.serializersManager.GetHeaderSerializer();
var deSerializedHeader =
headerSerializer.DeserializeRequestHeaders(
new IncomingMessageHeader(new SegmentedReadMemoryStream(messageHeaders)));
var msgBodySerializer =
this.serializersManager.GetRequestBodySerializer(deSerializedHeader.InterfaceId);
var deserializedMsg =
msgBodySerializer.Deserialize(
new IncomingMessageBody(new SegmentedReadMemoryStream(requestBody)));
var msg = new ServiceRemotingRequestMessage(deSerializedHeader, deserializedMsg);
var retval = await
this.messageHandler.HandleRequestResponseAsync(
this.requestContext,
msg);
if (retval == null)
{
return(new ResponseMessage());
}
outgoingMessageHeader = headerSerializer.SerializeResponseHeader(retval.GetHeader());
var responseSerializer =
this.serializersManager.GetResponseBodySerializer(deSerializedHeader.InterfaceId);
outgoingMessageBody = responseSerializer.Serialize(retval.GetBody());
var responseMessage = new ResponseMessage();
responseMessage.ResponseBody = outgoingMessageBody != null
? outgoingMessageBody.GetSendBuffers()
: new List <ArraySegment <byte> >();
responseMessage.MessageHeaders = outgoingMessageHeader != null
? outgoingMessageHeader.GetSendBuffer()
: new ArraySegment <byte>();
return(responseMessage);
}
catch (Exception e)
{
ServiceTrace.Source.WriteInfo("WcfRemotingService", "Remote Exception occured {0}", e);
throw new FaultException <RemoteException>(RemoteException.FromException(e), e.Message);
}
}
public async Task <IServiceRemotingResponseMessage> RequestResponseAsync(IServiceRemotingRequestMessage requestMessage)
{
IMessageBody serializedMsgBody = null;
IMessageHeader serializedHeader = null;
try
{
//Find the Serializer
var interfaceId = requestMessage.GetHeader().InterfaceId;
serializedHeader = this.serializersManager.GetHeaderSerializer()
.SerializeRequestHeader(requestMessage.GetHeader());
var msgBodySeriaizer = this.serializersManager.GetRequestBodySerializer(interfaceId);
serializedMsgBody = msgBodySeriaizer.Serialize(requestMessage.GetBody());
var responseMessage = await this.WcfClient.Channel.RequestResponseAsync(
serializedHeader.GetSendBuffer(),
serializedMsgBody == null?new List <ArraySegment <byte> >() : serializedMsgBody.GetSendBuffers())
.ContinueWith(
t => t.GetAwaiter().GetResult(),
TaskScheduler.Default);
// the code above (TaskScheduler.Default) for dispatches the responses on different thread
// so that if the user code blocks, we do not stop the response receive pump in WCF
var incomingHeader = (responseMessage != null && responseMessage.MessageHeaders != null)
? new IncomingMessageHeader(
new SegmentedReadMemoryStream(responseMessage.MessageHeaders))
: null;
////DeSerialize Response Header
var header =
this.serializersManager.GetHeaderSerializer()
.DeserializeResponseHeaders(
incomingHeader);
////DeSerialize Response Body
var responseSerializer = this.serializersManager.GetResponseBodySerializer(interfaceId);
var incomingMsgBody = (responseMessage != null && responseMessage.ResponseBody != null)
? new IncomingMessageBody(new SegmentedReadMemoryStream(responseMessage.ResponseBody))
: null;
var msgBody =
responseSerializer.Deserialize(incomingMsgBody);
//Create Response Message
return((IServiceRemotingResponseMessage) new ServiceRemotingResponseMessage(header,
msgBody));
}
catch (FaultException <RemoteException> faultException)
{
Exception remoteException;
if (RemoteException.ToException(new SegmentedReadMemoryStream(faultException.Detail.Data),
out remoteException))
{
throw new AggregateException(remoteException);
}
throw new ServiceException(remoteException.GetType().FullName, string.Format(
CultureInfo.InvariantCulture,
Microsoft.ServiceFabric.Services.Wcf.SR.ErrorDeserializationFailure,
remoteException.ToString()));
}
}
