XmlSerializer dando FileNotFoundException no construtor

Um aplicativo com o qual estou trabalhando está falhando quando tento serializar tipos.

Uma declaração como

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

produz:

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)

Não defino nenhum serializador especial para minha classe.

Como posso resolver este problema?

Acredite ou não, este é um comportamento normal. Uma exceção é lançada, mas tratada pelo XmlSerializer, portanto, se você a ignorar, tudo deve continuar bem.

Achei isso muito irritante e houve muitas queixas sobre isso, se você pesquisar um pouco, mas pelo que li, a Microsoft não planeja fazer nada a respeito.

Você pode evitar a obtenção de pop-ups de exceção o tempo todo durante a depuração se desativar as exceções de primeira chance para essa exceção específica. No Visual Studio, vá para Debug -> Exceptions (ou pressione Ctrl+ Alt+ E), Common Language Runtime Exceptions -> System.IO -> System.IO.FileNotFoundException .

Você pode encontrar informações sobre outra maneira de contornar isso na postagem do blog C # XmlSerializer FileNotFound (que discute a ferramenta XmlSerializerPreCompiler da ferramenta de Chris Sells ).

Como Martin Sherburn disse, esse é um comportamento normal. O construtor do XmlSerializer primeiro tenta localizar um assembly chamado [YourAssembly] .XmlSerializers.dll que deve conter a classe gerada para serialização do seu tipo. Como essa DLL ainda não foi gerada (não é por padrão), é lançada uma FileNotFoundException. Quando isso acontece, o construtor do XmlSerializer captura essa exceção e a DLL é gerada automaticamente em tempo de execução pelo construtor do XmlSerializer (isso é feito gerando arquivos de origem C # no diretório% temp% do seu computador e compilando-os usando o compilador C #). Construções adicionais de um XmlSerializer para o mesmo tipo usarão apenas a DLL já gerada.

ATUALIZAÇÃO: A partir do .NET 4.5, XmlSerializernão realiza mais a geração de código nem a compilação com o compilador C # para criar um assembly de serializador em tempo de execução, a menos que seja explicitamente forçado a definir uma configuração de arquivo de configuração ( useLegacySerializerGeneration ). Essa alteração remove a dependência csc.exee melhora o desempenho da inicialização. ^{Fonte: Leiame do .NET Framework 4.5 , seção 1.3.8.1.}

A exceção é tratada pelo construtor do XmlSerializer. Não é necessário fazer nada, basta clicar em 'Continuar' (F5) para continuar executando o programa e tudo ficará bem. Se você está incomodado com as exceções que interrompem a execução do programa e exibem um auxiliar de exceção, você tem o 'Just My Code' desativado ou o FileNotFoundException definido para interromper a execução quando lançada, em vez de quando 'User- sem tratamento ".

Para ativar 'Just My Code', vá para Ferramentas >> Opções >> Depuração >> Geral >> Ativar Just My Code. Para desativar a interrupção da execução quando o FileNotFound for acionado, vá para Debug >> Exceptions >> Find >>, digite 'FileNotFoundException' >> desmarque a caixa de seleção 'Thrown' em System.IO.FileNotFoundException.

Nas propriedades do projeto do Visual Studio (página "Build", se bem me lembro), existe uma opção dizendo "gerar assembly de serialização". Tente ativá-lo para um projeto que gera [Contendo Assembly do MyType] .

Existe uma solução alternativa para isso. Se você usar

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

deve evitar essa exceção. Isso funcionou para mim.

AVISO: Não use várias vezes, ou você terá um vazamento de memória

Você perderá memória como um louco se usar esse método para criar instâncias do XmlSerializermesmo tipo mais de uma vez!

Isso ocorre porque esse método ignora o cache interno fornecido aos construtores XmlSerializer(type)e XmlSerializer(type, defaultNameSpace)(todos os outros construtores também ignoram o cache).

Se você usar qualquer método para criar um XmlSerializer que não seja desses dois construtores, implemente seu próprio cache ou sofrerá hemorragia na memória.

Corri para esse problema exato e não consegui contornar isso com nenhuma das soluções mencionadas.

Então eu finalmente encontrei uma solução. Parece que o serializador precisa não apenas do tipo, mas também dos tipos aninhados. Alterando isso:

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

Para isso:

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

Corrigido o problema para mim. Sem mais exceções ou qualquer coisa.

Minha solução é ir direto à reflexão para criar o serializador. Isso ignora o carregamento estranho de arquivo que causa a exceção. Empacotei isso em uma função auxiliar que também cuida do armazenamento em cache do 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 a exceção, você precisa fazer duas coisas:

1. Adicione um atributo à classe serializada (espero que você tenha acesso)
2. Gere o arquivo de serialização com sgen.exe

Adicione o atributo System.Xml.Serialization.XmlSerializerAssembly à sua classe. Substitua 'MyAssembly' pelo nome do assembly em que MyClass está.

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

Gere o arquivo de serialização usando o utilitário sgen.exe e implante-o com o assembly da classe.

'sgen.exe MyAssembly.dll' gerará o arquivo MyAssembly.XmlSerializers.dll

Essas duas alterações farão com que o .net encontre diretamente o assembly. Eu verifiquei e funciona no .NET framework 3.5 com Visual Studio 2008

Essa exceção também pode ser interceptada por um assistente de depuração gerenciada (MDA) chamado BindingFailure.

Esse MDA é útil se seu aplicativo for projetado para ser fornecido com conjuntos de serialização pré-compilados. Fazemos isso para aumentar o desempenho de nosso aplicativo. Isso nos permite garantir que os conjuntos de serialização pré-criados estejam sendo construídos adequadamente pelo nosso processo de criação e carregados pelo aplicativo sem serem recriados em tempo real.

Realmente não é útil, exceto neste cenário, porque, como outros pôsteres disseram, quando um erro de ligação é capturado pelo construtor Serializer, o conjunto de serialização é recriado em tempo de execução. Então você geralmente pode desligá-lo.

A função XmlSerializer.FromTypes não lança a exceção, mas vaza a memória. É por isso que você precisa armazenar em cache esse serializador para todos os tipos, para evitar vazamento de memória em todas as instâncias criadas.

Crie sua própria fábrica XmlSerializer e use-a simplesmente:

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

A fábrica se parece com:

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

Versão mais complicada sem possibilidade de vazamento de memória (por favor, alguém reveja o 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;
    }       
}

