XmlSerializer在构造函数中提供FileNotFoundException

我尝试使用的应用程序在尝试序列化类型时失败。

像这样的声明

XmlSerializer lizer = new XmlSerializer(typeof(MyType));

产生：

System.IO.FileNotFoundException occurred
  Message="Could not load file or assembly '[Containing Assembly of MyType].XmlSerializers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null' or one of its dependencies. The system cannot find the file specified."
  Source="mscorlib"
  FileName="[Containing Assembly of MyType].XmlSerializers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
  FusionLog=""
  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)

我没有为班级定义任何特殊的序列化器。

我该如何解决这个问题？

信不信由你，这是正常的行为。引发了一个异常，但由XmlSerializer处理，因此，如果您忽略它，则一切都应继续进行。

我发现这很烦人，如果您进行一些搜索，就会有很多关于此的投诉，但是据我了解，Microsoft并不打算对此做任何事情。

如果您为特定异常关闭了初次机会异常，则可以避免在调试时始终获得异常弹出窗口。在Visual Studio中，转到“ 调试” ->“ 异常”（或按Ctrl+ Alt+ E），“ 公共语言运行时异常” ->“ System.IO” ->“ System.IO.FileNotFoundException”。

您可以在博客文章C＃XmlSerializer FileNotFound异常（讨论Chris Sells的工具XmlSerializerPreCompiler）中找到有关它的另一种方法的信息。

就像马丁·舍本（Martin Sherburn）所说，这是正常现象。XmlSerializer的构造函数首先尝试查找名为[YourAssembly] .XmlSerializers.dll的程序集，该程序集应包含用于类型化序列化的生成的类。由于尚未生成此类DLL（默认情况下未生成），因此将引发FileNotFoundException。发生这种情况时，XmlSerializer的构造函数会捕获该异常，并且XmlSerializer的构造函数会在运行时自动生成DLL（这是通过在计算机的％temp％目录中生成C＃源文件，然后使用C＃编译器进行编译来完成的）。相同类型的XmlSerializer的其他构造将仅使用已生成的DLL。

更新：从.NET 4.5开始XmlSerializer，为了在运行时创建序列化程序程序集，它不再执行代码生成，也不再使用C＃编译器执行编译，除非通过设置配置文件设置（useLegacySerializerGeneration）强制这样做。此更改消除了对它的依赖csc.exe并提高了启动性能。^{来源：.NET Framework 4.5自述文件，第1.3.8.1节。}

异常由XmlSerializer的构造函数处理。您无需自己做任何事情，只需单击“继续”（F5）继续执行程序，一切都会好起来。如果您对停止程序执行并弹出异常帮助程序的异常感到不安，则可以关闭“仅我的代码”，或者将FileNotFoundException设置为在引发时中断执行，而不是在“ User-未处理”。

要启用“仅我的代码”，请转到工具>>选项>>调试>>常规>>启用仅我的代码。要在抛出FileNotFound时关闭执行中断功能，请转至调试>>异常>>查找>>输入'FileNotFoundException'>>取消选中System.IO.FileNotFoundException中的“ Thrown”复选框。

在Visual Studio项目属性（“构建”页面，如果我没记错的话）中有一个选项，表示“生成序列化程序集”。尝试为生成[包含MyType的程序集]的项目打开它。

有一个解决方法。如果您使用

XmlSerializer lizer = XmlSerializer.FromTypes(new[] { typeof(MyType) })[0];

它应该避免该异常。这对我有用。

警告： 请勿多次使用，否则会导致内存泄漏

如果使用此方法XmlSerializer多次创建同一类型的实例，您将疯狂地泄漏内存！

这是因为此方法绕过了XmlSerializer(type)和XmlSerializer(type, defaultNameSpace)构造函数提供的内置缓存（所有其他构造函数也绕过了缓存）。

如果您使用任何不通过这两个构造函数的方法来创建XmlSerializer，则必须实现自己的缓存，否则会浪费内存。

