public static object loadTestFile(string path, Type desiredType, bool failOnException = true, SerializationBinder customBinder = null) { Assert.IsTrue(System.IO.File.Exists(path), "Test file " + path + " does not exist."); BinaryFormatter b = new BinaryFormatter(); object loaded = null; FileStream fs = null; try { fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.None); if (customBinder != null) b.Binder = customBinder; loaded = b.Deserialize(fs); fs.Close(); } catch (Exception e) { fs.Close(); if (failOnException) Assert.Fail("Caught exception when loading test file: " + e.Message); else throw; } Assert.IsNotNull(loaded, "Test file " + path + " loaded a null object."); Assert.IsInstanceOfType(loaded, desiredType, "Test file " + path + " did not resolve to desired type."); return loaded; }
public SoapReader(SerializationBinder binder, ISurrogateSelector selector, StreamingContext context) { _binder = binder; objMgr = new ObjectManager(selector, context); _context = context; _surrogateSelector = selector; _fieldIndices = new Hashtable(); }
internal ObjectWriter(ISurrogateSelector selector, StreamingContext context, InternalFE formatterEnums, SerializationBinder binder) { this.m_surrogates = selector; this.m_context = context; this.m_binder = binder; this.formatterEnums = formatterEnums; this.m_objectManager = new SerializationObjectManager(context); }
internal XmlObjectSerializerReadContextComplex(NetDataContractSerializer serializer) : base(serializer) { this.mode = SerializationMode.SharedType; this.preserveObjectReferences = true; this.binder = serializer.Binder; this.surrogateSelector = serializer.SurrogateSelector; this.assemblyFormat = serializer.AssemblyFormat; }
public ObjectReader (BinaryFormatter formatter) { // _formatter = formatter; _surrogateSelector = formatter.SurrogateSelector; _context = formatter.Context; _binder = formatter.Binder; _manager = new ObjectManager (_surrogateSelector, _context); _filterLevel = formatter.FilterLevel; }
internal XmlObjectSerializerWriteContextComplex(NetDataContractSerializer serializer, Hashtable surrogateDataContracts) : base(serializer) { this.mode = SerializationMode.SharedType; this.preserveObjectReferences = true; this.streamingContext = serializer.Context; this.binder = serializer.Binder; this.surrogateSelector = serializer.SurrogateSelector; this.surrogateDataContracts = surrogateDataContracts; }
// XMLObjectWriter Constructor internal ObjectWriter(ISurrogateSelector selector, StreamingContext context, InternalFE formatterEnums, SerializationBinder binder) { m_currentId = 1; m_surrogates = selector; m_context = context; m_binder = binder; this.formatterEnums = formatterEnums; m_objectManager = new SerializationObjectManager(context); SerTrace.InfoLog( formatterEnums.FEtypeFormat +" "+ ((Enum)formatterEnums.FEserializerTypeEnum)); }
internal ObjectReader(Stream stream, ISurrogateSelector selector, StreamingContext context, InternalFE formatterEnums, SerializationBinder binder) { if (stream == null) { throw new ArgumentNullException("stream", Environment.GetResourceString("ArgumentNull_Stream")); } this.m_stream = stream; this.m_surrogates = selector; this.m_context = context; this.m_binder = binder; if (this.m_binder != null) { ResourceReader.TypeLimitingDeserializationBinder binder2 = this.m_binder as ResourceReader.TypeLimitingDeserializationBinder; if (binder2 != null) { binder2.ObjectReader = this; } } this.formatterEnums = formatterEnums; }
internal ObjectReader(Stream stream, ISurrogateSelector selector, StreamingContext context, InternalFE formatterEnums, SerializationBinder binder) { if (stream == null) { throw new ArgumentNullException("stream", SoapUtil.GetResourceString("ArgumentNull_Stream")); } this.m_stream = stream; this.m_surrogates = selector; this.m_context = context; this.m_binder = binder; this.formatterEnums = formatterEnums; if (formatterEnums.FEtopObject != null) { this.IsFakeTopObject = true; } else { this.IsFakeTopObject = false; } this.m_formatterConverter = new FormatterConverter(); }
public static T DeserializeWithDecompression <T>(this byte[] buffer, SerializationBinder serializationBinder = null) { using (var compressedMemoryStream = new MemoryStream(buffer)) { using (var decompressedMemoryStream = new MemoryStream()) { using (var deCompressor = new GZipStream(compressedMemoryStream, CompressionMode.Decompress)) { IFormatter formatter = new BinaryFormatter(); using (var buffStream = new BufferedStream(deCompressor, 65536)) { buffStream.CopyTo(decompressedMemoryStream); decompressedMemoryStream.Position = 0; // To prevent errors serializing between version number differences (e.g. Version 1 serializes, and Version 2 deserializes) // inspired by: http://spazzarama.com/2009/06/25/binary-deserialize-unable-to-find-assembly/ formatter.Binder = serializationBinder; var result = (T)formatter.Deserialize(decompressedMemoryStream); buffStream.Close(); return(result); } } } } }
/// <summary> /// Deserialize a Byte Array to T object, using a custom Binder /// to help resolve the types referred to in the serialized stream /// </summary> /// <param name="frozen">Array of <see cref="System.Byte"/> containing a previously serialized object</param> /// <param name="customBinder">Subclass of <see cref="System.Runtime.Serialization.SerializationBinder"/></param> /// <returns>T instance or null</returns> public static T FromBinary(Byte[] frozen, System.Runtime.Serialization.SerializationBinder customBinder) { if (frozen.Length <= 0) { throw new ArgumentOutOfRangeException("frozenObject", "Cannot thaw a zero-length Byte[] array"); } if (customBinder == null) { throw new ArgumentNullException("customBinder", "SerializationBinder implementation cannot be null"); } System.Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter(); formatter.Binder = customBinder; System.IO.Stream stream = new System.IO.MemoryStream(frozen); try { return((T)formatter.Deserialize(stream)); } finally { stream.Close(); } }
[System.Security.SecurityCritical] // auto-generated internal static WriteObjectInfo Serialize(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SerializationBinder binder) { WriteObjectInfo soi = GetObjectInfo(serObjectInfoInit); soi.InitSerialize(objectType, surrogateSelector, context, serObjectInfoInit, converter, binder); return soi; }
[System.Security.SecurityCritical] // auto-generated internal void InitSerialize(Object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter, SerializationBinder binder) { SerTrace.Log( this, objectInfoId," Constructor 1 ",obj); this.context = context; this.obj = obj; this.serObjectInfoInit = serObjectInfoInit; ISurrogateSelector surrogateSelectorTemp; #if FEATURE_REMOTING if (RemotingServices.IsTransparentProxy(obj)) objectType = Converter.typeofMarshalByRefObject; else #endif objectType = obj.GetType(); if (objectType.IsArray) { isArray = true; InitNoMembers(); return; } InvokeSerializationBinder(binder); SerTrace.Log( this, objectInfoId," Constructor 1 trace 2"); objectWriter.ObjectManager.RegisterObject(obj); if (surrogateSelector != null && (serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp)) != null) { SerTrace.Log( this, objectInfoId," Constructor 1 trace 3"); si = new SerializationInfo(objectType, converter); if (!objectType.IsPrimitive) serializationSurrogate.GetObjectData(obj, si, context); InitSiWrite(); } else if (obj is ISerializable) { if (!objectType.IsSerializable) { throw new SerializationException(Environment.GetResourceString("Serialization_NonSerType", objectType.FullName, objectType.Assembly.FullName)); } si = new SerializationInfo(objectType, converter, !FormatterServices.UnsafeTypeForwardersIsEnabled()); #if FEATURE_SERIALIZATION ((ISerializable)obj).GetObjectData(si, context); #endif SerTrace.Log( this, objectInfoId," Constructor 1 trace 4 ISerializable "+objectType); InitSiWrite(); CheckTypeForwardedFrom(cache, objectType, binderAssemblyString); } else { SerTrace.Log(this, objectInfoId," Constructor 1 trace 5"); InitMemberInfo(); CheckTypeForwardedFrom(cache, objectType, binderAssemblyString); } }
/// <summary> /// Write a type value to the binary writer. /// </summary> /// <param name="binaryWriter"> /// The binary writer. /// </param> /// <param name="type"> /// The type. /// </param> /// <param name="binder"> /// The serialization binder. /// </param> private static void WriteType(BinaryWriter binaryWriter, Type type, SerializationBinder binder) { var tuple = TypeNameCache.GetOrAdd( type, _ => { string assemblyName; string typeName; binder.BindToName(type, out assemblyName, out typeName); return new Tuple<string, string>(assemblyName, typeName); }); binaryWriter.Write(tuple.Item1); binaryWriter.Write(tuple.Item2); }
internal ObjectReader(Stream stream, ISurrogateSelector selector, StreamingContext context, InternalFE formatterEnums, SerializationBinder binder) { SerTrace.Log( this, "Constructor ISurrogateSelector ",((selector == null)?"null selector ":"selector present")); if (stream==null) { throw new ArgumentNullException("stream", Environment.GetResourceString("ArgumentNull_Stream")); } m_stream=stream; m_surrogates = selector; m_context = context; m_binder = binder; this.formatterEnums = formatterEnums; //SerTrace.Log( this, "Constructor formatterEnums.FEtopObject ",formatterEnums.FEtopObject); }
public LegacyDeserializationHelper(SerializationBinder binder, ISurrogateSelector surrogate) { this.binder = binder; this.surrogate = surrogate; }
[System.Security.SecurityCritical] // auto-generated internal void InitSerialize(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SerializationBinder binder) { SerTrace.Log( this, objectInfoId," Constructor 2 ",objectType); this.objectType = objectType; this.context = context; this.serObjectInfoInit = serObjectInfoInit; if (objectType.IsArray) { InitNoMembers(); return; } InvokeSerializationBinder(binder); ISurrogateSelector surrogateSelectorTemp = null; if (surrogateSelector!=null) serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp); if (serializationSurrogate != null) { isSi = true; } else if (Object.ReferenceEquals(objectType, Converter.typeofObject)) { } else if (Converter.typeofISerializable.IsAssignableFrom(objectType)) isSi = true; if (isSi) { si = new SerializationInfo(objectType, converter); cache = new SerObjectInfoCache(objectType); } else { InitMemberInfo(); } SerTrace.Log( this,objectInfoId," ", objectType," InitSerialize Exit ",isSi); }
/// <summary> /// Глубокое (полное) клонирование объекта /// </summary> /// <remarks>Все клонируемые объекты должны иметь атрибут Serializable</remarks> public static object DeepClone(object obj, SerializationBinder binder = null) { using (MemoryStream ms = new MemoryStream()) { BinaryFormatter bf = new BinaryFormatter(); if (binder != null) bf.Binder = binder; bf.Serialize(ms, obj); ms.Position = 0; return bf.Deserialize(ms); } }
private DynamicTypeRenamingSerializationBinder(bool useStaticBaseInstance) { _binder = useStaticBaseInstance ? BaseInstance : new DefaultSerializationBinder(); }
private void CreateDefaultBinder() { mBinder = new DiagramBinder(); }
public SerializationBinderAdapter(System.Runtime.Serialization.SerializationBinder serializationBinder) { Class6.yDnXvgqzyB5jw(); base(); this.SerializationBinder = serializationBinder; }
public FileSerializer(SerializationBinder binder) { _binder = binder; }
[System.Security.SecurityCritical] // auto-generated internal void InitSerialize(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SerializationBinder binder) { SerTrace.Log( this, objectInfoId," Constructor 2 ",objectType); this.objectType = objectType; this.context = context; this.serObjectInfoInit = serObjectInfoInit; if (objectType.IsArray) { InitNoMembers(); return; } InvokeSerializationBinder(binder); ISurrogateSelector surrogateSelectorTemp = null; if (surrogateSelector!=null) serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp); if (serializationSurrogate != null) { // surrogate does not have this problem since user has pass in through the BF's ctor si = new SerializationInfo(objectType, converter); cache = new SerObjectInfoCache(objectType); isSi = true; } else if (Object.ReferenceEquals(objectType, Converter.typeofObject)) { } else if (Converter.typeofISerializable.IsAssignableFrom(objectType)) { si = new SerializationInfo(objectType, converter, !FormatterServices.UnsafeTypeForwardersIsEnabled()); cache = new SerObjectInfoCache(objectType); CheckTypeForwardedFrom(cache, objectType, binderAssemblyString); isSi = true; } if (!isSi) { InitMemberInfo(); CheckTypeForwardedFrom(cache, objectType, binderAssemblyString); } SerTrace.Log( this,objectInfoId," ", objectType," InitSerialize Exit ",isSi); }
private void InvokeSerializationBinder(SerializationBinder binder) { if (binder != null) { binder.BindToName(objectType, out binderAssemblyString, out binderTypeName); } }
// Update the overloads whenever you are changing this method internal static void WriteClrTypeInfo(XmlWriterDelegator writer, Type dataContractType, SerializationBinder binder, string defaultClrTypeName, string defaultClrAssemblyName) { string clrTypeName = null; string clrAssemblyName = null; if (binder != null) { binder.BindToName(dataContractType, out clrAssemblyName, out clrTypeName); } if (clrTypeName == null) { clrTypeName = defaultClrTypeName; } if (clrAssemblyName == null) { clrAssemblyName = defaultClrAssemblyName; } WriteClrTypeInfo(writer, clrTypeName, clrAssemblyName); }
internal static object DeserializeEx(byte[] data, SerializationBinder binder) { MemoryStream stream = new MemoryStream(CompressHelper.Decompress(data)); System.Runtime.Serialization.IFormatter formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter(); formatter.Binder = binder; object obj = formatter.Deserialize(stream); stream.Close(); stream.Dispose(); return obj; }
public ObjectWriter (BinaryFormatter formatter) { _surrogateSelector = formatter.SurrogateSelector; _context = formatter.Context; _assemblyFormat = formatter.AssemblyFormat; _typeFormat = formatter.TypeFormat; _manager = new SerializationObjectManager (formatter.Context); #if NET_4_0 _binder = formatter.Binder; #endif }
// Update the overloads whenever you are changing this method internal static void WriteClrTypeInfo(XmlWriterDelegator writer, DataContract dataContract, SerializationBinder binder) { if (!dataContract.IsISerializable && !(dataContract is SurrogateDataContract)) { TypeInformation typeInformation = null; Type clrType = dataContract.OriginalUnderlyingType; string clrTypeName = null; string clrAssemblyName = null; if (binder != null) { binder.BindToName(clrType, out clrAssemblyName, out clrTypeName); } if (clrTypeName == null) { typeInformation = NetDataContractSerializer.GetTypeInformation(clrType); clrTypeName = typeInformation.FullTypeName; } if (clrAssemblyName == null) { clrAssemblyName = (typeInformation == null) ? NetDataContractSerializer.GetTypeInformation(clrType).AssemblyString : typeInformation.AssemblyString; // Throw in the [TypeForwardedFrom] case to prevent a partially trusted assembly from forwarding itself to an assembly with higher privileges if (!UnsafeTypeForwardingEnabled && !clrType.Assembly.IsFullyTrusted && !IsAssemblyNameForwardingSafe(clrType.Assembly.FullName, clrAssemblyName)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.TypeCannotBeForwardedFrom, DataContract.GetClrTypeFullName(clrType), clrType.Assembly.FullName, clrAssemblyName))); } } WriteClrTypeInfo(writer, clrTypeName, clrAssemblyName); } }
internal ObjectReader(Stream stream, ISurrogateSelector selector, StreamingContext context, InternalFE formatterEnums, SerializationBinder binder) { if (stream == null) { throw new ArgumentNullException("stream", Environment.GetResourceString("ArgumentNull_Stream")); } Contract.EndContractBlock(); SerTrace.Log(this, "Constructor ISurrogateSelector ", ((selector == null) ? "null selector " : "selector present")); m_stream=stream; m_surrogates = selector; m_context = context; m_binder = binder; #if !FEATURE_PAL && FEATURE_SERIALIZATION // This is a hack to allow us to write a type-limiting deserializer // when we know exactly what type to expect at the head of the // object graph. if (m_binder != null) { ResourceReader.TypeLimitingDeserializationBinder tldBinder = m_binder as ResourceReader.TypeLimitingDeserializationBinder; if (tldBinder != null) tldBinder.ObjectReader = this; } #endif // !FEATURE_PAL && FEATURE_SERIALIZATION this.formatterEnums = formatterEnums; //SerTrace.Log( this, "Constructor formatterEnums.FEtopObject ",formatterEnums.FEtopObject); }
// Update the overloads whenever you are changing this method internal static void WriteClrTypeInfo(XmlWriterDelegator writer, Type dataContractType, SerializationBinder binder, SerializationInfo serInfo) { TypeInformation typeInformation = null; string clrTypeName = null; string clrAssemblyName = null; if (binder != null) { binder.BindToName(dataContractType, out clrAssemblyName, out clrTypeName); } if (clrTypeName == null) { if (serInfo.IsFullTypeNameSetExplicit) { clrTypeName = serInfo.FullTypeName; } else { typeInformation = NetDataContractSerializer.GetTypeInformation(serInfo.ObjectType); clrTypeName = typeInformation.FullTypeName; } } if (clrAssemblyName == null) { if (serInfo.IsAssemblyNameSetExplicit) { clrAssemblyName = serInfo.AssemblyName; } else { clrAssemblyName = (typeInformation == null) ? NetDataContractSerializer.GetTypeInformation(serInfo.ObjectType).AssemblyString : typeInformation.AssemblyString; } } WriteClrTypeInfo(writer, clrTypeName, clrAssemblyName); }
public DocTemplate(string[] astr, Type typeDoc, Type typeFrame, Type typeView, SerializationBinder serBinder) { m_astr = (string[])astr.Clone(); m_typeDoc = typeDoc; m_typeFrame = typeFrame; m_typeView = typeView; m_alsDocuments = new ArrayList(); m_serBinder = serBinder; }
internal SecurityBinder(SerializationBinder delegateBinder) { _delegateBinder = delegateBinder; }
public JsonFormatter(SerializationBinder binder, StreamingContext context) { this.binder = binder; this.context = context; }