No se pudo serializar la respuesta en la API web con Json

Estoy trabajando con ASP.NET MVC 5 Web Api. Quiero consultar a todos mis usuarios.

Escribí api/usersy recibo esto:

"El tipo 'ObjectContent`1' no pudo serializar el cuerpo de la respuesta para el tipo de contenido 'application / json; charset = utf-8'"

En WebApiConfig, ya agregué estas líneas:

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

Pero todavía no funciona.

Mi función para devolver datos es esta:

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

Cuando se trata de devolver datos al consumidor desde Web Api (o cualquier otro servicio web para el caso), recomiendo no devolver entidades que provengan de una base de datos. Es mucho más confiable y fácil de mantener usar modelos en los que tiene control de cómo se ven los datos y no la base de datos. De esa manera, no tendrá que perder tanto tiempo con los formateadores en WebApiConfig. Puede crear un UserModel que tenga modelos secundarios como propiedades y deshacerse de los bucles de referencia en los objetos de retorno. Eso hace que el serializador sea mucho más feliz.

Además, no es necesario eliminar los formateadores o los tipos de medios admitidos normalmente si solo especifica el encabezado "Acepta" en la solicitud. Jugar con esas cosas a veces puede hacer que las cosas sean más confusas.

Ejemplo:

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

Si está trabajando con EF, además de agregar el siguiente código en Global.asax

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

No olvides importar

using System.Data.Entity;

Entonces puede devolver sus propios modelos EF

¡Simple como eso!

Una respuesta correcta es una forma de hacerlo, sin embargo, es una exageración cuando puede solucionarlo mediante una configuración de configuración.

Es mejor usarlo en el constructor dbcontext

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

Error de API web de Asp.Net: el tipo 'ObjectContent`1' no pudo serializar el cuerpo de la respuesta para el tipo de contenido 'application / xml; charset = utf-8 '

Agregue este código a global.asaxcontinuación en Application_Start:

Actualizar de .Ignorea .Serialize. Debe 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();
    }
}

No me gusta este código:

foreach(var user in db.Users)

Como alternativa, uno podría hacer algo como esto, que funcionó para mí:

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

                         });

return listOfUsers.ToList();

Sin embargo, terminé usando la solución de Lucas Roselli.

Actualización: simplificado al devolver un objeto anónimo:

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

return listOfUsers.ToList();

Lo resolví usando este código en el archivo WebApiConfig.cs

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

También existe este escenario que genera el mismo error:

En caso de que la devolución sea un List<dynamic> método de API web

Ejemplo:

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

Entonces, para este escenario use el [KnownTypeAttribute] en la clase de retorno (todos ellos) así:

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

¡Esto funciona para mí!

Agregar esto en su Application_Start()método de Global.asaxarchivo debería resolver el 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: [No recomendado]
Si está trabajando con EntityFramework, puede deshabilitar el proxy en su constructor de clases DbContext. NOTA: este código se eliminará si actualiza el modelo

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

Mi favorito personal: simplemente agregue el código a continuación a App_Start/WebApiConfig.cs. Esto devolverá json en lugar de XML de forma predeterminada y también evitará el error que tuvo. No es necesario editar Global.asaxpara eliminar, XmlFormatteretc.

El tipo 'ObjectContent`1' no pudo serializar el cuerpo de la respuesta para el tipo de contenido 'application / xml; juego de caracteres = 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;
        }
    }

Utilice el siguiente espacio de nombres:

using System.Web.OData;

En vez de :

using System.Web.Http.OData;

Funcionó para mi

Agrega la siguiente línea

this.Configuration.ProxyCreationEnabled = false;

Dos formas de usar ProxyCreationEnabledcomo false.

1. Agréguelo dentro de DBContextConstructor

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

O

2. Agrega la línea dentro del Getmétodo

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

Solución que funcionó para mí:

1. Úselo [DataContract]para la clase y los [DataMember]atributos de cada propiedad a serializar. Esto es suficiente para obtener el resultado de Json (por ejemplo, de fiddler).

2. Para obtener la serialización xml, escriba Global.asaxeste código:

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

3. Leer este artículo, me ayudó a comprender la serialización: https://www.asp.net/web-api/overview/formats-and-model-binding/json-and-xml-serialization

