Falha ao serializar a resposta na API da Web com Json

Estou trabalhando com ASP.NET MVC 5 Web Api. Quero consultar todos os meus usuários.

Escrevi api/userse recebo isto:

"O tipo 'ObjectContent`1' falhou ao serializar o corpo da resposta para o tipo de conteúdo 'application / json; charset = utf-8'"

No WebApiConfig, já adicionei estas linhas:

HttpConfiguration config = new HttpConfiguration();
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
config.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore; 

Mas ainda não funciona.

Minha função para dados de retorno é esta:

public IEnumerable<User> GetAll()
{
    using (Database db = new Database())
    {
        return db.Users.ToList();
    }
}

Quando se trata de retornar dados ao consumidor da API Web (ou de qualquer outro serviço da Web), recomendo enfaticamente não transmitir entidades que vêm de um banco de dados. É muito mais confiável e sustentável usar modelos nos quais você tem controle da aparência dos dados e não do banco de dados. Assim, você não precisa mexer tanto com os formatadores no WebApiConfig. Você pode simplesmente criar um UserModel que tem modelos filhos como propriedades e se livrar dos loops de referência nos objetos de retorno. Isso deixa o serializador muito mais feliz.

Além disso, não é necessário remover formatadores ou tipos de mídia suportados normalmente se você estiver apenas especificando o cabeçalho "Aceita" na solicitação. Brincar com essas coisas às vezes pode tornar as coisas mais confusas.

Exemplo:

public class UserModel {
    public string Name {get;set;}
    public string Age {get;set;}
    // Other properties here that do not reference another UserModel class.
}

Se você está trabalhando com EF, além de adicionar o código abaixo em Global.asax

GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings
    .ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
GlobalConfiguration.Configuration.Formatters
    .Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);          

Não se esqueça de importar

using System.Data.Entity;

Então você pode devolver seus próprios modelos EF

Simples assim!

Dada a resposta certa é um caminho a percorrer, no entanto, é um exagero quando você pode corrigi-lo por meio de uma configuração.

Melhor usá-lo no construtor dbcontext

public DbContext() // dbcontext constructor
            : base("name=ConnectionStringNameFromWebConfig")
{
     this.Configuration.LazyLoadingEnabled = false;
     this.Configuration.ProxyCreationEnabled = false;
}

Erro de API Web Asp.Net: O tipo 'ObjectContent`1' falhou ao serializar o corpo de resposta para o tipo de conteúdo 'application / xml; charset = utf-8 '

Adicione este código global.asaxabaixo em Application_Start:

Atualizar de .Ignorea .Serialize. Deve funcionar.

GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize;
            GlobalConfiguration.Configuration.Formatters.Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);

public class UserController : ApiController
{

   Database db = new Database();

   // construction
   public UserController()
   {
      // Add the following code
      // problem will be solved
      db.Configuration.ProxyCreationEnabled = false;
   }

   public IEnumerable<User> GetAll()
    {
            return db.Users.ToList();
    }
}

Eu não gosto deste código:

foreach(var user in db.Users)

Como alternativa, pode-se fazer algo assim, que funcionou para mim:

var listOfUsers = db.Users.Select(r => new UserModel
                         {
                             userModel.FirstName = r.FirstName;
                             userModel.LastName = r.LastName;

                         });

return listOfUsers.ToList();

Porém, acabei usando a solução de Lucas Roselli.

Atualização: simplificado pelo retorno de um objeto anônimo:

var listOfUsers = db.Users.Select(r => new 
                         {
                             FirstName = r.FirstName;
                             LastName = r.LastName;
                         });

return listOfUsers.ToList();

Resolvi isso usando este código para o arquivo WebApiConfig.cs

var json = config.Formatters.JsonFormatter;
json.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects; 
config.Formatters.Remove(config.Formatters.XmlFormatter);

Também existe este cenário que gera o mesmo erro:

No caso de o retorno ser um List<dynamic>método de API da web

Exemplo:

public HttpResponseMessage Get()
{
    var item = new List<dynamic> { new TestClass { Name = "Ale", Age = 30 } };

    return Request.CreateResponse(HttpStatusCode.OK, item);
}

public class TestClass
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Portanto, para este cenário, use o [KnownTypeAttribute] na classe de retorno (todos eles) assim:

