public IOutgoingMessageBody Serialize(IServiceRemotingResponseMessageBody responseMessageBody)
{
string json = JsonConvert.SerializeObject(
responseMessageBody, ServiceRemotingJsonSerializerSettings.Default);
byte[] bytes = Encoding.UTF8.GetBytes(json);
ArraySegment <byte> segment = new ArraySegment <byte>(bytes);
return(new OutgoingMessageBody(new[] { segment }));
}
public IOutgoingMessageBody Serialize(IServiceRemotingResponseMessageBody responseMessageBody)
{
if (responseMessageBody == null)
{
return(null);
}
var bytes = responseMessageBody.Serialize();
var segment = new ArraySegment <byte>(bytes);
return(new OutgoingMessageBody(new [] { segment }));
}
public OutgoingMessageBody Serialize(IServiceRemotingResponseMessageBody responseMessageBody)
{
var json = JsonConvert.SerializeObject(responseMessageBody, new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.All
});
var bytes = Encoding.UTF8.GetBytes(json);
var segment = new ArraySegment <byte>(bytes);
var list = new List <ArraySegment <byte> > {
segment
};
return(new OutgoingMessageBody(list));
}
IOutgoingMessageBody IServiceRemotingResponseMessageBodySerializer.Serialize(IServiceRemotingResponseMessageBody serviceRemotingResponseMessageBody)
{
byte[] bytes;
using (var ms = new MemoryStream())
{
Serializer.Serialize(ms, serviceRemotingResponseMessageBody);
bytes = ms.ToArray();
}
var segment = new ArraySegment <byte>(bytes);
var list = new List <ArraySegment <byte> > {
segment
};
return(new OutgoingMessageBody(list));
}
private Task <IServiceRemotingResponseMessageBody> ActorMethodDispatch(
Remoting.V2.Builder.ActorMethodDispatcherBase methodDispatcher, ActorBase actor, int interfaceId,
int methodId,
IServiceRemotingRequestMessageBody requestBody,
IServiceRemotingMessageBodyFactory remotingMessageBodyFactory, CancellationToken innerCancellationToken)
{
var actorInterfaceMethodKey =
DiagnosticsEventManager.GetInterfaceMethodKey((uint)interfaceId, (uint)methodId);
this.DiagnosticsEventManager.ActorMethodStart(actorInterfaceMethodKey, actor, RemotingListener.V2Listener);
Task <IServiceRemotingResponseMessageBody> dispatchTask;
try
{
dispatchTask = methodDispatcher.DispatchAsync(actor, methodId, requestBody, remotingMessageBodyFactory,
innerCancellationToken);
}
catch (Exception e)
{
this.DiagnosticsEventManager.ActorMethodFinish(actorInterfaceMethodKey, actor, e,
RemotingListener.V2Listener);
throw;
}
return(dispatchTask.ContinueWith(
t =>
{
IServiceRemotingResponseMessageBody responseMsgBody = null;
try
{
responseMsgBody = t.GetAwaiter().GetResult();
}
catch (Exception e)
{
this.DiagnosticsEventManager.ActorMethodFinish(actorInterfaceMethodKey, actor, e,
RemotingListener.V2Listener);
throw;
}
this.DiagnosticsEventManager.ActorMethodFinish(actorInterfaceMethodKey, actor, null,
RemotingListener.V2Listener);
return responseMsgBody;
},
TaskContinuationOptions.ExecuteSynchronously));
}
public OutgoingMessageBody Serialize(IServiceRemotingResponseMessageBody serviceRemotingResponseMessageBody)
{
if (serviceRemotingResponseMessageBody == null)
{
return(null);
}
using (var stream = new Messaging.SegmentedPoolMemoryStream(this.bufferPoolManager))
{
using (var writer = XmlDictionaryWriter.CreateBinaryWriter(stream))
{
this.serializer.WriteObject(writer, serviceRemotingResponseMessageBody);
writer.Flush();
return(new OutgoingMessageBody(stream.GetBuffers()));
}
}
}
public OutgoingMessageBody Serialize(IServiceRemotingResponseMessageBody serviceRemotingRequestMessageBody)
{
if (serviceRemotingRequestMessageBody == null)
{
return(null);
}
using (var stream = new MemoryStream())
{
using (var writer = XmlDictionaryWriter.CreateBinaryWriter(stream))
{
serializer.WriteObject(writer, serviceRemotingRequestMessageBody);
writer.Flush();
var bytes = stream.ToArray();
var segments = new List <ArraySegment <byte> >();
segments.Add(new ArraySegment <byte>(bytes));
return(new OutgoingMessageBody(segments));
}
}
}
public IOutgoingMessageBody Serialize(IServiceRemotingResponseMessageBody responseMessageBody)
{
if (responseMessageBody == null)
{
return(null);
}
using (var writeStream = new MemoryStream())
using (var jsonWriter = new JsonTextWriter(new StreamWriter(writeStream)))
{
_serializer.Serialize(jsonWriter, responseMessageBody);
jsonWriter.Flush();
var bytes = writeStream.ToArray();
var segment = new ArraySegment <byte>(bytes);
var segments = new List <ArraySegment <byte> > {
segment
};
return(new OutgoingMessageBody(segments));
}
}
public IOutgoingMessageBody Serialize(IServiceRemotingResponseMessageBody serviceRemotingResponseMessageBody)
{
if (serviceRemotingResponseMessageBody == null)
{
return(null);
}
using (var ms = new MemoryStream())
{
using (var writer = new BsonDataWriter(ms))
{
serializer.Serialize(writer, serviceRemotingResponseMessageBody);
writer.Flush();
var segment = new ArraySegment <byte>(ms.ToArray());
var segments = new List <ArraySegment <byte> > {
segment
};
return(new OutgoingMessageBody(segments));
}
}
}
public OutgoingMessageBody Serialize(IServiceRemotingResponseMessageBody serviceRemotingRequestMessageBody)
{
object constructed;
if (_empty)
{
constructed = new BondEmptyResponseMessageBody();
}
else
{
var value = serviceRemotingRequestMessageBody.Get(typeof(object));
constructed = _payloadType.GetConstructors()[1].Invoke(new[] { value });
}
using (var stream = new MemoryStream())
{
var outputStream = new OutputStream(stream);
var writer = new FastBinaryWriter <OutputStream>(outputStream);
_serializer.Serialize(constructed, writer);
outputStream.Flush();
stream.TryGetBuffer(out var segment);
return(new OutgoingMessageBody(new[] { segment }));
}
}
public MockServiceRemotingResponseMessage(IServiceRemotingResponseMessageHeader header, IServiceRemotingResponseMessageBody msgBody)
{
Header = header;
MsgBody = msgBody;
}
public IOutgoingMessageBody Serialize(
IServiceRemotingResponseMessageBody serviceRemotingResponseMessageBody)
{
return(null);
}
public ServiceRemotingResponseMessage(IServiceRemotingResponseMessageHeader header,
IServiceRemotingResponseMessageBody msgBody)
{
this.header = header;
this.msgBody = msgBody;
}