我遇到了这个确切的问题，无法通过提到的任何解决方案来解决。

然后我终于找到了解决方案。看来，序列化器不仅需要类型，而且还需要嵌套类型。改变这个：

XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));

对此：

XmlSerializer xmlSerializer = new XmlSerializer(typeof(T).GetNestedTypes());

为我解决了此问题。没有更多的例外或任何东西。

我的解决方案是直接思考创建序列化器。这绕过了导致异常的奇怪文件加载。我将其打包在一个辅助函数中，该函数还负责缓存序列化程序。

private static readonly Dictionary<Type,XmlSerializer> _xmlSerializerCache = new Dictionary<Type, XmlSerializer>();

public static XmlSerializer CreateDefaultXmlSerializer(Type type) 
{
    XmlSerializer serializer;
    if (_xmlSerializerCache.TryGetValue(type, out serializer))
    {
        return serializer;
    }
    else
    {
        var importer = new XmlReflectionImporter();
        var mapping = importer.ImportTypeMapping(type, null, null);
        serializer = new XmlSerializer(mapping);
        return _xmlSerializerCache[type] = serializer;
    }
}

为了避免异常，您需要做两件事：

1. 向序列化的类添加属性（希望您可以访问）
2. 使用sgen.exe生成序列化文件

将System.Xml.Serialization.XmlSerializerAssembly属性添加到您的类。将“ MyAssembly”替换为MyClass所在的程序集的名称。

[Serializable]
[XmlSerializerAssembly("MyAssembly.XmlSerializers")]
public class MyClass
{
…
}

使用sgen.exe实用程序生成序列化文件，并与类的程序集一起部署它。

'sgen.exe MyAssembly.dll'将生成文件MyAssembly.XmlSerializers.dll

这两个更改将使.net直接找到程序集。我检查了它，并在带有Visual Studio 2008的.NET Framework 3.5上运行

托管调试助手也可以捕获此异常称为BindingFailure（MDA）。

如果您的应用程序设计为附带预构建序列化程序集，则此MDA很有用。我们这样做是为了提高应用程序的性能。它使我们能够确保在构建过程中正确构建了预构建的序列化程序集，并在不进行即时重新构建的情况下由应用程序加载了该序列化程序集。

除非在这种情况下，否则它实际上没有用，因为正如其他张贴者所说的那样，当Serializer构造函数捕获绑定错误时，将在运行时重新构建序列化程序集。因此，您通常可以将其关闭。

函数XmlSerializer.FromTypes不会引发异常，但是会泄漏内存。这就是为什么您需要为每种类型缓存此类序列化程序，以避免为每个创建的实例泄漏内存。

创建您自己的XmlSerializer工厂并简单地使用它：

XmlSerializer serializer = XmlSerializerFactoryNoThrow.Create(typeof(MyType));

工厂看起来像：

public static class XmlSerializerFactoryNoThrow
{
    public static Dictionary<Type, XmlSerializer> _cache = new Dictionary<Type, XmlSerializer>();

    private static object SyncRootCache = new object();        

    /// <summary>
    /// //the constructor XmlSerializer.FromTypes does not throw exception, but it is said that it causes memory leaks
    /// http://stackoverflow.com/questions/1127431/xmlserializer-giving-filenotfoundexception-at-constructor
    /// That is why I use dictionary to cache the serializers my self.
    /// </summary>
    public static XmlSerializer Create(Type type)
    {
        XmlSerializer serializer;

        lock (SyncRootCache)
        {
            if (_cache.TryGetValue(type, out serializer))
                return serializer;
        }

        lock (type) //multiple variable of type of one type is same instance
        {
            //constructor XmlSerializer.FromTypes does not throw the first chance exception           
            serializer = XmlSerializer.FromTypes(new[] { type })[0];
            //serializer = XmlSerializerFactoryNoThrow.Create(type);
        }

        lock (SyncRootCache)
        {
            _cache[type] = serializer;
        }
        return serializer;
    }       
}

