BinaryFormatter fails to deserialize by hmanner

Dont use any formatter.

Use XML formatting methods to objects and pass xml content between client and server.

We are currently using an assembly resolver, ignoring the version of the assemblies.

Regarding the last posted workaround...using XML...well...sigh...now that's what I call a workaround...hehe.



See the AppDomain.AssemblyResolve event.

My error was:
Could not load file or assembly 'System.Runtime.Serialization, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' or one of its dependencies. The system cannot find the file specified."
I started getting it right after uninstalling the Visual Studio Extensions for WinFX beta 1.
Repaired my visualstudio /.net2 installations still same error.

This is the most generic workaround ever and probably opens up major security holes given the lines commented out, but I'll be transfered to my new pc on Monday. I commented out the following lines in my global web.config file.
Note: I would not suggest this except for a very slacked out alternative, but my web projects compile now.


                <!--<add assembly="System.Runtime.Serialization, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL" />-->
                <!--<add assembly="System.Security.Authorization, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL" />-->
                <!--<add assembly="System.ServiceModel, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />-->




<!--<add name="ServiceModel" type="System.ServiceModel.Channels.HttpModule, System.ServiceModel, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />-->

We have had serious problems with this, and finally raised an MSDN incident and it has been confirmed as a problem, although it is not known when a fix will be available, or whether the fix, when it comes, will allow generic objects serialised without the fix to be deserialised by code with the fix. They also confirmed that the AssemblyResolve event was a valid workaround, and that it shouldn't have any adverse effects. They pointed out that the event only needs to be subscribed to once per app domain, as long as the program only has one app domain the subscription can be put in Main regardless how many assemblies or threads are doing serialisation.
For the benefit of others in the same boat, this is how I think the event handler should look (if anyone know better I'd be interested):

System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
    // args.Name looks like this:
    // "<AssemblyName>, Version=<major>.<minor>.<build>.<revison>, Culture=neutral, PublicKeyToken=<16 hexit number>"
    // We need to parse it to extract the version number and the simple name
    string versionStr = args.Name.Substring(args.Name.IndexOf("=") + 1);    // Don't look for "Version" it may vary by locale
    versionStr = versionStr.Substring(0, versionStr.IndexOf(","));
    string simpleName = args.Name.Substring(0, args.Name.IndexOf(','));

    // Load the assembly using just the name
    AssemblyName assemblyName = new AssemblyName();
    assemblyName.Name = simpleName;
    Assembly assembly = Assembly.Load(assemblyName);

    // Now replace the assembly's version number with the required version and return it.
    assembly.GetName().Version = new Version(versionStr);
    return assembly;
}

I built a dll that is simply a generic class I use to serialize/deserialize when transfering over named pipes. Since all projects reference the same library, I am not getting this error.


Below is all that exists in the project and then the server projects (multiple windows services) reference this project. Everyone is using the same version so it satisfies the assembly verification when deserializing

''' <summary>
''' Object used to transfer between server/client
''' </summary>
''' <remarks>Contains the action, data and session GUID</remarks>
<Serializable()> Public Class TransferObject

    Public Action As String
    Public transferObject As Object
    Private reqID As Guid

    Public ReadOnly Property requestID() As Guid
        Get
            Return reqID
        End Get
    End Property
    Public Sub New()
        reqID = Guid.NewGuid
    End Sub

End Class

The above has allowed me to transfer this generic object over a TCP connection, then from service to service via named pipes.

Hope this helps!

If the type and all its members are in the current assembly, you attach the following custom Binder to the BinaryFormatter (using the Binder property).

/// <summary>
/// This binder will ignore the assembly information, thus allowing deserializing from different assembly versions.
/// </summary>
private class SimpleBinder : System.Runtime.Serialization.SerializationBinder
{
public override Type BindToType(string assemblyName, string typeName)
{
    //assemblyName ignored.
    return Type.GetType(typeName);
}
}

This solution can be used, if you don't want to alter the assembly resolving of the whole AppDomain. The Binder implementation can be easily modified, so it can load other assemblies.

Hooking into the AssemblyResolve event works for my. However, make sure to use the AssemblyName class to parse the full name of the assembly, rather than implementing your own parsing logic.

I am still facing problems in non-Generic types. Using custom binder doesn't help even if all the types are resolved i.e.