A solução de problemas de erros de compilação, por outro lado, é muito complicada. Esses problemas se manifestam em um FileNotFoundException com a mensagem:

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

Você pode se perguntar o que um arquivo não encontrado tem a ver com instanciar um objeto serializador, mas lembre-se: o construtor grava arquivos C # e tenta compilá-los. A pilha de chamadas dessa exceção fornece algumas informações boas para apoiar essa suspeita. A exceção ocorreu enquanto o XmlSerializer tentou carregar um assembly gerado pelo CodeDOM chamando o método System.Reflection.Assembly.Load. A exceção não fornece uma explicação sobre o motivo pelo qual o assembly que o XmlSerializer deveria criar não estava presente. Em geral, o assembly não está presente porque a compilação falhou, o que pode acontecer porque, em raras circunstâncias, os atributos de serialização produzem código que o compilador C # falha ao compilar.

Nota Este erro também ocorre quando o XmlSerializer é executado em uma conta ou em um ambiente de segurança que não pode acessar o diretório temporário.

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

Nas propriedades do projeto do Visual Studio, há uma opção dizendo "gerar assembly de serialização". Tente ativá-lo para um projeto que gera [Contendo Assembly do MyType].

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

Anexei o trecho de código. Talvez isso possa ajudá-lo.

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

Eu estava tendo um problema semelhante e ignorar a exceção não funcionou para mim. Meu código estava chamando a configuração do NServiceBus 'Configure.With(...).XmlSerializer()...

O que o corrigiu para mim foi mudar a plataforma do meu projeto.

1. Vá para Build \ Configuration Manager ...
2. Encontre seu projeto e mude a Plataforma (no meu caso, de x86 para Qualquer CPU)

Apenas como referência. Retirando da resposta e dos comentários do DB, eu vim com esta solução que é próxima da solução do DB. Funciona bem em todos os meus casos e é seguro para threads. Eu não acho que o uso de um ConcurrentDictionary tivesse sido bom.

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

Seu tipo pode fazer referência a outros assemblies que não podem ser encontrados nem no GAC nem na pasta bin local ==> ...

"ou uma de suas dependências. O sistema não pode encontrar o arquivo especificado"

Você pode dar um exemplo do tipo que deseja serializar?

Nota: Verifique se o seu tipo implementa Serializable.

Eu estava recebendo o mesmo erro e era devido ao tipo que estava tentando desserializar por não ter um construtor sem parâmetros padrão . Eu adicionei um construtor e ele começou a funcionar.

Eu tive o mesmo problema até usar uma ferramenta de terceiros para gerar a classe a partir do XSD e funcionou! Eu descobri que a ferramenta estava adicionando algum código extra na parte superior da minha classe. Quando adicionei esse mesmo código ao topo da minha classe original, ele funcionou. Aqui está o que eu adicionei ...

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

Visto muitas recomendações para usar um ConcurrentDictionary, mas não há exemplos sólidos, então vou jogar meu chapéu nessa corrida de soluções. Como não sou desenvolvedor de thread-safe, se esse código não for sólido, fale por aqueles que seguem a seguir.

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

Vi outras postagens envolvendo ConcurrentDictionarye Lazycarregando o valor. Não tenho certeza se isso é relevante aqui ou não, mas aqui está o código para isso:

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