BinaryFormatter 反序列化给出 SerializationException

Question

我得到一个：

System.Runtime.Serialization.SerializationException：无法找到 程序集'myNameSpace，版本= 1.0.0.0，文化=中性， PublicKeyToken=null

当尝试在另一个程序中反序列化某些数据而不是我序列化它的程序时。

经过一番谷歌搜索后，我发现显然这只能使用共享程序集来完成。

但是，我的数据库充满了这些序列化对象，我需要一个实用程序来将它们取出。有没有办法覆盖这种行为，只给它提供完全相同的类并强制它反序列化？

---

我已经找到了这个片段，但我不明白应该如何以及在哪里放置/使用它。

   static constructor() {
        AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
   }

    static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args) {
        Assembly ayResult = null;
        string sShortAssemblyName = args.Name.Split(',')[0];
         Assembly[] ayAssemblies = AppDomain.CurrentDomain.GetAssemblies();
         foreach (Assembly ayAssembly in ayAssemblies) {
            if (sShortAssemblyName == ayAssembly.FullName.Split(',')[0]) {
                 ayResult = ayAssembly;
                 break;
            }
         }
         return ayResult;
    }

Answer 1

如果您知道该对象，则无需 DLL 即可解决此问题...

http://spazzarama.com/2009/06/25/binary-deserialize-unable-to-find- assembly/

http://msdn.microsoft.com/en-us/library/system.runtime.serialization。序列化binder(VS.71).aspx

使用“System.Runtime.Serialization.SerializationBinder”类。经过
继承此类可以重定向所有请求
适用于从二进制格式化程序到您选择的类型的类型。

下面是一个示例，它将允许在当前程序集中找到类型，无论最初创建序列化流的程序集版本如何：

sealed class AllowAllAssemblyVersionsDeserializationBinder : System.Runtime.Serialization.SerializationBinder
{
    public override Type BindToType(string assemblyName, string typeName)
    {     
        String currentAssembly = Assembly.GetExecutingAssembly().FullName;

        // In this case we are always using the current assembly
        assemblyName = currentAssembly;

        // Get the type using the typeName and assemblyName
        Type typeToDeserialize = Type.GetType(String.Format("{0}, {1}",
            typeName, assemblyName));

        return typeToDeserialize;
    }
}

public static MyRequestObject Deserialize(byte[] b)
{
    MyRequestObject mro = null;
    var formatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
    using (var ms = new System.IO.MemoryStream(b))
    {
       // To prevent errors serializing between version number differences (e.g. Version 1 serializes, and Version 2 deserializes)
       formatter.Binder = new AllowAllAssemblyVersionsDeserializationBinder();

       // Allow the exceptions to bubble up
       // System.ArgumentNullException
       // System.Runtime.Serialization.SerializationException
       // System.Security.SecurityException
       mro = (MyRequestObject)formatter.Deserialize(ms);
       ms.Close();
       return mro;
    }
}

Answer 2

您需要以某种方式提供对原始类型的引用，以便实用程序知道如何反序列化它。

最简单的方法就是添加最初定义类型的 DLL 作为对实用程序项目的引用。

您发布的代码允许您在解串器确定找不到类型时动态加载相同的 DLL。这是一种更困难的方法（但并不那么困难），但在这两种情况下，您都需要一个定义类型的 DLL...因此可能最简单的方法是通过添加引用来静态链接。

如果您的类型当前不在 DLL 中（例如，如果它们在 EXE 中），我建议您将这些类从 EXE 中提取到新的 DLL 中，并从原始项目和 util 项目引用该 DLL。

Answer 3

我遇到了类似的问题，并在以下链接的帮助下解决了问题：
BinaryFormatter反序列化-not-finding-a-type

基本上，您需要做的是在反序列化之前订阅 AssemblyResolve 事件。然后反序列化后取消订阅。

AppDomain.CurrentDomain.AssemblyResolve +=
                new ResolveEventHandler(CurrentDomain_AssemblyResolve);
// CODE TO DESERIALIZE HERE

AppDomain.CurrentDomain.AssemblyResolve -= new ResolveEventHandler(CurrentDomain_AssemblyResolve);

这里是我用来解析Assembly的方法：

static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
    try
    {
        if(args.Name == "MY ASSEMBLY NAME"))
        {
            //Load my Assembly 
            Assembly assem = Assembly.LoadFrom("MY ASSEMBLY PATH");
            if(assem != null)
                return assem;
        }
    }
    catch { ;}

    return Assembly.GetExecutingAssembly();
}

Answer 4

JTtheGeek 的答案是正确的，自定义 SerializationBinder 是处理此问题的方法。不过，该答案中给出的示例代码不足以满足我的用例。我需要的东西可以：

1. 处理不匹配的版本号和命名空间。
2. 查看所有程序集，而不仅仅是当前程序集。
3. 仍然足够快，每秒调用 100 次。

这就是我想出的：

using System;
using System.Collections.Generic;
using System.Linq;

namespace Company.Product.Common.Serialize
{
    /// <summary>
    /// A Serialization Binder that allows inexact matches (version number or namespace).
    /// </summary>
    public sealed class AllowInexactMatchSerializationBinder : System.Runtime.Serialization.SerializationBinder
    {
        static private Dictionary<string, Type> typeBindings = new Dictionary<string, Type>();

        /// <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;
            var assemblyQualifiedTypeName = String.Format("{0}, {1}", typeName, assemblyName);

            // use cached result if it exists
            if (typeBindings.TryGetValue(assemblyQualifiedTypeName, out type))
            {
                return type;
            }

            // try the fully qualified name
            try { type = Type.GetType(assemblyQualifiedTypeName); }
            catch { type = null; }

            if (type == null)
            {
                // allow any assembly version
                var assemblyNameWithoutVersion = assemblyName.Remove(assemblyName.IndexOf(','));
                var assemblyQualifiedTypeNameWithoutVersion = String.Format("{0}, {1}", typeName, assemblyNameWithoutVersion);
                try { type = Type.GetType(assemblyQualifiedTypeNameWithoutVersion); }
                catch { type = null; }
            }

            if (type == null)
            {
                // check all assemblies for type full name
                try
                {
                    type = AppDomain.CurrentDomain.GetAssemblies()
                        .SelectMany(a => a.ExportedTypes)
                        .Where(a => a.FullName == typeName)
                        .FirstOrDefault();
                }
                catch { type = null; }
            }

            if (type == null)
            {
                // check all assemblies for type name
                var name = typeName.Split('.').Last();
                try
                {
                    type = AppDomain.CurrentDomain.GetAssemblies()
                        .SelectMany(a => a.ExportedTypes)
                        .Where(a => a.Name == name)
                        .FirstOrDefault();
                }
                catch { type = null; }
            }

            typeBindings[assemblyQualifiedTypeName] = type;
            return type;
        }
    }
}

Answer 5

如果您无权访问序列化数据的原始程序集，则可以使用 SerializationBinder 或 SerializationSurrogate。这两个接口允许您控制反序列化时类型之间如何转换。

Answer 6

我遵循了 JTtheGeek 回答的解决方案，为了让它为我工作，我必须在语句 assemblyName = currentAssembly; 之前添加以下内容：

typeName = "yourNamespace.yourClassName";

之后效果很好！