XmlSerializer podający FileNotFoundException w konstruktorze

Aplikacja, z którą pracuję, zawiesza się, gdy próbuję serializować typy.

Oświadczenie jak

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

produkuje:

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)

Nie definiuję żadnych specjalnych serializatorów dla mojej klasy.

Jak mogę rozwiązać ten problem?

Wierzcie lub nie, to jest normalne zachowanie. Wyjątek jest zgłaszany, ale obsługiwany przez XmlSerializer, więc jeśli go zignorujesz, wszystko powinno być w porządku.

Uważam to za bardzo irytujące i było wiele skarg na to, jeśli trochę się rozglądasz, ale z tego, co przeczytałem, Microsoft nie planuje nic z tym zrobić.

Możesz uniknąć wyświetlania wyskakujących okien wyjątków przez cały czas podczas debugowania, jeśli wyłączysz wyjątki pierwszej szansy dla tego konkretnego wyjątku. W programie Visual Studio przejdź do opcji Debugowanie -> Wyjątki (lub naciśnij Ctrl+ Alt+ E), Wyjątki czasu wykonywania wspólnego języka -> System.IO -> System.IO.FileNotFoundException .

Informacje o innym rozwiązaniu można znaleźć w blogu C # XmlSerializer FileNotFound wyjątek (który omawia narzędzie Chrisa Sellsa XmlSerializerPreCompiler ).

