Impossibile serializzare la risposta nell'API Web con Json

Sto lavorando con ASP.NET MVC 5 Web Api. Voglio consultare tutti i miei utenti.

Ho scritto api/userse ricevo questo:

"Il tipo" ObjectContent`1 "non è riuscito a serializzare il corpo della risposta per il tipo di contenuto" application / json; charset = utf-8 ""

In WebApiConfig, ho già aggiunto queste righe:

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

Ma ancora non funziona.

La mia funzione per i dati di ritorno è questa:

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

Quando si tratta di restituire i dati al consumatore da Web Api (o da qualsiasi altro servizio Web per quella materia), consiglio vivamente di non restituire entità che provengono da un database. È molto più affidabile e gestibile utilizzare modelli in cui si ha il controllo dell'aspetto dei dati e non del database. In questo modo non devi perdere tempo con i formattatori nel WebApiConfig. Puoi semplicemente creare un UserModel che ha modelli figlio come proprietà e sbarazzarti dei loop di riferimento negli oggetti di ritorno. Ciò rende il serializzatore molto più felice.

Inoltre, non è necessario rimuovere i formattatori oi tipi di media supportati in genere se stai specificando solo l'intestazione "Accetta" nella richiesta. Giocare con quella roba a volte può creare confusione.

Esempio:

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

Se stai lavorando con EF, oltre ad aggiungere il codice qui sotto su Global.asax

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

Non dimenticare di importare

using System.Data.Entity;

Quindi puoi restituire i tuoi modelli EF

Semplice come quella!

Data la risposta giusta è un modo per andare, tuttavia è eccessivo quando puoi risolverlo con le impostazioni di una configurazione.

Meglio usarlo nel costruttore dbcontext

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

Errore API Web Asp.Net: il tipo "ObjectContent" 1 "non è riuscito a serializzare il corpo della risposta per il tipo di contenuto" application / xml; charset = utf-8'

Aggiungi questo codice di global.asaxseguito su Application_Start:

Aggiorna da .Ignorea .Serialize. Deve funzionare.

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

Non mi piace questo codice:

foreach(var user in db.Users)

In alternativa, si potrebbe fare qualcosa di simile, che ha funzionato per me:

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

                         });

return listOfUsers.ToList();

Tuttavia, ho finito per utilizzare la soluzione di Lucas Roselli.

Aggiornamento: semplificato restituendo un oggetto anonimo:

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

return listOfUsers.ToList();

L'ho risolto utilizzando questo codice nel file WebApiConfig.cs

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

C'è anche questo scenario che genera lo stesso errore:

Nel caso in cui il ritorno sia un List<dynamic>metodo api web

Esempio:

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

Quindi, per questo scenario usa [KnownTypeAttribute] nella classe di ritorno (tutti) in questo modo:

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

Questo funziona per me!

L'aggiunta di questo nel tuo Application_Start()metodo di Global.asaxfile dovrebbe risolvere il problema

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

METODO 2: [Non consigliato]
Se stai lavorando con EntityFramework, puoi disabilitare il proxy nel costruttore della classe DbContext. NOTA: questo codice verrà rimosso se aggiorni il modello

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

Il mio preferito personale: aggiungi il codice qui sotto a App_Start/WebApiConfig.cs. Questo restituirà json invece di XML per impostazione predefinita e impedirà anche l'errore che hai avuto. Non è necessario modificare Global.asaxper rimuovere XmlFormatterecc.

Il tipo "ObjectContent" 1 "non è riuscito a serializzare il corpo della risposta per il tipo di contenuto" application / xml; charset = utf-8

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

Usa AutoMapper ...

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

Utilizza il seguente spazio dei nomi:

using System.Web.OData;

Invece di :

using System.Web.Http.OData;

Ha funzionato per me

Aggiungi la riga sottostante

this.Configuration.ProxyCreationEnabled = false;

Due modi per usare ProxyCreationEnabledcome false.

1. Aggiungilo all'interno di DBContextConstructor

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

O

2. Aggiungi la linea all'interno del Getmetodo

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

Soluzione che ha funzionato per me:

1. Utilizzare [DataContract]per la classe e gli [DataMember]attributi per ogni proprietà da serializzare. Questo è sufficiente per ottenere il risultato di Json (ad es. Dal violinista).

2. Per ottenere la serializzazione xml scrivi Global.asaxquesto codice:

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

3. Leggi questo articolo, mi ha aiutato a capire la serializzazione: https://www.asp.net/web-api/overview/formats-and-model-binding/json-and-xml-serialization

Per aggiungere alla risposta di jensendp:

Passerei l'entità a un modello creato dall'utente e utilizzerei i valori di tale entità per impostare i valori nel modello appena creato. Per esempio:

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

Quindi modifica il tipo di reso in: IEnumerable<UserInformation>

Fondamentalmente aggiungo una riga che sono

• Entity.Configuration.ProxyCreationEnabled = false;

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

Usa [Serializable] per la classe:

Esempio:

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

Ha funzionato per me!

Dovrai definire Serializer Formatter all'interno di WebApiConfig.cs disponibile in App_Start Folder come

Aggiunta di config.Formatters.Remove (config.Formatters.XmlFormatter); // che ti fornirà i dati in formato JSON

Aggiunta di config.Formatters.Remove (config.Formatters.JsonFormatter); // che ti fornirà i dati in formato XML

Basta inserire le seguenti righe in global.asax:

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

Importare

using System.Data.Entity;

Un altro caso in cui ho ricevuto questo errore è stato quando la mia query sul database ha restituito un valore nullo ma il mio tipo di modello utente / vista è stato impostato come non annullabile. Ad esempio, cambiando il mio campo UserModel da inta int?risolto.

Ciò accade anche quando Response-Type non è pubblico! Ho restituito una classe interna poiché ho utilizzato Visual Studio per generarmi il tipo.

internal class --> public class

Sebbene tutte queste risposte sopra siano corrette, si potrebbe voler controllare InnerException> ExceptionMessage .

Se dice qualcosa del genere "L ' istanza di ObjectContext è stata eliminata e non può più essere utilizzata per operazioni che richiedono una connessione. ". Questo potrebbe essere un problema a causa del comportamento predefinito dell'EF.

Assegnando LazyLoadingEnabled = false nel tuo costruttore DbContext farà il trucco.

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

Per una lettura più dettagliata sul comportamento di EagerLoading e LazyLoading di EF, fare riferimento a questo articolo MSDN .

Nel mio caso ho ricevuto un messaggio di errore simile:

Il tipo "ObjectContent" 1 "non è riuscito a serializzare il corpo della risposta per il tipo di contenuto" application / xml; charset = utf-8' .

Ma quando ho scavato più a fondo, il problema era:

Digitare "name.SomeSubRootType" con il nome del contratto dati "SomeSubRootType: //schemas.datacontract.org/2004/07/WhatEverService" non è previsto. Prendi in considerazione l'utilizzo di un DataContractResolver se stai usando DataContractSerializer o aggiungi qualsiasi tipo non noto staticamente all'elenco dei tipi noti, ad esempio usando l'attributo KnownTypeAttribute o aggiungendoli all'elenco dei tipi noti passati al serializzatore.

Il modo in cui ho risolto aggiungendo KnownType.

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

Questo è stato risolto ispirato da questa risposta .

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

Visual Studio 2017 o 2019 è assolutamente impensabile su questo, perché Visual Studio stesso richiede che l'output sia in formato json , mentre il formato predefinito di Visual Studio è " XmlFormat" (config.Formatters.XmlFormatter) .

Visual Studio dovrebbe farlo automaticamente invece di dare tanti problemi agli sviluppatori.

Per correggere questo problema, vai al file WebApiConfig.cs e aggiungi

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

dopo " config.MapHttpAttributeRoutes (); " nel metodo Register (HttpConfiguration config) . Ciò consentirebbe al tuo progetto di produrre output json.

Nel mio caso ho risolto ricreando il database. Ho apportato alcune modifiche a un modello e lanciando Update-Database nella console di Gestione pacchetti ho ricevuto il seguente errore:

"L'istruzione ALTER TABLE era in conflitto con il vincolo FOREIGN KEY" FK_dbo.Activities_dbo.Projects_ProjectId ". Il conflitto si è verificato nel database" TrackEmAllContext-20190530144302 ", tabella" dbo.Projects ", colonna" Id "."

Nel caso: se l'aggiunta di codice a WebApiConfig.cs o Global.asax.cs non funziona per te:

.ToList();

Aggiungi la funzione .ToList ().

Ho provato ogni soluzione, ma per me ha funzionato:

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

Spero possa essere d'aiuto.

nel mio caso, è stato corretto quando ho rimosso la parola chiave virtuale prima delle mie proprietà di navigazione, intendo le tabelle di riferimento. quindi sono cambiato

public virtual MembershipType MembershipType { get; set; }

per:

public MembershipType MembershipType { get; set; }