internal static IMessage DeserializeMessage(string mimeType, Stream xstm, bool methodRequest, IMessage msg, Header[] h)
{
Stream serializationStream = null;
object obj2;
bool flag = false;
bool flag2 = true;
if (string.Compare(mimeType, "application/octet-stream", StringComparison.Ordinal) == 0)
{
flag2 = true;
}
if (string.Compare(mimeType, "text/xml", StringComparison.Ordinal) == 0)
{
flag2 = false;
}
if (!flag)
{
serializationStream = xstm;
}
else
{
long position = xstm.Position;
byte[] bytes = ((MemoryStream)xstm).ToArray();
xstm.Position = position;
MemoryStream stream3 = new MemoryStream(Convert.FromBase64String(Encoding.ASCII.GetString(bytes, 0, bytes.Length)));
serializationStream = stream3;
}
IRemotingFormatter formatter = MimeTypeToFormatter(mimeType, false);
if (flag2)
{
obj2 = ((BinaryFormatter)formatter).UnsafeDeserializeMethodResponse(serializationStream, null, (IMethodCallMessage)msg);
}
else if (methodRequest)
{
MethodCall call = new MethodCall(h);
formatter.Deserialize(serializationStream, new HeaderHandler(call.HeaderHandler));
obj2 = call;
}
else
{
IMethodCallMessage mcm = (IMethodCallMessage)msg;
MethodResponse response = new MethodResponse(h, mcm);
formatter.Deserialize(serializationStream, new HeaderHandler(response.HeaderHandler));
obj2 = response;
}
return((IMessage)obj2);
}
/// <summary>
/// 反序列化对象，默认从二进制字符串反序列化为对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="graph"></param>
/// <param name="formatterType"></param>
/// <returns></returns>
public static T DeserializeStringToObject <T>(string graph, FormatterType formatterType)
{
Byte[] arrGraph = Convert.FromBase64String(graph);
using (MemoryStream memoryStream = new MemoryStream(arrGraph))
{
IRemotingFormatter formatter = GetFormatter(formatterType);
return((T)formatter.Deserialize(memoryStream));
}
}
private IDictionary <string, object> Base64StringToDictionary(string base64EncodedSerializedTempData)
{
var bytes = Convert.FromBase64String(base64EncodedSerializedTempData);
using (var memStream = new MemoryStream(bytes))
{
return(_formatter.Deserialize(memStream, null) as IDictionary <string, object>);
}
}
/// <summary>
/// Deserializes the specified object to deserialize.
/// </summary>
/// <typeparam name="TObjectType">Type of the object to deserialize.</typeparam>
/// <param name="objectToDeserialize">The object to deserialize.</param>
/// <returns>Deserialized object</returns>
public TObjectType Deserialize <TObjectType>(byte[] objectToDeserialize)
{
TObjectType deserializedObject;
using (var memStream = new MemoryStream(objectToDeserialize))
{
deserializedObject = (TObjectType)_formatter.Deserialize(memStream);
}
return(deserializedObject);
}
/// <summary>
/// 把已序列化为字符串类型的对象反序列化为指定的类型
/// </summary>
/// <param name="serializedGraph">已序列化为字符串类型的对象</param>
/// <param name="formatterType">消息格式编码类型（Soap或Binary型）</param>
/// <param name="binder"></param>
/// <returns>串行化转化结果</returns>
/// <remarks>调用BinaryFormatter或SoapFormatter的Deserialize方法实现主要转换过程。</remarks>
public static object DeserializeStringToObject(this string serializedGraph, SerializationFormatterType formatterType, SerializationBinder binder)
{
ExceptionHelper.CheckStringIsNullOrEmpty(serializedGraph, "serializedGraph");
Byte[] arrGraph = Convert.FromBase64String(serializedGraph);
using (MemoryStream memoryStream = new MemoryStream(arrGraph))
{
IRemotingFormatter formatter = GetFormatter(formatterType);
formatter.Binder = binder;
return(formatter.Deserialize(memoryStream));
}
}
public T Deserialize <T>(byte[] data, int offset)
{
Contract.Requires(offset == 0 || data == null || data.Length > offset);
if (data == null || data.Length == 0)
{
if (offset > 0)
{
throw new InvalidOperationException();
}
return((T)(object)null);
}
using (var memory = new MemoryStream(data))
{
memory.Position = offset;
var isNullDataFlag = memory.ReadByte();
Contract.Assume(isNullDataFlag == 0 || isNullDataFlag == 1);
if (isNullDataFlag == 1)
{
return((T)(object)null);
}
else
{
new SecurityPermission(SecurityPermissionFlag.SerializationFormatter).Assert();
try
{
return((T)formatter.Deserialize(memory));
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
}
}
public static T DeserializeObjectFromFile <T>(string path, SerializationFormatterType formatterType, SerializationBinder binder = null)
{
if (!File.Exists(path))
{
throw new FileNotFoundException("path");
}
if (SerializationFormatterType.Xml == formatterType)
{
return(XmlDeserializeObjectFromFile <T>(path));
}
using (FileStream fileStream = new FileStream(path, FileMode.Open))
{
IRemotingFormatter formatter = GetFormatter(formatterType);
if (binder != null)
{
formatter.Binder = binder;
}
return((T)formatter.Deserialize(fileStream));
}
}
public static T DeserializeObject <T>(string serializedGraph, SerializationFormatterType formatterType, SerializationBinder binder = null)
{
if (string.IsNullOrEmpty(serializedGraph.Trim()))
{
throw new ArgumentNullException("serializedGraph");
}
if (SerializationFormatterType.Xml == formatterType)
{
return(XmlDeserializeObject <T>(serializedGraph));
}
byte[] arrGraph = Convert.FromBase64String(serializedGraph);
using (MemoryStream memoryStream = new MemoryStream(arrGraph))
{
IRemotingFormatter formatter = GetFormatter(formatterType);
if (binder != null)
{
formatter.Binder = binder;
}
return((T)formatter.Deserialize(memoryStream));
}
}
internal static IMessage DeserializeMessage(String mimeType, Stream xstm, bool methodRequest, IMessage msg, Header[] h)
{
InternalRemotingServices.RemotingTrace("DeserializeMessage");
InternalRemotingServices.RemotingTrace("MimeType: " + mimeType);
CoreChannel.DebugOutXMLStream(xstm, "Deserializing");
Stream fmtStm = null;
bool bin64encode = false;
bool doHeaderBodyAsOne = true;
if (string.Compare(mimeType, BinaryMimeType, false, CultureInfo.InvariantCulture) == 0)
{
doHeaderBodyAsOne = true;
}
if (string.Compare(mimeType, SOAPMimeType, false, CultureInfo.InvariantCulture) == 0)
{
doHeaderBodyAsOne = false;
}
if (bin64encode == false)
{
fmtStm = xstm;
}
else
{
InternalRemotingServices.RemotingTrace("***************** Before base64 decode *****");
long Position = xstm.Position;
MemoryStream inStm = (MemoryStream)xstm;
byte[] byteArray = inStm.ToArray();
xstm.Position = Position;
String base64String = Encoding.ASCII.GetString(byteArray, 0, byteArray.Length);
byte[] byteArrayContent = Convert.FromBase64String(base64String);
MemoryStream memStm = new MemoryStream(byteArrayContent);
fmtStm = memStm;
InternalRemotingServices.RemotingTrace("***************** after base64 decode *****");
}
Object ret;
IRemotingFormatter fmt = MimeTypeToFormatter(mimeType, false);
if (doHeaderBodyAsOne == true)
{
ret = ((BinaryFormatter)fmt).UnsafeDeserializeMethodResponse(fmtStm, null, (IMethodCallMessage)msg);
}
else
{
InternalRemotingServices.RemotingTrace("Content");
InternalRemotingServices.RemotingTrace("***************** Before Deserialize Headers *****");
InternalRemotingServices.RemotingTrace("***************** After Deserialize Headers *****");
InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message *****");
if (methodRequest == true)
{
MethodCall mc = new MethodCall(h);
InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message - as MethodCall *****");
fmt.Deserialize(fmtStm, new HeaderHandler(mc.HeaderHandler));
ret = mc;
}
else
{
IMethodCallMessage mcm = (IMethodCallMessage)msg;
MethodResponse mr = new MethodResponse(h, mcm);
InternalRemotingServices.RemotingTrace("***************** Before Deserialize Message - as MethodResponse *****");
fmt.Deserialize(fmtStm, new HeaderHandler(mr.HeaderHandler));
ret = mr;
}
InternalRemotingServices.RemotingTrace("***************** After Deserialize Message *****");
}
// Workaround to make this method verifiable
IMessage resMessage = (IMessage)ret;
InternalRemotingServices.RemotingTrace("CoreChannel::DeserializeMessage OUT");
CoreChannel.DebugMessage(resMessage);
return(resMessage);
}