Jak powiedział Martin Sherburn, jest to normalne zachowanie. Konstruktor XmlSerializer najpierw próbuje znaleźć zestaw o nazwie [YourAssembly] .XmlSerializers.dll, który powinien zawierać wygenerowaną klasę do serializacji danego typu. Ponieważ taka biblioteka DLL nie została jeszcze wygenerowana (nie są domyślnie), zgłaszany jest wyjątek FileNotFoundException. Kiedy tak się dzieje, konstruktor XmlSerializer przechwytuje ten wyjątek, a biblioteka DLL jest generowana automatycznie w czasie wykonywania przez konstruktor XmlSerializer (odbywa się to poprzez wygenerowanie plików źródłowych C # w katalogu% temp% na komputerze, a następnie kompilację przy użyciu kompilatora C #). Dodatkowe konstrukcje XmlSerializer dla tego samego typu będą po prostu korzystać z już wygenerowanej biblioteki DLL.

AKTUALIZACJA: Począwszy od .NET 4.5, XmlSerializernie wykonuje już generowania kodu ani nie wykonuje kompilacji z kompilatorem C # w celu utworzenia zestawu serializatora w czasie wykonywania, chyba że jest to wyraźnie wymagane przez ustawienie pliku konfiguracyjnego ( useLegacySerializerGeneration ). Ta zmiana usuwa zależność csc.exei poprawia wydajność uruchamiania. ^{Źródło: Readme .NET Framework 4.5 , sekcja 1.3.8.1.}

Wyjątek jest obsługiwany przez konstruktor XmlSerializer. Nie musisz nic robić sam, wystarczy kliknąć „Kontynuuj” (F5), aby kontynuować wykonywanie programu i wszystko będzie dobrze. Jeśli przeszkadzają Ci wyjątki, które zatrzymują wykonywanie programu i wyświetlają pomocnika wyjątków, albo masz „Just My Code” wyłączony, albo masz wyjątek FileNotFoundException, który przerywa wykonywanie po rzuceniu, zamiast gdy „User- nieobsługiwany ”.

Aby włączyć „Just My Code”, przejdź do Narzędzia >> Opcje >> Debugowanie >> Ogólne >> Włącz Just My Code. Aby wyłączyć przerwanie wykonywania po wyrzuceniu FileNotFound, przejdź do Debugowanie >> Wyjątki >> Znajdź >> wpisz „FileNotFoundException” >> odznacz pole wyboru „Zgłoszony” w System.IO.FileNotFoundException.

We właściwościach projektu Visual Studio (strona „Kompiluj”, jeśli dobrze to pamiętam) istnieje opcja „generuj zespół serializacji”. Spróbuj włączyć go dla projektu, który generuje [Zawiera zestaw MyType] .

Istnieje obejście tego problemu. Jeśli użyjesz

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

powinien unikać tego wyjątku. To zadziałało dla mnie.

OSTRZEŻENIE: Nie należy używać wielokrotnie, w przeciwnym razie nastąpi wyciek pamięci

Wyciekasz pamięć jak szaloną, jeśli użyjesz tej metody do tworzenia instancji XmlSerializer dla tego samego typu więcej niż jeden raz!

Wynika to z tego, że ta metoda omija wbudowane buforowanie pod warunkiem, że XmlSerializer(type)iXmlSerializer(type, defaultNameSpace) konstruktorów (wszystkie inne konstruktory również omijają pamięć podręczną).

Jeśli użyjesz dowolnej metody, aby utworzyć XmlSerializer, który nie odbywa się za pośrednictwem tych dwóch konstruktorów, musisz zaimplementować własne buforowanie lub pamięć krwotoku.

Natrafiłem na ten konkretny problem i nie mogłem go obejść za pomocą żadnego z wymienionych rozwiązań.

W końcu znalazłem rozwiązanie. Wygląda na to, że serializator potrzebuje nie tylko typu, ale także typów zagnieżdżonych. Zmieniając to:

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

Do tego:

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

Naprawiono problem dla mnie. Nigdy więcej wyjątków lub czegokolwiek.

Moim rozwiązaniem jest przejście bezpośrednio do refleksji, aby utworzyć serializator. Pomija to dziwne ładowanie plików, które powoduje wyjątek. Spakowałem to w funkcji pomocniczej, która również zajmuje się buforowaniem serializatora.

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

Aby uniknąć wyjątku, musisz zrobić dwie rzeczy:

1. Dodaj atrybut do serializowanej klasy (mam nadzieję, że masz dostęp)
2. Wygeneruj plik serializacji za pomocą sgen.exe

Dodaj atrybut System.Xml.Serialization.XmlSerializerAssembly do swojej klasy. Zamień „MyAssembly” na nazwę zestawu, w którym znajduje się MyClass.

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

Wygeneruj plik serializacji za pomocą narzędzia sgen.exe i wdróż go przy użyciu zestawu klasy.

„sgen.exe MyAssembly.dll” wygeneruje plik MyAssembly.XmlSerializers.dll

Te dwie zmiany spowodują, że .net bezpośrednio znajdzie zestaw. Sprawdziłem to i działa na .NET Framework 3.5 z Visual Studio 2008

Ten wyjątek może również zostać uwięziony przez zarządzanego asystenta debugowania (MDA) o nazwie BindingFailure.

Ta MDA jest przydatna, jeśli aplikacja jest zaprojektowana do dostarczania z kompilacjami serializacji przed kompilacją. Robimy to, aby zwiększyć wydajność naszej aplikacji. Pozwala nam to upewnić się, że wstępnie skompilowane zestawy serializacji są poprawnie budowane przez nasz proces kompilacji i ładowane przez aplikację bez konieczności ponownej kompilacji w locie.

Jest to naprawdę nieprzydatne, z wyjątkiem tego scenariusza, ponieważ jak powiedzieli inni plakaty, gdy konstruktor Serializer uwięził błąd wiązania, zespół serializacji jest ponownie budowany w czasie wykonywania. Więc zazwyczaj możesz to wyłączyć.

Funkcja XmlSerializer.FromTypes nie zgłasza wyjątku, ale przecieka pamięć. Dlatego musisz buforować taki serializator dla każdego typu, aby uniknąć wycieku pamięci dla każdej utworzonej instancji.

Utwórz własną fabrykę XmlSerializer i użyj jej po prostu:

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

Fabryka wygląda jak:

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

Bardziej skomplikowana wersja bez możliwości wycieku pamięci (proszę przejrzeć kod):

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

Z drugiej strony rozwiązywanie problemów z kompilacją jest bardzo skomplikowane. Te problemy przejawiają się w wyjątku FileNotFoundException z komunikatem:

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() 

Możesz się zastanawiać, co wyjątek związany z nie znalezieniem pliku ma związek z tworzeniem wystąpienia obiektu serializującego, ale pamiętaj: konstruktor zapisuje pliki C # i próbuje je skompilować. Stos wywołań tego wyjątku dostarcza pewnych dobrych informacji na poparcie tego podejrzenia. Wystąpił wyjątek, gdy XmlSerializer próbował załadować zestaw wygenerowany przez CodeDOM wywołujący metodę System.Reflection.Assembly.Load. Wyjątek nie wyjaśnia, dlaczego zestaw, który miał utworzyć XmlSerializer, nie był obecny. Ogólnie rzecz biorąc, zestaw nie jest obecny, ponieważ kompilacja nie powiodła się, co może się zdarzyć, ponieważ w rzadkich okolicznościach atrybuty serializacji generują kod, którego kompilator C # nie kompiluje.

Uwaga Ten błąd występuje również, gdy XmlSerializer działa na koncie lub w środowisku bezpieczeństwa, które nie ma dostępu do katalogu tymczasowego.

Źródło : http://msdn.microsoft.com/en-us/library/aa302290.aspx

We właściwościach projektu Visual Studio istnieje opcja „generuj zespół serializacji”. Spróbuj włączyć go dla projektu, który generuje [Zawiera zestaw MyType].

Klasa niestandardowa do serializacji:

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

Załączam fragment kodu. Może to może ci pomóc.

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

Miałem podobny problem i zignorowanie wyjątku nie zadziałało. Mój kod wywoływał konfigurację NServiceBusConfigure.With(...).XmlSerializer()...

Naprawdę zmieniłem platformę mojego projektu.

1. Przejdź do Build \ Configuration Manager ...
2. Znajdź swój projekt i zmień platformę (w moim przypadku z x86 na dowolny procesor)

Tylko jako odniesienie. Biorąc od DB odpowiedzi i komentarze, przyszedłem z tym rozwiązaniem, które jest zbliżone do rozwiązania DB. Działa dobrze we wszystkich moich przypadkach i jest bezpieczny dla wątków. Nie sądzę, że użycie ConcurrentDictionary byłoby w porządku.

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

Stosowanie:

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

Twój typ może odwoływać się do innych zespołów, których nie można znaleźć ani w GAC, ani w lokalnym folderze bin ==> ...

„lub jedną z jego zależności. System nie może znaleźć określonego pliku”

Czy możesz podać przykład typu, który chcesz serializować?

Uwaga: Upewnij się, że Twój typ implementuje Serializable.

Otrzymywałem ten sam błąd i wynikało to z typu, którego próbowałem deserializować, nie mając domyślnego konstruktora bez parametrów . Dodałem konstruktor i zaczął działać.

Miałem ten sam problem, dopóki nie użyłem narzędzia innej firmy do wygenerowania klasy z XSD i zadziałało! Odkryłem, że narzędzie dodawało dodatkowy kod na początku mojej klasy. Kiedy dodałem ten sam kod na początku mojej oryginalnej klasy, zadziałało. Oto co dodałem ...

#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
  {
  ...

Widziałem wiele rekomendacji do użycia ConcurrentDictionary, ale nie ma solidnych przykładów, więc wrzucę swój kapelusz w ten wyścig rozwiązań. Nie jestem programistą bezpiecznym dla wątków, więc jeśli ten kod nie jest solidny, proszę zabrać głos ze względu na tych, którzy go śledzą.

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

Widziałem inne posty obejmujące ConcurrentDictionaryi Lazyładujące wartość. Nie jestem pewien, czy jest to istotne tutaj, czy nie, ale oto kod do tego:

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