생성자에서 FileNotFoundException을 제공하는 XmlSerializer

유형을 직렬화하려고 할 때 작업했던 응용 프로그램이 실패합니다.

다음과 같은 진술

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에서 처리되므로 예외를 무시하면 모든 것이 잘 진행됩니다.

나는 이것이 매우 성가신 것을 발견했으며 조금 둘러 보면 이것에 대해 많은 불만이 있었지만, 내가 읽은 것에서 그것에 대해 아무것도 할 계획이 없습니다.

특정 예외에 대한 첫 번째 예외를 해제하면 디버깅하는 동안 항상 예외 팝업이 표시되는 것을 피할 수 있습니다. 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의 생성자는 해당 예외를 포착하고 DLL은 XmlSerializer의 생성자에 의해 런타임에 자동으로 생성됩니다 (이는 컴퓨터의 % temp % 디렉토리에 C # 소스 파일을 생성 한 다음 C # 컴파일러를 사용하여 컴파일하여 수행됨). 동일한 유형의 XmlSerializer를 추가로 구성하면 이미 생성 된 DLL 만 사용됩니다.

업데이트 : .NET 4.5부터는 XmlSerializer구성 파일 설정 ( useLegacySerializerGeneration ) 을 설정하여 명시 적으로 강제하지 않는 한 런타임에 직렬 변환기 어셈블리를 만들기 위해 더 이상 코드 생성을 수행하거나 C # 컴파일러로 컴파일을 수행하지 않습니다 . 이 변경으로 인해 종속성이 제거되고 csc.exe시작 성능이 향상됩니다. ^{출처 : .NET Framework 4.5 추가 정보 , 섹션 1.3.8.1.}

XmlSerializer의 생성자가 예외를 처리합니다. 아무것도 할 필요가 없습니다. '계속'(F5)을 클릭하여 프로그램을 계속 실행하면 모든 것이 정상입니다. 프로그램 실행을 중지하고 예외 도우미를 팝업으로 표시하는 예외로 인해 방해를 받으면 '사용자 정의'가 해제되었거나 '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는 예외를 throw하지 않지만 메모리가 누출됩니다. 따라서 생성 된 모든 인스턴스에서 메모리 누수가 발생하지 않도록 모든 유형에 대해 이러한 직렬 변환기를 캐시해야합니다.

자신의 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() 

예외를 찾을 수없는 파일이 serializer 객체를 인스턴스화하는 것과 어떤 관련이 있는지 궁금 할 수 있지만 생성자는 C # 파일을 작성하고 컴파일하려고합니다. 이 예외의 호출 스택은 그러한 의심을 뒷받침 할 수있는 좋은 정보를 제공합니다. XmlSerializer가 System.Reflection.Assembly.Load 메서드를 호출하는 CodeDOM에 의해 생성 된 어셈블리를로드하려고 시도하는 동안 예외가 발생했습니다. 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. 빌드 \ 구성 관리자로 이동하십시오 ...
2. 프로젝트를 찾고 플랫폼을 변경하십시오 (필자의 경우 x86에서 모든 CPU로)

참조로. DB 답변과 의견에서 DB 솔루션에 가까운이 솔루션을 제공했습니다. 그것은 모든 경우에 잘 작동하며 스레드 안전합니다. 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을 구현하는지 확인하십시오.

동일한 오류가 발생했으며 기본 매개 변수가없는 생성자가 없는 직렬화를 해제하려고 시도한 유형 때문이었습니다 . 생성자를 추가하고 작동하기 시작했습니다.

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