Para agregar a la respuesta de jensendp:

Pasaría la entidad a un modelo creado por el usuario y usaría los valores de esa entidad para establecer los valores en su modelo recién creado. Por ejemplo:

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

Luego cambie su tipo de retorno a: IEnumerable<UserInformation>

Básicamente agrego una línea que son

• entidades.Configuración.ProxyCreationEnabled = falso;

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

Utilice [Serializable] para la clase:

Ejemplo:

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

¡Funcionó para mí!

Tendrá que definir Serializer Formatter dentro de WebApiConfig.cs disponible en App_Start Folder como

Añadiendo config.Formatters.Remove (config.Formatters.XmlFormatter); // que le proporcionará datos en formato JSON

Añadiendo config.Formatters.Remove (config.Formatters.JsonFormatter); // que le proporcionará datos en formato XML

Simplemente coloque las siguientes líneas en 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;

Otro caso en el que recibí este error fue cuando mi consulta de base de datos devolvió un valor nulo, pero mi tipo de modelo de usuario / vista se estableció como no anulable. Por ejemplo, cambiar mi campo UserModel de inta int?resuelto.

¡Esto también sucede cuando el tipo de respuesta no es público! Devolví una clase interna ya que usé Visual Studio para generarme el tipo.

internal class --> public class

Si bien todas estas respuestas anteriores son correctas, es posible que desee verificar InnerException> ExceptionMessage .

Si dice algo como esto "La instancia de ObjectContext se ha eliminado y ya no se puede usar para operaciones que requieren una conexión. ". Esto podría ser un problema debido al comportamiento predeterminado del EF.

Al asignar LazyLoadingEnabled = false en su constructor DbContext hará el truco.

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

Para obtener una lectura más detallada sobre el comportamiento EagerLoading y LazyLoading de EF, consulte este artículo de MSDN .

En mi caso, he tenido un mensaje de error similar:

El tipo 'ObjectContent`1' no pudo serializar el cuerpo de la respuesta para el tipo de contenido 'application / xml; charset = utf-8 '.

Pero cuando profundizo en él, el problema fue:

Escriba 'name.SomeSubRootType' con el nombre del contrato de datos 'SomeSubRootType: //schemas.datacontract.org/2004/07/WhatEverService' no se espera. Considere usar un DataContractResolver si está usando DataContractSerializer o agregue cualquier tipo no conocido estáticamente a la lista de tipos conocidos, por ejemplo, usando el atributo KnownTypeAttribute o agregándolos a la lista de tipos conocidos pasados ​​al serializador.

La forma en que resolví agregando KnownType.

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

Esto se resolvió inspirado en esta respuesta .

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

Visual Studio 2017 o 2019 es totalmente imprudente en esto, porque Visual Studio requiere que la salida esté en formato json , mientras que el formato predeterminado de Visual Studio es " XmlFormat" (config.Formatters.XmlFormatter) .

Visual Studio debería hacer esto automáticamente en lugar de dar tantos problemas a los desarrolladores.

Para corregir este problema, vaya al archivo WebApiConfig.cs y agregue

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

después de " config.MapHttpAttributeRoutes (); " en el método Register (HttpConfiguration config) . Esto permitiría que su proyecto produzca una salida json.

En mi caso resolví recrear la base de datos. Hice algunos cambios en un modelo y al iniciar Update-Database en Package Manager Console obtuve el siguiente error:

"La declaración ALTER TABLE entró en conflicto con la restricción FOREIGN KEY" FK_dbo.Activities_dbo.Projects_ProjectId ". El conflicto ocurrió en la base de datos" TrackEmAllContext-20190530144302 ", tabla" dbo.Projects ", columna 'Id'."

En caso de que no le funcione agregar código a WebApiConfig.cs o Global.asax.cs :

.ToList();

Agregue la función .ToList ().

Probé todas las soluciones, pero lo siguiente funcionó para mí:

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

Espero que ayude.

en mi caso, se solucionó cuando eliminé la palabra clave virtual antes de mis propiedades de navegación, me refiero a las tablas de referencia. así que cambié

public virtual MembershipType MembershipType { get; set; }

a:

public MembershipType MembershipType { get; set; }