Fehler beim Serialisieren der Antwort in der Web-API mit Json

Ich arbeite mit ASP.NET MVC 5 Web Api. Ich möchte alle meine Benutzer konsultieren.

Ich habe geschrieben api/usersund erhalte Folgendes:

"Der Typ 'ObjectContent`1' konnte den Antworttext für den Inhaltstyp 'application / json; charset = utf-8' nicht serialisieren."

In WebApiConfig habe ich bereits folgende Zeilen hinzugefügt:

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

Aber es funktioniert immer noch nicht.

Meine Funktion für Rückgabedaten lautet:

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

Wenn es darum geht, Daten von Web Api (oder einem anderen Webdienst) an den Verbraucher zurückzugeben, empfehle ich dringend, Entitäten, die aus einer Datenbank stammen, nicht zurückzugeben. Es ist viel zuverlässiger und wartbarer, Modelle zu verwenden, in denen Sie steuern können, wie die Daten aussehen, und nicht die Datenbank. Auf diese Weise müssen Sie nicht so viel mit den Formatierern in der WebApiConfig herumspielen. Sie können einfach ein UserModel erstellen, das untergeordnete Modelle als Eigenschaften hat, und die Referenzschleifen in den Rückgabeobjekten entfernen. Das macht den Serializer viel glücklicher.

Außerdem müssen Formatierer oder unterstützte Medientypen normalerweise nicht entfernt werden, wenn Sie in der Anforderung nur den Header "Akzeptiert" angeben. Das Herumspielen mit diesem Zeug kann die Dinge manchmal verwirrender machen.

Beispiel:

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

Wenn Sie mit EF arbeiten, fügen Sie neben dem folgenden Code auch Global.asax hinzu

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

Vergessen Sie nicht zu importieren

using System.Data.Entity;

Dann können Sie Ihre eigenen EF-Modelle zurückgeben

So einfach ist das!

Die richtige Antwort ist ein Weg, aber es ist ein Overkill, wenn Sie es durch eine Konfigurationseinstellung beheben können.

Besser im dbcontext-Konstruktor verwenden

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

Asp.Net-Web-API-Fehler: Der Typ 'ObjectContent`1' konnte den Antworttext für den Inhaltstyp 'application / xml nicht serialisieren. Zeichensatz = utf-8 '

Fügen Sie diesen Code global.asaxunten hinzu Application_Start:

Update von .Ignorebis .Serialize. Es muss funktionieren.

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

Ich mag diesen Code nicht:

foreach(var user in db.Users)

Als Alternative könnte man so etwas tun, was für mich funktioniert hat:

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

                         });

return listOfUsers.ToList();

Am Ende habe ich jedoch die Lösung von Lucas Roselli verwendet.

Update: Vereinfacht durch Rückgabe eines anonymen Objekts:

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

return listOfUsers.ToList();

Ich habe es mit diesem Code in die Datei WebApiConfig.cs aufgelöst

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

Es gibt auch dieses Szenario, das denselben Fehler erzeugt:

Im Falle, dass die Rückgabe eine List<dynamic>Web-API-Methode ist

Beispiel:

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

Verwenden Sie für dieses Szenario das [KnownTypeAttribute] in der Rückgabeklasse (alle) wie folgt:

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

Das funktioniert bei mir!

Addiert man diese in Ihrer Application_Start()Methode der Global.asaxDatei lösen soll das Problem

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

METHODE 2: [Nicht empfohlen]
Wenn Sie mit EntityFramework arbeiten, können Sie den Proxy in Ihrem DbContext-Klassenkonstruktor deaktivieren. HINWEIS: Dieser Code wird entfernt, wenn Sie das Modell aktualisieren

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

Mein persönlicher Favorit: Fügen Sie einfach den folgenden Code hinzu App_Start/WebApiConfig.cs. Dies gibt standardmäßig json anstelle von XML zurück und verhindert auch den Fehler, den Sie hatten. Keine Notwendigkeit zu bearbeiten Global.asax, um zu entfernen XmlFormatterusw.

Der Typ 'ObjectContent`1' konnte den Antworttext für den Inhaltstyp 'application / xml nicht serialisieren. Zeichensatz = utf-8

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

Verwenden Sie AutoMapper ...

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

Verwenden Sie den folgenden Namespace:

using System.Web.OData;

Anstatt :

using System.Web.Http.OData;

Es hat bei mir funktioniert

Fügen Sie die folgende Zeile hinzu

this.Configuration.ProxyCreationEnabled = false;

Zwei Möglichkeiten, ProxyCreationEnabledals zu verwenden false.

1. Fügen Sie es in DBContextConstructor hinzu

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

ODER

2. Fügen Sie die Zeile innerhalb der GetMethode hinzu

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

Lösung, die bei mir funktioniert hat:

1. Verwenden Sie [DataContract]für Klasse und [DataMember]Attribute für jede zu serialisierende Eigenschaft. Dies reicht aus, um das Json-Ergebnis zu erhalten (z. B. vom Geiger).

2. Um die XML-Serialisierung zu erhalten, schreiben Sie Global.asaxdiesen Code:

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

3. Lesen Sie diesen Artikel, er hat mir geholfen, die Serialisierung zu verstehen: https://www.asp.net/web-api/overview/formats-and-model-binding/json-and-xml-serialization

