XmlSerializer dando FileNotFoundException en el constructor

Una aplicación con la que he estado trabajando falla cuando intento serializar tipos.

Una declaración como

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

produce:

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)

No defino ningún serializador especial para mi clase.

¿Como puedo solucionar este problema?

Lo creas o no, este es un comportamiento normal. Se produce una excepción, pero XmlSerializer la maneja, por lo que si la ignora, todo debería continuar bien.

Esto me pareció muy molesto, y ha habido muchas quejas sobre esto si buscas un poco, pero por lo que he leído, Microsoft no planea hacer nada al respecto.

Puede evitar las ventanas emergentes de excepción todo el tiempo mientras se depura si desactiva las excepciones de primera oportunidad para esa excepción específica. En Visual Studio, vaya a Depurar -> Excepciones (o presione Ctrl+ Alt+ E), Excepciones de Common Language Runtime -> System.IO -> System.IO.FileNotFoundException .

Puede encontrar información sobre otra forma de evitarlo en la publicación del blog C # XmlSerializer FileNotFound excepción (que analiza la herramienta XmlSerializerPreCompiler de Chris Sells ).

Como dijo Martin Sherburn, este es un comportamiento normal. El constructor del XmlSerializer primero intenta encontrar un ensamblado llamado [YourAssembly] .XmlSerializers.dll que debe contener la clase generada para la serialización de su tipo. Dado que dicha DLL aún no se ha generado (no lo están de forma predeterminada), se genera una excepción FileNotFoundException. Cuando eso sucede, el constructor de XmlSerializer detecta esa excepción, y el constructor de XmlSerializer genera la DLL automáticamente en tiempo de ejecución (esto se hace generando archivos fuente C # en el directorio% temp% de su computadora, luego compilándolos usando el compilador C #). Las construcciones adicionales de un XmlSerializer para el mismo tipo solo usarán el DLL ya generado.

ACTUALIZACIÓN: a partir de .NET 4.5, XmlSerializerya no realiza la generación de código ni realiza la compilación con el compilador de C # para crear un ensamblado de serializador en tiempo de ejecución, a menos que se lo obligue explícitamente estableciendo una configuración de archivo de configuración ( useLegacySerializerGeneration ). Este cambio elimina la dependencia csc.exey mejora el rendimiento de inicio. ^{Fuente: Léame de .NET Framework 4.5 , sección 1.3.8.1.}

La excepción es manejada por el constructor de XmlSerializer. No hay necesidad de hacer nada usted mismo, simplemente haga clic en 'Continuar' (F5) para continuar ejecutando su programa y todo estará bien. Si le molestan las excepciones que detienen la ejecución de su programa y aparecen un asistente de excepción, tiene 'Just My Code' desactivado o tiene la FileNotFoundException configurada para interrumpir la ejecución cuando se lanza, en lugar de cuando 'User- no manejado ".

Para habilitar 'Solo mi código', vaya a Herramientas >> Opciones >> Depuración >> General >> Habilitar solo mi código. Para desactivar la interrupción de la ejecución cuando se lanza FileNotFound, vaya a Depurar >> Excepciones >> Buscar >> ingrese 'FileNotFoundException' >> desactive la casilla de verificación 'Lanzar' de System.IO.FileNotFoundException.

En las propiedades del proyecto de Visual Studio (página "Build", si no recuerdo mal) hay una opción que dice "generar ensamblado de serialización". Intente encenderlo para un proyecto que genere [Contiene ensamblaje de MyType] .

Hay una solución para eso. Si utiliza

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

Debería evitar esa excepción. Esto funcionó para mí.

ADVERTENCIA: no lo use varias veces, o tendrá una pérdida de memoria

¡Perderá la memoria como loco si usa este método para crear instancias del XmlSerializermismo tipo más de una vez!

Esto se debe a que este método omite el almacenamiento en caché incorporado siempre que los constructores XmlSerializer(type)y XmlSerializer(type, defaultNameSpace)(todos los demás constructores también omitan el almacenamiento en caché).

Si utiliza algún método para crear un XmlSerializer que no sea a través de estos dos constructores, debe implementar su propio almacenamiento en caché o tendrá memoria de hemorragia.

Me encontré con este problema exacto y no pude evitarlo con ninguna de las soluciones mencionadas.

Entonces finalmente encontré una solución. Parece que el serializador necesita no solo el tipo, sino también los tipos anidados. Cambiando esto:

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

A esto:

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

Solucionó el problema para mí. No más excepciones ni nada.

Mi solución es ir directamente a la reflexión para crear el serializador. Esto evita la carga extraña de archivos que causa la excepción. Empaqué esto en una función auxiliar que también se encarga de almacenar en caché el serializador.

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

Para evitar la excepción, debe hacer dos cosas:

1. Agregue un atributo a la clase serializada (espero que tenga acceso)
2. Genere el archivo de serialización con sgen.exe

Agregue el atributo System.Xml.Serialization.XmlSerializerAssembly a su clase. Reemplace 'MyAssembly' con el nombre del ensamblaje donde está MyClass.

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

Genere el archivo de serialización utilizando la utilidad sgen.exe e impleméntelo con el ensamblado de la clase.

'sgen.exe MyAssembly.dll' generará el archivo MyAssembly.XmlSerializers.dll

Estos dos cambios harán que .net encuentre directamente el ensamblado. Lo revisé y funciona en .NET Framework 3.5 con Visual Studio 2008

Esta excepción también puede ser atrapada por un asistente de depuración administrado (MDA) llamado BindingFailure.

Este MDA es útil si su aplicación está diseñada para enviarse con ensambles de serialización precompilados. Hacemos esto para aumentar el rendimiento de nuestra aplicación. Nos permite asegurarnos de que los ensambles de serialización preconstruidos estén siendo construidos adecuadamente por nuestro proceso de construcción y cargados por la aplicación sin ser reconstruidos sobre la marcha.

Realmente no es útil, excepto en este escenario, porque como han dicho otros carteles, cuando el constructor del serializador atrapa un error vinculante, el ensamblado de serialización se reconstruye en tiempo de ejecución. Por lo tanto, generalmente puede apagarlo.

La función XmlSerializer.FromTypes no produce la excepción, pero pierde la memoria. Es por eso que necesita almacenar en caché dicho serializador para cada tipo para evitar pérdidas de memoria para cada instancia creada.

Cree su propia fábrica de XmlSerializer y úsela simplemente:

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

La fábrica parece gustos:

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

Versión más complicada sin posibilidad de pérdida de memoria (alguien revise el código):

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

La resolución de errores de compilación, por otro lado, es muy complicada. Estos problemas se manifiestan en una FileNotFoundException con el mensaje:

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

Quizás se pregunte qué tiene que ver una excepción de archivo no encontrado con la creación de instancias de un objeto serializador, pero recuerde: el constructor escribe archivos C # e intenta compilarlos. La pila de llamadas de esta excepción proporciona buena información para respaldar esa sospecha. La excepción ocurrió mientras XmlSerializer intentaba cargar un ensamblado generado por CodeDOM llamando al método System.Reflection.Assembly.Load. La excepción no proporciona una explicación de por qué el ensamblado que se suponía que XmlSerializer debía crear no estaba presente. En general, el ensamblado no está presente porque la compilación falló, lo que puede suceder porque, en circunstancias excepcionales, los atributos de serialización producen código que el compilador de C # no puede compilar.

Nota: Este error también se produce cuando XmlSerializer se ejecuta en una cuenta o en un entorno de seguridad que no puede acceder al directorio temporal.

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

En las propiedades del proyecto de Visual Studio hay una opción que dice "generar ensamblaje de serialización". Intente encenderlo para un proyecto que genere [Contiene ensamblaje de MyType].

Una clase personalizada para serializar:

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

He adjuntado el fragmento de código. Tal vez esto pueda ayudarte.

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

Estaba teniendo un problema similar e ignorar la excepción no funcionó para mí. Mi código estaba llamando a la configuración de NServiceBusConfigure.With(...).XmlSerializer()...

Lo que me solucionó fue cambiar la plataforma de mi proyecto.

1. Vaya a Build \ Configuration Manager ...
2. Encuentre su proyecto y cambie la plataforma (en mi caso de x86 a cualquier CPU)

Solo como referencia. Tomando de la respuesta y los comentarios de DB, vine con esta solución que está cerca de la solución de DB. Funciona bien en todos mis casos y es seguro para subprocesos. No creo que usar un ConcurrentDictionary hubiera estado bien.

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

Uso:

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

Su tipo puede hacer referencia a otros ensamblados que no se pueden encontrar ni en el GAC ni en su carpeta bin local ==> ...

"o una de sus dependencias. El sistema no puede encontrar el archivo especificado"

¿Puede dar un ejemplo del tipo que desea serializar?

Nota: Asegúrese de que su tipo implemente Serializable.

Estaba recibiendo el mismo error, y fue debido al tipo que estaba tratando de deserializar al no tener un constructor sin parámetros predeterminado . Agregué un constructor y comenzó a funcionar.

¡Tuve el mismo problema hasta que utilicé una herramienta de terceros para generar la Clase desde el XSD y funcionó! Descubrí que la herramienta estaba agregando un código extra en la parte superior de mi clase. Cuando agregué este mismo código a la parte superior de mi clase original, funcionó. Esto es lo que agregué ...

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

ConcurrentDictionaryHe visto muchas recomendaciones para usar un , pero no hay ejemplos sólidos de él, así que voy a lanzar mi sombrero en esta carrera de solución. No soy un desarrollador seguro para subprocesos, así que si este código no es sólido, hable por el bien de los que siguen.

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

He visto otras publicaciones que involucran ConcurrentDictionaryy Lazycargan el valor. No estoy seguro de si eso es relevante aquí o no, pero aquí está el código para eso:

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