XmlSerializer donnant FileNotFoundException au constructeur

Une application avec laquelle je travaille échoue lorsque j'essaie de sérialiser des types.

Une déclaration comme

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

produit:

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)

Je ne définis aucun sérialiseur spécial pour ma classe.

Comment puis-je résoudre ce problème?

Croyez-le ou non, c'est un comportement normal. Une exception est levée mais gérée par XmlSerializer, donc si vous l'ignorez, tout devrait bien continuer.

J'ai trouvé cela très ennuyeux, et il y a eu de nombreuses plaintes à ce sujet si vous recherchez un peu, mais d'après ce que j'ai lu, Microsoft n'a pas l'intention de faire quoi que ce soit à ce sujet.

Vous pouvez éviter d'obtenir des fenêtres contextuelles d'exception tout le temps lors du débogage si vous désactivez les exceptions de première chance pour cette exception spécifique. Dans Visual Studio, accédez à Debug -> Exceptions (ou appuyez sur Ctrl+ Alt+ E), Common Language Runtime Exceptions -> System.IO -> System.IO.FileNotFoundException .

Vous pouvez trouver des informations sur un autre moyen de le contourner dans l' exception de blog C # XmlSerializer FileNotFound (qui traite de l'outil XmlSerializerPreCompiler de Chris Sells ).