Um die Antwort von jensendp zu ergänzen:

Ich würde die Entität an ein vom Benutzer erstelltes Modell übergeben und die Werte dieser Entität verwenden, um die Werte in Ihrem neu erstellten Modell festzulegen. Beispielsweise:

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

Ändern Sie dann Ihren Rückgabetyp in: IEnumerable<UserInformation>

Ich füge im Grunde eine Zeile hinzu, die sie sind

• entity.Configuration.ProxyCreationEnabled = false;

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

Verwenden Sie [Serializable] für die Klasse:

Beispiel:

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

Es hat bei mir funktioniert!

Sie müssen den Serializer-Formatierer in WebApiConfig.cs definieren, der im Ordner App_Start verfügbar ist

Hinzufügen von config.Formatters.Remove (config.Formatters.XmlFormatter); // die Ihnen Daten im JSON-Format liefert

Hinzufügen von config.Formatters.Remove (config.Formatters.JsonFormatter); // die Ihnen Daten im XML-Format liefert

Ein anderer Fall, in dem ich diesen Fehler erhielt, war, als meine Datenbankabfrage einen Nullwert zurückgab, mein Benutzer- / Ansichtsmodelltyp jedoch als nicht nullwertfähig festgelegt wurde. Zum Beispiel den Wechsel von meinem UserModel Feld intzu int?aufgelöst.

Dies passiert auch, wenn der Antworttyp nicht öffentlich ist! Ich habe eine interne Klasse zurückgegeben, als ich mit Visual Studio den Typ generiert habe.

internal class --> public class

Obwohl alle oben genannten Antworten korrekt sind, sollten Sie InnerException> ExceptionMessage überprüfen .

Wenn so etwas wie "Die ObjectContext-Instanz wurde entsorgt und kann nicht mehr für Vorgänge verwendet werden, für die eine Verbindung erforderlich ist. " Dies kann aufgrund des Standardverhaltens der EF ein Problem sein.

Durch Zuweisen von LazyLoadingEnabled = false in Ihrem DbContext-Konstruktor wird der Trick ausgeführt.

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

Weitere Informationen zum EagerLoading- und LazyLoading-Verhalten von EF finden Sie in diesem MSDN-Artikel .

In meinem Fall hatte ich eine ähnliche Fehlermeldung:

Der Typ 'ObjectContent`1' konnte den Antworttext für den Inhaltstyp 'application / xml nicht serialisieren. Zeichensatz = utf-8 '.

Aber wenn ich tiefer darin grabe, war das Problem:

Geben Sie 'name.SomeSubRootType' mit dem Datenvertragsnamen 'SomeSubRootType: //schemas.datacontract.org/2004/07/WhatEverService' nicht ein. Verwenden Sie einen DataContractResolver, wenn Sie DataContractSerializer verwenden, oder fügen Sie der Liste der bekannten Typen nicht statisch bekannte Typen hinzu, indem Sie beispielsweise das Attribut KnownTypeAttribute verwenden oder sie der Liste der bekannten Typen hinzufügen, die an den Serializer übergeben werden.

Die Art und Weise, wie ich durch Hinzufügen gelöst habe KnownType.

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

Dies wurde inspiriert von dieser Antwort gelöst .

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

Visual Studio 2017 oder 2019 ist diesbezüglich völlig unüberlegt, da Visual Studio selbst die Ausgabe im JSON- Format erfordert , während das Standardformat von Visual Studio " XmlFormat" (config.Formatters.XmlFormatter) ist .

Visual Studio sollte dies automatisch tun, anstatt den Entwicklern so viel Ärger zu bereiten.

Um dieses Problem zu beheben, rufen Sie die Datei WebApiConfig.cs auf und fügen Sie hinzu

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

nach " config.MapHttpAttributeRoutes (); " in der Register- Methode (HttpConfiguration config) . Dies würde es Ihrem Projekt ermöglichen, eine JSON-Ausgabe zu erzeugen.

In meinem Fall habe ich die Neuerstellung der Datenbank gelöst. Ich habe einige Änderungen an einem Modell vorgenommen und beim Starten der Update-Datenbank in der Package Manager-Konsole den folgenden Fehler erhalten:

"Die Anweisung ALTER TABLE stand in Konflikt mit der FOREIGN KEY-Einschränkung" FK_dbo.Activities_dbo.Projects_ProjectId ". Der Konflikt trat in der Datenbank" TrackEmAllContext-20190530144302 ", Tabelle" dbo.Projects ", Spalte 'Id' auf."

Falls: Wenn das Hinzufügen von Code zu WebApiConfig.cs oder Global.asax.cs für Sie nicht funktioniert:

.ToList();

Fügen Sie die Funktion .ToList () hinzu.

Ich habe jede Lösung ausprobiert, aber Folgendes hat bei mir funktioniert:

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

Ich hoffe, es hilft.

In meinem Fall wurde es behoben, als ich das virtuelle Schlüsselwort vor meinen Navigationseigenschaften entfernte. Ich meine die Referenztabellen. Also habe ich mich verändert

public virtual MembershipType MembershipType { get; set; }

zu:

public MembershipType MembershipType { get; set; }

Fügen Sie einfach die folgenden Zeilen in global.asax ein:

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

Importieren

using System.Data.Entity;