private class SimpleBinder : System.Runtime.Serialization.SerializationBinder
{
public override Type BindToType(string assemblyName, string typeName)
{
    newAssemblyName = "Client.PersonalArchivalEngine.Base";
    return Type.GetType(newAssemblyName,typeName);
}
}

I still get this error message from the given stack trace given below...

Could not load file or assembly 'Client.PersonalArchivalEngine.Base, Version=1.0.3056.37064, Culture=neutral, PublicKeyToken=null' or one of its dependencies. The located assembly's manifest definition does not match the assembly reference. (Exception from HRESULT: 0x80131040)</Message>
    <StackTrace> at System.Reflection.Assembly._nLoad(AssemblyName fileName, String codeBase, Evidence assemblySecurity, Assembly locationHint, StackCrawlMark& stackMark, Boolean throwOnFileNotFound, Boolean forIntrospection)
at System.Reflection.Assembly.nLoad(AssemblyName fileName, String codeBase, Evidence assemblySecurity, Assembly locationHint, StackCrawlMark& stackMark, Boolean throwOnFileNotFound, Boolean forIntrospection)
at System.Reflection.Assembly.InternalLoad(AssemblyName assemblyRef, Evidence assemblySecurity, StackCrawlMark& stackMark, Boolean forIntrospection)
at System.Reflection.Assembly.InternalLoad(String assemblyString, Evidence assemblySecurity, StackCrawlMark& stackMark, Boolean forIntrospection)
at System.Reflection.Assembly.Load(String assemblyString)
at System.UnitySerializationHolder.GetRealObject(StreamingContext context)
at System.Runtime.Serialization.ObjectManager.ResolveObjectReference(ObjectHolder holder)
at System.Runtime.Serialization.ObjectManager.DoFixups()
at System.Runtime.Serialization.Formatters.Binary.ObjectReader.Deserialize(HeaderHandler handler, __BinaryParser serParser, Boolean fCheck, Boolean isCrossAppDomain, IMethodCallMessage methodCallMessage)
at System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Deserialize(Stream serializationStream, HeaderHandler handler, Boolean fCheck, Boolean isCrossAppDomain, IMethodCallMessage methodCallMessage)
at System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Deserialize(Stream serializationStream)</StackTrace>

AssemblyResolve works fine.

I wonder why this bug hasn't been fixed till now.

The workaround of AssemblyResolve works for deserialization. But after the object is deserialized, it cannot be casted to the required type. (Seems the version change also fails this). How are you guys working around this?

As stated in other comments, using a SerializationBinder is a way to fix the issue. Since none provided a sample here it is one.

/// <summary>
/// Class used to allow for deserialization of types hosted in assemblies having different versions.
/// </summary>
/// <remarks>The binder will always match requested assembly with currently available one, without knowing if this action is legal or not.</remarks>
private sealed class VersionAgnosticSerializationBinder : System.Runtime.Serialization.SerializationBinder
{
        /// <summary>
        /// When overridden in a derived class, controls the binding of a serialized object to a type.
        /// </summary>
        /// <param name="assemblyName">Specifies the <see cref="T:System.Reflection.Assembly"/> name of the serialized object.</param>
        /// <param name="typeName">Specifies the <see cref="T:System.Type"/> name of the serialized object.</param>
        /// <returns>
        /// The type of the object the formatter creates a new instance of.
        /// </returns>
        public override Type BindToType(string assemblyName, string typeName)
        {
                Type type = Type.GetType((System.Reflection.Assembly.CreateQualifiedName(assemblyName, typeName)));

                if (type == null)
                {
                        //A full name was passed, we need the simple one!
                        string simpleAssemblyName = assemblyName.Split(',').FirstOrDefault();

                        if (string.IsNullOrEmpty(simpleAssemblyName))
                                throw new InvalidOperationException("Cannot retrieve assembly name from string '" + assemblyName + "'");

                        System.Reflection.Assembly currentAssembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((System.Reflection.Assembly assembly) => { return (assembly.GetName().Name.Equals(simpleAssemblyName)); });

                        if (currentAssembly == null)
                                throw new InvalidOperationException("The requested assembly '" + simpleAssemblyName + "' was not found");

                        type = currentAssembly.GetType(typeName);
                }

                if (type == null)
                        System.Diagnostics.Debug.WriteLine("Cannot bind requested type '" + string.Format("{0}, {1}", assemblyName, typeName), GetType().ToString());

                return type;
        }
}