没有内存泄漏可能性的更复杂的版本（请检查代码）：

    public static XmlSerializer Create(Type type)
    {
        XmlSerializer serializer;

        lock (SyncRootCache)
        {
            if (_cache.TryGetValue(type, out serializer))
                return serializer;
        }

        lock (type) //multiple variable of type of one type is same instance
        {
            lock (SyncRootCache)
            {
                if (_cache.TryGetValue(type, out serializer))
                    return serializer;
            }
            serializer = XmlSerializer.FromTypes(new[] { type })[0];
            lock (SyncRootCache)
            {
                _cache[type] = serializer;
            }
        }          
        return serializer;
    }       
}

另一方面，对编译错误进行故障排除非常复杂。这些问题通过消息显示在FileNotFoundException中：

File or assembly name abcdef.dll, or one of its dependencies, was not found. File name: "abcdef.dll"
   at System.Reflection.Assembly.nLoad( ... )
   at System.Reflection.Assembly.InternalLoad( ... )
   at System.Reflection.Assembly.Load(...)
   at System.CodeDom.Compiler.CompilerResults.get_CompiledAssembly() 

您可能想知道，找不到文件异常与实例化序列化程序对象有什么关系，但请记住：构造函数将编写C＃文件并尝试对其进行编译。此异常的调用堆栈提供了一些很好的信息来支持这种怀疑。XmlSerializer尝试加载由CodeDOM调用System.Reflection.Assembly.Load方法生成的程序集时发生异常。该异常没有提供关于为何XmlSerializer应该创建的程序集不存在的解释。通常，不存在汇编程序是因为编译失败，这可能是因为在极少数情况下，序列化属性会产生C＃编译器无法编译的代码。

注意 当XmlSerializer在无法访问temp目录的帐户或安全环境下运行时，也会发生此错误。

来源：http : //msdn.microsoft.com/en-us/library/aa302290.aspx

在Visual Studio项目属性中，有一个选项“生成序列化程序集”。尝试为生成[包含MyType的程序集]的项目打开它。

要序列化的自定义类：

[Serializable]
public class TestClass
{
    int x = 2;
    int y = 4;
    public TestClass(){}
    public TestClass(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public int TestFunction()
    {
        return x + y;
    }
}

我已经附上了代码片段。也许这可以帮助您。

static void Main(string[] args)
{
    XmlSerializer xmlSerializer = new XmlSerializer(typeof(TestClass));

    MemoryStream memoryStream = new MemoryStream();
    XmlTextWriter xmlWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);

    TestClass domain = new TestClass(10, 3);
    xmlSerializer.Serialize(xmlWriter, domain);
    memoryStream = (MemoryStream)xmlWriter.BaseStream;
    string xmlSerializedString = ConvertByteArray2Str(memoryStream.ToArray());

    TestClass xmlDomain = (TestClass)DeserializeObject(xmlSerializedString);

    Console.WriteLine(xmlDomain.TestFunction().ToString());
    Console.ReadLine();
}

我遇到了类似的问题，并且忽略该异常对我不起作用。我的代码正在调用NServiceBus的配置Configure.With(...).XmlSerializer()...

对我来说固定的是更改项目平台。

1. 转到Build \ Configuration Manager ...
2. 查找您的项目并更改平台（在我的情况下，从x86更改为Any CPU）

仅供参考。从数据库的答案和评论中，我得到了与数据库解决方案非常接近的此解决方案。在我所有情况下，它都能正常工作，并且是线程安全的。我不认为使用ConcurrentDictionary是可以的。

using System;
using System.Collections.Generic;
using System.Xml.Serialization;

namespace HQ.Util.General
{
    public class XmlSerializerHelper
    {
        private static readonly Dictionary<Type, XmlSerializer> _dictTypeToSerializer = new Dictionary<Type, XmlSerializer>();

