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); }