XmlSerializer在构造函数中给出FileNotFoundException

我也有同样的问题，直到我使用第三方工具从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
{
...

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

对我来说，解决这个问题的方法是改变我项目的平台。

1. 去构建\配置管理器…
2. 找到你的项目并更改平台(在我的情况下，从x86到任何CPU)

我遇到了这个问题，上面提到的任何解决方案都无法解决它。

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

:

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

为我修复了这个问题。

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

只是作为参考。从D-B的回答和评论中，我得出了这个接近D-B的解决方案。它在我的所有情况下都工作得很好，并且是线程安全的。我不认为使用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);
}
}
}

见过很多使用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;
}

在我的一个。net标准dll中也有类似的问题。

我使用了Microsoft.XmlSerializer.Generator nuget，它在. net Core和. net Standard上预生成XmlSerializer。