        public static XmlSerializer GetSerializer(Type type)
        {
            lock (_dictTypeToSerializer)
            {
                XmlSerializer serializer;
                if (! _dictTypeToSerializer.TryGetValue(type, out serializer))
                {
                    var importer = new XmlReflectionImporter();
                    var mapping = importer.ImportTypeMapping(type, null, null);
                    serializer = new XmlSerializer(mapping);
                    return _dictTypeToSerializer[type] = serializer;
                }

                return serializer;
            }
        }
    }
}

用法：

        if (File.Exists(Path))
        {
            using (XmlTextReader reader = new XmlTextReader(Path))
            {
                // XmlSerializer x  = new XmlSerializer(typeof(T));
                var x = XmlSerializerHelper.GetSerializer(typeof(T));

                try
                {
                    options = (OptionsBase<T>)x.Deserialize(reader);
                }
                catch (Exception ex)
                {
                    Log.Instance.AddEntry(LogType.LogException, "Unable to open Options file: " + Path, ex);
                }
            }
        }

您的类型可能引用了在GAC或本地bin文件夹中都找不到的其他程序集==> ...

“或其依赖项之一。系统找不到指定的文件”

您能否举一个要序列化类型的例子？

注意：确保您的类型实现了Serializable。

我遇到了同样的错误，这是由于我尝试反序列化的类型没有默认的无参数构造函数。我添加了一个构造函数，它开始起作用。

在使用第3方工具从XSD生成类并起作用之前，我一直遇到相同的问题！我发现该工具在班级顶部添加了一些额外的代码。当我将相同的代码添加到原始类的顶部时，它就起作用了。这是我添加的...

#pragma warning disable
namespace MyNamespace
{
  using System;
  using System.Diagnostics;
  using System.Xml.Serialization;
  using System.Collections;
  using System.Xml.Schema;
  using System.ComponentModel;
  using System.Xml;
  using System.Collections.Generic;

  [System.CodeDom.Compiler.GeneratedCodeAttribute("System.Xml", "4.6.1064.2")]
  [System.SerializableAttribute()]
  [System.Diagnostics.DebuggerStepThroughAttribute()]
  [System.ComponentModel.DesignerCategoryAttribute("code")]
  [System.Xml.Serialization.XmlTypeAttribute(AnonymousType = true)]
  [System.Xml.Serialization.XmlRootAttribute(Namespace = "", IsNullable = false)]
  public partial class MyClassName
  {
  ...

看到了很多建议使用ConcurrentDictionary，但没有可靠的示例，因此我将全力以赴参加解决方案竞赛。我不是线程安全的开发人员，因此，如果此代码不够可靠，请为以后的读者大声疾呼。

public static class XmlSerializerHelper
{
    private static readonly ConcurrentDictionary<Type, XmlSerializer> TypeSerializers = new ConcurrentDictionary<Type, XmlSerializer>();

    public static XmlSerializer GetSerializer(Type type)
    {
        return TypeSerializers.GetOrAdd(type,
        t =>
        {
            var importer = new XmlReflectionImporter();
            var mapping = importer.ImportTypeMapping(t, null, null);
            return new XmlSerializer(mapping);
        });
    }
}

我看过其他帖子，涉及ConcurrentDictionary和Lazy加载该值。我不确定这是否有意义，但是这是该代码：

private static readonly ConcurrentDictionary<Type, Lazy<XmlSerializer>> TypeSerializers = new ConcurrentDictionary<Type, Lazy<XmlSerializer>>();

public static XmlSerializer GetSerializer(Type type)
{
    return TypeSerializers.GetOrAdd(type,
    t =>
    {
        var importer = new XmlReflectionImporter();
        var mapping = importer.ImportTypeMapping(t, null, null);
        var lazyResult = new Lazy<XmlSerializer>(() => new XmlSerializer(mapping), LazyThreadSafetyMode.ExecutionAndPublication);
        return lazyResult;
    }).Value;
}