public ReturnPacket DeSerializeToReturnPacket(ITransportableObject tranObj)
{
ReturnPacket packet = null;
var jsonTranObj = tranObj as JsonTransportable;
var jsonString = jsonTranObj.JsonString;
if (jsonString == null)
{
return(packet);
}
JsonSerializer serializer = JsonSerializer.Create(_Settings);
JObject jObject = JObject.Parse(jsonString);
var jtoken = jObject.GetValue(nameof(ReturnPacket.Content));
//如果返回参数不为空
if (jtoken != null)
{
jObject.Remove(nameof(ReturnPacket.Content));
packet = jObject.ToObject <ReturnPacket>(serializer);
Type contentType = Utilities.GetType(packet.ContentType, true);
packet.Content = jtoken.ToObject(contentType, serializer);
}
else
{
packet = packet = jObject.ToObject <ReturnPacket>(serializer);
}
return(packet);
}
public InvokePacket DeSerializeToInvokePacket(ITransportableObject tranObj)
{
InvokePacket packet = null;
var jsonTranObj = tranObj as JsonTransportable;
var jsonString = jsonTranObj.JsonString;
if (jsonString == null)
{
return(packet);
}
JObject jObject = JObject.Parse(jsonString);
JsonSerializer serializer = JsonSerializer.Create(_Settings);
var jtoken = jObject.GetValue(nameof(InvokePacket.ParameterValues));
//若有传入参数
if (jtoken != null)
{
jObject.Remove(nameof(InvokePacket.ParameterValues));
packet = jObject.ToObject <InvokePacket>(serializer);
Type[] parameterTypes = new Type[packet.ParameterTypes.Length];
Object[] parameterValues = new Object[packet.ParameterTypes.Length];
for (Int32 i = 0; i < packet.ParameterTypes.Length; ++i)
{
parameterTypes[i] = Utilities.GetType(packet.ParameterTypes[i], true);
}
var jarrayObject = jtoken as JArray;
if (packet.ParameterTypes.Length == 1)
{
if (parameterTypes[0].IsArray)
{
parameterValues[0] = jarrayObject.ToObject(parameterTypes[0], serializer);
}
else
{
parameterValues[0] = jarrayObject[0].ToObject(parameterTypes[0], serializer);
}
}
else
{
for (Int32 i = 0; i < parameterTypes.Length; ++i)
{
var jtokenObject = jarrayObject[i];
parameterValues[i] = jtokenObject.ToObject(parameterTypes[i], serializer);
}
}
packet.ParameterValues = parameterValues;
}
else
{
packet = jObject.ToObject <InvokePacket>(serializer);
}
return(packet);
}
private static ITransportableObject Expand(Stream objStream)
{
if (objStream == null)
{
throw new ArgumentNullException("objStream", "A valid non-null Stream is required.");
}
ITransportableObject objTransportableObject = null;
using (BinaryReaderExtension objBinaryReader = new BinaryReaderExtension(objStream))
{
byte[] bytSignature = objBinaryReader.ReadBytes(RemotableSignature.Length);
if (AreByteArraysEqual(bytSignature, RemotableSignature) == false)
{
throw new Exception("The binary data does not represent a valid, serialized ITransportableObject instance.");
}
string strAssemblyName = objBinaryReader.ReadString();
string strTypeName = objBinaryReader.ReadString();
Assembly objAssembly = null;
try
{
objAssembly = Assembly.Load(strAssemblyName);
}
catch (Exception objException)
{
string strErrorMessage = "An error was encountered while loading the assembly - Assembly.Load('" + strAssemblyName + "'):\n";
throw new Exception(strErrorMessage, objException);
}
Type objType = null;
try
{
objType = objAssembly.GetType(strTypeName, true, true);
}
catch (Exception objException)
{
string strErrorMessage = "An error was encountered while loading the type - objAssemblyName.GetType('" + strTypeName + "', True, True):\n";
throw new Exception(strErrorMessage, objException);
}
try
{
objTransportableObject = FastReflectionManager.CreateInstance <ITransportableObject>(objType, new Type[] { typeof(BinaryReaderExtension) }, objBinaryReader);
}
catch (Exception objException)
{
string strErrorMessage = "An error was encountered while creating the object - Activator.CreateInstance('" + objType.FullName + "'):\n";
throw new Exception(strErrorMessage, objException);
}
}
return(objTransportableObject);
}
public void WriteTransportableObject(ITransportableObject objObject)
{
bool blnIsNull = (objObject == null);
Write(blnIsNull);
if (blnIsNull == false)
{
byte[] bytTransportableObjectData = (objObject).Compress();
WriteByteArray(bytTransportableObjectData);
}
}
public TTransportableObjectType ReadTransportableObject <TTransportableObjectType>()
where TTransportableObjectType : ITransportableObject
{
ITransportableObject objValue = null;
bool blnIsNull = ReadBoolean();
if (blnIsNull == false)
{
byte[] bytTransportableObjectData = ReadByteArray();
objValue = TransportableObject.Expand(bytTransportableObjectData);
}
return((TTransportableObjectType)objValue);
}
public static ITransportableObject Expand(byte[] bytData)
{
if (bytData == null)
{
throw new ArgumentNullException("bytData", "A valid non-null byte[] is required.");
}
byte[] bytDecompressedData = bytData;
if (QuickLZ.headerLen(bytDecompressedData) == QuickLZ.DEFAULT_HEADERLEN)
{
bytDecompressedData = QuickLZ.decompress(bytDecompressedData);
}
ITransportableObject objTransportableObject = null;
using (MemoryStream objMemoryStream = new MemoryStream(bytDecompressedData))
{
objTransportableObject = Expand(objMemoryStream);
}
return(objTransportableObject);
}
public Boolean Transfer(ITransportableObject tranObject, ITransportableObject retrunTranObject)
{
Boolean getted = false;
Uri uri = new Uri(this.TransferSetting.Address);
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri);
request.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
request.Method = "POST";
request.ContentType = "application/json";
request.SendChunked = true;
request.Timeout = (Int32)this.TransferSetting.Timeout.TotalMilliseconds;
var stream = tranObject.GetStream();
request.ContentLength = stream.Length;
using (var requestStream = request.GetRequestStream())
{
stream.CopyTo(requestStream);
}
using (var response = request.GetResponse())
{
if (response.ContentLength > 0)
{
using (var receiveStream = response.GetResponseStream())
{
using (MemoryStream memoryStream = new MemoryStream())
{
receiveStream.CopyTo(memoryStream);
retrunTranObject.Load(memoryStream, 0, memoryStream.Length);
}
getted = true;
}
}
}
return(getted);
}
public object Transfer(ITransportableObject data)
{
throw new NotImplementedException();
}