[KnownTypeAttribute(typeof(TestClass))]
public class TestClass
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Isso funciona para mim!

Adicionar isso ao seu Application_Start()método de Global.asaxarquivo deve resolver o problema

protected void Application_Start()
{
    GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings
        .ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
    GlobalConfiguration.Configuration.Formatters
        .Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter); 
// ...
}

MÉTODO 2: [Não recomendado]
Se você estiver trabalhando com EntityFramework, você pode desativar o proxy em seu construtor de classe DbContext. NOTA: este código será removido se você atualizar o modelo

public class MyDbContext : DbContext
{
  public MyDbContext()
  {
    this.Configuration.ProxyCreationEnabled = false;
  }
}

Meu favorito pessoal: Basta adicionar o código abaixo para App_Start/WebApiConfig.cs. Isso retornará json em vez de XML por padrão e também evitará o erro que você teve. Não há necessidade de editar Global.asaxpara remover XmlFormatteretc.

O tipo 'ObjectContent`1' falhou ao serializar o corpo da resposta para o tipo de conteúdo 'application / xml; charset = utf-8

config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));

Usar AutoMapper ...

public IEnumerable<User> GetAll()
    {
        using (Database db = new Database())
        {
            var users = AutoMapper.Mapper.DynamicMap<List<User>>(db.Users);
            return users;
        }
    }

Use o seguinte namespace:

using System.Web.OData;

Ao invés de :

using System.Web.Http.OData;

Funcionou para mim

Adicione a linha abaixo

this.Configuration.ProxyCreationEnabled = false;

Duas maneiras de usar ProxyCreationEnabledcomo false.

1. Adicione-o dentro do DBContextConstrutor

   public ProductEntities() : base("name=ProductEntities")
   {
       this.Configuration.ProxyCreationEnabled = false;
   }

OU

2. Adicione a linha dentro do Getmétodo

   public IEnumerable<Brand_Details> Get()
   {
       using (ProductEntities obj = new ProductEntities())
       {
           this.Configuration.ProxyCreationEnabled = false;
           return obj.Brand_Details.ToList();
       }
   }

Solução que funcionou para mim:

1. Use [DataContract]para a classe e os [DataMember]atributos de cada propriedade a ser serializada. Isso é o suficiente para obter o resultado Json (por exemplo, do violinista).

2. Para obter a serialização xml, escreva Global.asaxneste código:

   var xml = GlobalConfiguration.Configuration.Formatters.XmlFormatter; xml.UseXmlSerializer = true;

3. Leia este artigo, ele me ajudou a entender a serialização: https://www.asp.net/web-api/overview/formats-and-model-binding/json-and-xml-serialization

Para adicionar à resposta de jensendp:

Gostaria de passar a entidade para um modelo criado pelo usuário e usar os valores dessa entidade para definir os valores em seu modelo recém-criado. Por exemplo:

public class UserInformation {
   public string Name { get; set; }
   public int Age { get; set; }

   public UserInformation(UserEntity user) {
      this.Name = user.name;
      this.Age = user.age;
   }
}

Em seguida, altere seu tipo de retorno para: IEnumerable<UserInformation>

Eu basicamente adiciono uma linha que eles são

• entidades.Configuration.ProxyCreationEnabled = false;

para UsersController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using UserDataAccess;

namespace SBPMS.Controllers
{
    public class UsersController : ApiController
    {


        public IEnumerable<User> Get() {
            using (SBPMSystemEntities entities = new SBPMSystemEntities()) {
                entities.Configuration.ProxyCreationEnabled = false;
                return entities.Users.ToList();
            }
        }
        public User Get(int id) {
            using (SBPMSystemEntities entities = new SBPMSystemEntities()) {
                entities.Configuration.ProxyCreationEnabled = false;
                return entities.Users.FirstOrDefault(e => e.user_ID == id);
            }
        }
    }
}

Use [Serializable] para a classe:

Exemplo:

[Serializable]
public class UserModel {
    public string Name {get;set;}
    public string Age {get;set;}
}

Funcionou para mim!

Você terá que definir o Serializer Formatter dentro de WebApiConfig.cs disponível na pasta App_Start como

Adicionando config.Formatters.Remove (config.Formatters.XmlFormatter); // que fornecerá dados no formato JSON