Comme Martin Sherburn l'a dit, c'est un comportement normal. Le constructeur de XmlSerializer essaie d'abord de trouver un assembly nommé [YourAssembly] .XmlSerializers.dll qui doit contenir la classe générée pour la sérialisation de votre type. Puisqu'une telle DLL n'a pas encore été générée (elles ne le sont pas par défaut), une FileNotFoundException est levée. Lorsque cela se produit, le constructeur de XmlSerializer intercepte cette exception et la DLL est générée automatiquement au moment de l'exécution par le constructeur de XmlSerializer (cela se fait en générant des fichiers source C # dans le répertoire% temp% de votre ordinateur, puis en les compilant à l'aide du compilateur C #). Les constructions supplémentaires d'un XmlSerializer pour le même type utiliseront simplement la DLL déjà générée.

MISE À JOUR: À partir de .NET 4.5, XmlSerializern'effectue plus la génération de code ni la compilation avec le compilateur C # afin de créer un assembly sérialiseur au moment de l'exécution, sauf si explicitement contraint à définir un paramètre de fichier de configuration ( useLegacySerializerGeneration ). Cette modification supprime la dépendance csc.exeet améliore les performances de démarrage. ^{Source: Lisezmoi .NET Framework 4.5 , section 1.3.8.1.}

L'exception est gérée par le constructeur de XmlSerializer. Il n'est pas nécessaire de faire quoi que ce soit vous-même, vous pouvez simplement cliquer sur «Continuer» (F5) pour continuer à exécuter votre programme et tout ira bien. Si vous êtes gêné par les exceptions arrêtant l'exécution de votre programme et faisant apparaître un assistant d'exception, vous avez soit 'Just My Code' désactivé, soit vous avez défini FileNotFoundException pour interrompre l'exécution lorsqu'il est lancé, au lieu de quand 'User- non géré ».

Pour activer «Just My Code», accédez à Outils >> Options >> Débogage >> Général >> Activer Just My Code. Pour désactiver la rupture d'exécution lorsque FileNotFound est levé, accédez à Debug >> Exceptions >> Find >> entrez 'FileNotFoundException' >> décochez la case 'Thrown' de System.IO.FileNotFoundException.

Dans les propriétés du projet Visual Studio (page "Build", si je me souviens bien), il y a une option disant "générer un assemblage de sérialisation". Essayez de l'activer pour un projet qui génère [Assemblage contenant de MyType] .

Il existe une solution pour cela. Si tu utilises

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

il devrait éviter cette exception. Cela a fonctionné pour moi.

AVERTISSEMENT: ne pas utiliser plusieurs fois, ou vous aurez une fuite de mémoire

Vous perdrez de la mémoire comme un fou si vous utilisez cette méthode pour créer des instances de XmlSerializer même type!

En effet, cette méthode contourne la mise en cache intégrée à condition que le XmlSerializer(type)etXmlSerializer(type, defaultNameSpace) constructeurs (tous les autres constructeurs contournent également le cache).

Si vous utilisez une méthode pour créer un XmlSerializer qui n'est pas via ces deux constructeurs, vous devez implémenter votre propre mise en cache ou vous aurez une mémoire d'hémorragie.

J'ai rencontré ce problème exact et je n'ai pu le contourner par aucune des solutions mentionnées.

Puis j'ai finalement trouvé une solution. Il semble que le sérialiseur ait besoin non seulement du type, mais également des types imbriqués. Changer ceci:

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

Pour ça:

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

Correction du problème pour moi. Plus d'exceptions ou quoi que ce soit.

Ma solution est d'aller directement à la réflexion pour créer le sérialiseur. Cela contourne l'étrange chargement de fichier qui provoque l'exception. J'ai empaqueté ceci dans une fonction d'aide qui s'occupe également de la mise en cache du sérialiseur.

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

Pour éviter l'exception, vous devez faire deux choses:

1. Ajoutez un attribut à la classe sérialisée (j'espère que vous y avez accès)
2. Générez le fichier de sérialisation avec sgen.exe

Ajoutez l'attribut System.Xml.Serialization.XmlSerializerAssembly à votre classe. Remplacez «MyAssembly» par le nom de l'assembly dans lequel se trouve MyClass.

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

Générez le fichier de sérialisation à l'aide de l'utilitaire sgen.exe et déployez-le avec l'assembly de la classe.

'sgen.exe MyAssembly.dll' générera le fichier MyAssembly.XmlSerializers.dll

Ces deux modifications feront que le .net trouvera directement l'assembly. Je l'ai vérifié et cela fonctionne sur .NET Framework 3.5 avec Visual Studio 2008

Cette exception peut également être interceptée par un assistant de débogage géré (MDA) appelé BindingFailure.

Ce MDA est utile si votre application est conçue pour être livrée avec des assemblys de sérialisation pré-génération. Nous faisons cela pour augmenter les performances de notre application. Cela nous permet de nous assurer que les assemblys de sérialisation pré-construits sont correctement construits par notre processus de construction et chargés par l'application sans être reconstruits à la volée.

Ce n'est vraiment pas utile sauf dans ce scénario, car comme d'autres affiches l'ont dit, lorsqu'une erreur de liaison est interceptée par le constructeur Serializer, l'assembly de sérialisation est reconstruit au moment de l'exécution. Vous pouvez donc généralement le désactiver.

La fonction XmlSerializer.FromTypes ne lève pas l'exception, mais elle fuit la mémoire. C'est pourquoi vous devez mettre en cache un tel sérialiseur pour chaque type afin d'éviter une fuite de mémoire pour chaque instance créée.

Créez votre propre fabrique XmlSerializer et utilisez-la simplement:

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

L'usine ressemble à:

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

Version plus compliquée sans possibilité de fuite de mémoire (veuillez consulter le code):

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

Le dépannage des erreurs de compilation est en revanche très compliqué. Ces problèmes se manifestent dans une FileNotFoundException avec le message:

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

Vous vous demandez peut-être ce qu'une exception de fichier introuvable a à voir avec l'instanciation d'un objet sérialiseur, mais n'oubliez pas: le constructeur écrit des fichiers C # et essaie de les compiler. La pile d'appels de cette exception fournit de bonnes informations pour étayer cette suspicion. L'exception s'est produite alors que XmlSerializer a tenté de charger un assembly généré par CodeDOM appelant la méthode System.Reflection.Assembly.Load. L'exception ne fournit pas d'explication sur la raison pour laquelle l'assembly que le XmlSerializer était censé créer n'était pas présent. En général, l'assembly n'est pas présent car la compilation a échoué, ce qui peut se produire car, dans de rares circonstances, les attributs de sérialisation produisent du code que le compilateur C # ne parvient pas à compiler.

Remarque Cette erreur se produit également lorsque le XmlSerializer s'exécute sous un compte ou un environnement de sécurité qui n'est pas en mesure d'accéder au répertoire temporaire.

Source : http://msdn.microsoft.com/en-us/library/aa302290.aspx

Dans les propriétés du projet Visual Studio, il existe une option indiquant «générer un assembly de sérialisation». Essayez de l'activer pour un projet qui génère [Assemblage contenant de MyType].

Une classe personnalisée à sérialiser:

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

J'ai joint l'extrait de code. Peut-être que cela peut vous aider.

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

J'avais un problème similaire et ignorer l'exception ne fonctionnait pas pour moi. Mon code appelait la configuration de NServiceBusConfigure.With(...).XmlSerializer()...

Ce qui m'a permis de changer la plateforme de mon projet.

1. Allez dans Build \ Configuration Manager ...
2. Trouvez votre projet et changez de plateforme (dans mon cas de x86 à Any CPU)

Juste comme référence. Prenant de la réponse et des commentaires de DB, je suis venu avec cette solution qui est proche de la solution DB. Cela fonctionne bien dans tous mes cas et il est sûr pour les threads. Je ne pense pas que l'utilisation d'un ConcurrentDictionary aurait été acceptable.

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

Usage:

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

Votre type peut référencer d'autres assemblys qui ne peuvent être trouvés ni dans le GAC ni dans votre dossier bin local ==> ...

"ou l'une de ses dépendances. Le système ne trouve pas le fichier spécifié"

Pouvez-vous donner un exemple du type que vous souhaitez sérialiser?

Remarque: assurez-vous que votre type implémente Sérialisable.

J'obtenais la même erreur, et c'était dû au type que j'essayais de désérialiser de ne pas avoir de constructeur sans paramètre par défaut . J'ai ajouté un constructeur et il a commencé à fonctionner.

J'ai eu le même problème jusqu'à ce que j'utilise un outil tiers pour générer la classe à partir du XSD et cela a fonctionné! J'ai découvert que l'outil ajoutait du code supplémentaire en haut de ma classe. Lorsque j'ai ajouté ce même code en haut de ma classe d'origine, cela a fonctionné. Voici ce que j'ai ajouté ...

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

Vu beaucoup de recommandations à utiliser ConcurrentDictionary, mais pas d'exemples solides, donc je vais jeter mon chapeau dans cette course aux solutions. Je ne suis pas un développeur thread-safe, donc si ce code n'est pas solide, veuillez parler pour ceux qui suivront.

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

J'ai vu d'autres articles impliquer ConcurrentDictionaryet Lazycharger la valeur. Je ne sais pas si c'est pertinent ici ou non, mais voici le code pour cela:

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