CustomSerializerSurrogateSelector Class

[ObsoleteAttribute("It is not recommended to use this class because it's basically used for solving BinaryFormatter incompatibility issues between different platforms. For KGy SOFT's BinarySerializationFormatter this class is not really needed. Or if so, it's a sign that binary serialization is not used in a secure way.")]
public sealed class CustomSerializerSurrogateSelector : ISurrogateSelector, 
	ISerializationSurrogate, IDisposable

<ObsoleteAttribute("It is not recommended to use this class because it's basically used for solving BinaryFormatter incompatibility issues between different platforms. For KGy SOFT's BinarySerializationFormatter this class is not really needed. Or if so, it's a sign that binary serialization is not used in a secure way.")>
Public NotInheritable Class CustomSerializerSurrogateSelector
	Implements ISurrogateSelector, ISerializationSurrogate, IDisposable

[ObsoleteAttribute(L"It is not recommended to use this class because it's basically used for solving BinaryFormatter incompatibility issues between different platforms. For KGy SOFT's BinarySerializationFormatter this class is not really needed. Or if so, it's a sign that binary serialization is not used in a secure way.")]
public ref class CustomSerializerSurrogateSelector sealed : ISurrogateSelector, 
	ISerializationSurrogate, IDisposable

[<SealedAttribute>]
[<ObsoleteAttribute("It is not recommended to use this class because it's basically used for solving BinaryFormatter incompatibility issues between different platforms. For KGy SOFT's BinarySerializationFormatter this class is not really needed. Or if so, it's a sign that binary serialization is not used in a secure way.")>]
type CustomSerializerSurrogateSelector = 
    class
        interface ISurrogateSelector
        interface ISerializationSurrogate
        interface IDisposable
    end

Inheritance

Object    CustomSerializerSurrogateSelector

Implements

IDisposable, ISerializationSurrogate, ISurrogateSelector

By using the CustomSerializerSurrogateSelector you can serialize and deserialize any types.

To serialize a non-serializable type, or a type, which contains non-serializable types, it is usually enough to assign a CustomSerializerSurrogateSelector to the formatter:

var formatter = new BinaryFormatter { SurrogateSelector = new CustomSerializerSurrogateSelector() };
formatter.Serialize(stream, myObject);

Solving compatibility issues between different platforms

Basic case

If the only difference is that the type, which is serializable in the original platform is not marked by the SerializableAttribute in the new one (e.g.: MemoryStream is not serializable in .NET Core, but otherwise it is still the same as in .NET Framework), then it is enough to use the default CustomSerializerSurrogateSelector:

C#Copy

// deserializing a MemoryStream in .NET Core that was serialized in .NET Framework
var formatter = new BinaryFormatter { SurrogateSelector = new CustomSerializerSurrogateSelector() };
var memoryStream = (MemoryStream)formatter.Deserialize(streamSerializedInNetFramework);

The original type implements ISerializable

In .NET Core there are several types that still implement ISerializable, though their ISerializable.GetObjectData method throws a PlatformNotSupportedException (e.g. DBNull, Type and Assembly in .NET Core 2.0). On the other hand, in .NET Core 3.0 DBNull is serializable again, Assembly remained the same and from Type the ISerializable implementation has also been removed along with the SerializableAttribute. For such cases there are more possible solutions:

• In best cases it is enough to use the BinarySerializationFormatter both for serializing and deserializing without any surrogate selector. It natively supports Type instances on all platforms.
• When serializing by CustomSerializerSurrogateSelector you can set the IgnoreISerializable property to force serializing the object by fields. If the fields are the same on the deserializing side, then the object will be deserializable by using the CustomSerializerSurrogateSelector on both sides with the same settings.
• If fields have also changed you can customize the serializing and deserializing process by handling the events (see below).

Providing backwards compatibility

The Basic case might not work the other way around: serializing an object in .NET Core might not be deserializable in .NET Framework, for example. It can be avoided if:

• You use BinarySerializationFormatter instead of BinaryFormatter. It supports many types natively, including many core collections and simple types. These types are always encoded in a platform-independent way, which is also very compact.
• You can serialize the types using the ForwardedTypesSerializationBinder with setting the WriteLegacyIdentity property to to use assembly identities of the .NET Framework for most public types. These types can be resolved on all platforms. This solution works even with BinaryFormatter.
• Alternatively, you can use the BinarySerializationFormatter with the OmitAssemblyQualifiedNames, or the WeakAssemblySerializationBinder (works also with BinaryFormatter) to allow to omit assembly identities in the serialized stream. Such a stream can be deserialized if all the assemblies that contain the types to be deserialized are already loaded and the full names of the types are unambiguous in the loaded assemblies.

Deserializing refactored types

If the object was serialized by fields but the field names have been refactored since then, then you can handle the SettingField event where you can either look up and set the appropriate Field or do whatever custom processing and set the Handled property to to indicate that you processed the entry manually. If you can initialize the complete object by yourself based on the serialized SerializationInfo, then you can handle the Deserializing event and set the Handled property to .

C#Copy

// deserializing a type, whose fields used to have "m_" prefix, which have been removed
var surrogate = new CustomSerializerSurrogateSelector();
surrogate.Deserializing += (sender, args) =>
{
    // manipulating data only if the current class is the one that changed
    if (!(args.Object is MyChangedClass))
        return;

    // Replacing serialization entry names using the ReplaceValue extension method.
    // An alternative solution would be initializing args.Object by ourselves and
    // setting the args.Handled to true to prevent default deserialization logic.
    foreach (SerializationEntry entry in args.SerializationInfo)
    {
        if (entry.Name.StartsWith("m_"))
            args.SerializationInfo.ReplaceValue(entry.Name, 
                entry.Name.Substring(2), entry.Value, entry.ObjectType);
    }
};

var formatter = new BinaryFormatter // or a BinarySerializationFormatter
{
    SurrogateSelector = surrogate, // to remap field names as specified above
    Binder = new WeakAssemblySerializationBinder() // if assembly version changed, too
};

return (MyChangedClass)formatter.Deserialize(streamContainingOldData);

  Tip

If the name of the type changed too, you can use the CustomSerializationBinder class.

Reference