Adicionando config.Formatters.Remove (config.Formatters.JsonFormatter); // que fornecerá dados em formato XML

Basta colocar as seguintes linhas em global.asax:

GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;  
GlobalConfiguration.Configuration.Formatters.Remove(GlobalConfiguration.Configuration.Formatters.XmlFormatter);

Importar

using System.Data.Entity;

Outro caso em que recebi esse erro foi quando minha consulta de banco de dados retornou um valor nulo, mas meu tipo de modelo de usuário / visualização foi definido como não anulável. Por exemplo, alterando meu campo UserModel de intpara int?resolvido.

Isso também acontece quando o Tipo de resposta não é público! Retornei uma classe interna, pois usei o Visual Studio para gerar o tipo.

internal class --> public class

Embora todas as respostas acima estejam corretas, pode-se querer verificar a InnerException> ExceptionMessage .

Se disser algo como "A instância ObjectContext foi descartada e não pode mais ser usada para operações que requerem uma conexão. ". Isso pode ser um problema devido ao comportamento padrão do EF.

Ao atribuir LazyLoadingEnabled = false em seu construtor DbContext irá fazer o truque.

public class MyDbContext : DbContext
{
  public MyDbContext()
  {
    this.Configuration.LazyLoadingEnabled = false;
  }
}

Para uma leitura mais detalhada sobre o comportamento de EagerLoading e LazyLoading da EF, consulte este artigo MSDN .

No meu caso, recebi uma mensagem de erro semelhante:

O tipo 'ObjectContent`1' falhou ao serializar o corpo da resposta para o tipo de conteúdo 'application / xml; charset = utf-8 '.

Mas quando vou mais fundo nisso, o problema era:

O tipo 'name.SomeSubRootType' com o nome do contrato de dados 'SomeSubRootType: //schemas.datacontract.org/2004/07/WhatEverService' não é esperado. Considere usar um DataContractResolver se estiver usando DataContractSerializer ou adicione quaisquer tipos não conhecidos estaticamente à lista de tipos conhecidos - por exemplo, usando o atributo KnownTypeAttribute ou adicionando-os à lista de tipos conhecidos passados ​​para o serializador.

A maneira como resolvi adicionando KnownType.

[KnownType(typeof(SomeSubRootType))]
public partial class SomeRootStructureType

Isso foi resolvido inspirado nesta resposta .

Referência: https://msdn.microsoft.com/en-us/library/ms730167(v=vs.100).aspx

O Visual Studio 2017 ou 2019 é totalmente impensado nisso, porque o próprio Visual Studio requer que a saída esteja no formato json , enquanto o formato padrão do Visual Studio é " XmlFormat" (config.Formatters.XmlFormatter) .

O Visual Studio deve fazer isso automaticamente, em vez de dar tantos problemas aos desenvolvedores.

Para corrigir esse problema, vá para o arquivo WebApiConfig.cs e adicione

var json = config.Formatters.JsonFormatter; json.SerializerSettings.PreserveReferencesHandling = Newtonsoft.Json.PreserveReferencesHandling.Objects; config.Formatters.Remove (config.Formatters.XmlFormatter);

após " config.MapHttpAttributeRoutes (); " no método Register (HttpConfiguration config) . Isso permitiria que seu projeto produzisse saída json.

No meu caso, resolvi recriar o banco de dados. Fiz algumas alterações em um modelo e, ao iniciar o Update-Database no Package Manager Console, obtive o seguinte erro:

"A instrução ALTER TABLE entrou em conflito com a restrição FOREIGN KEY" FK_dbo.Activities_dbo.Projects_ProjectId ". O conflito ocorreu no banco de dados" TrackEmAllContext-20190530144302 ", tabela" dbo.Projects ", coluna 'Id'."

Caso: Se adicionar código a WebApiConfig.cs ou Global.asax.cs não funcionar para você:

.ToList();

Adicione a função .ToList ().

Tentei todas as soluções, mas as seguintes funcionaram para mim:

var allShops = context.shops.Where(s => s.city_id == id)**.ToList()**;
return allShops;

Espero que ajude.

no meu caso, foi corrigido quando removi a palavra-chave virtual antes das minhas propriedades de navegação, ou seja, as tabelas de referência. então eu mudei

public virtual MembershipType MembershipType { get; set; }

para:

public MembershipType MembershipType { get; set; }