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