Użyj JsonSerializerSettings

• ReferenceLoopHandling.Error (domyślnie) spowoduje błąd w przypadku napotkania pętli odniesienia. Dlatego dostajesz wyjątek.
• ReferenceLoopHandling.Serialize jest przydatne, gdy obiekty są zagnieżdżane, ale nie w nieskończoność.
• ReferenceLoopHandling.Ignore nie spowoduje serializacji obiektu, jeśli jest on sam w sobie obiektem potomnym.

Przykład:

JsonConvert.SerializeObject(YourPOCOHere, Formatting.Indented, 
new JsonSerializerSettings { 
        ReferenceLoopHandling = ReferenceLoopHandling.Serialize
});

Jeśli musisz serializować obiekt, który jest zagnieżdżony w nieskończoność, możesz użyć PreserveObjectReferences , aby uniknąć StackOverflowException.

Przykład:

JsonConvert.SerializeObject(YourPOCOHere, Formatting.Indented, 
new JsonSerializerSettings { 
        PreserveReferencesHandling = PreserveReferencesHandling.Objects
});

Wybierz, co ma sens dla obiektu, który serializujesz.

Odniesienie http://james.newtonking.com/json/help/

Poprawką jest ignorowanie odwołań do pętli, a nie serializowanie ich. Zachowanie to jest określone w JsonSerializerSettings.

Single JsonConvert z przeciążeniem:

JsonConvert.SerializeObject(YourObject, Formatting.Indented,
    new JsonSerializerSettings() {
        ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
    }
);

Globalne ustawienie z kodem w {[4] } w globalnym.asax.cs:

JsonConvert.DefaultSettings = () => new JsonSerializerSettings {
     Formatting = Newtonsoft.Json.Formatting.Indented,
     ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
};

Numer referencyjny: https://github.com/JamesNK/Newtonsoft.Json/issues/78

Najprostszym sposobem na to jest zainstalowanie Json.NET z nuget i Dodaj atrybut [JsonIgnore] do wirtualnej właściwości w klasie, na przykład:

    public string Name { get; set; }
    public string Description { get; set; }
    public Nullable<int> Project_ID { get; set; }

    [JsonIgnore]
    public virtual Project Project { get; set; }

Chociaż w dzisiejszych czasach, tworzę model tylko z właściwościami, które chcę przekazać, więc jest lżejszy, nie zawiera niechcianych kolekcji i nie tracę swoich zmian, gdy odbudowuję wygenerowane pliki...

W. NET Core 1.0 możesz ustawić to jako globalne ustawienie w swoim starcie.plik cs:

using System.Buffers;
using Microsoft.AspNetCore.Mvc.Formatters;
using Newtonsoft.Json;

// beginning of Startup class

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc(options =>
        {
            options.OutputFormatters.Clear();
            options.OutputFormatters.Add(new JsonOutputFormatter(new JsonSerializerSettings(){
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
            }, ArrayPool<char>.Shared));
        });
    }

Możemy dodać te dwie linie do konstruktora klasy DbContext, aby wyłączyć pętlę odwołującą się do siebie, jak

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

Możesz również zastosować atrybut do właściwości. Atrybut [JsonProperty( ReferenceLoopHandling = ... )] dobrze do tego pasuje.

Na przykład:

/// <summary>
/// Represents the exception information of an event
/// </summary>
public class ExceptionInfo
{
    // ...code omitted for brevity...

    /// <summary>
    /// An inner (nested) error.
    /// </summary>
    [JsonProperty( ReferenceLoopHandling = ReferenceLoopHandling.Ignore, IsReference = true )]
    public ExceptionInfo Inner { get; set; }

    // ...code omitted for brevity...    
}

Hope that helps, Jaans

Aby zignorować odwołania do pętli i nie serializować ich globalnie w MVC 6, użyj poniższego przy starcie.cs:

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc().Configure<MvcOptions>(options =>
        {
            options.OutputFormatters.RemoveTypesOf<JsonOutputFormatter>();
            var jsonOutputFormatter = new JsonOutputFormatter();
            jsonOutputFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
            options.OutputFormatters.Insert(0, jsonOutputFormatter);
        });
    }

Użyj tego w WebApiConfig.cs klasie:

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

Dla mnie musiałem pójść inną drogą. Zamiast próbować naprawić JSON.Net serializer musiałem iść po leniwym ładowaniu na moim datacontext.

Właśnie dodałem to do repozytorium Bazy:

context.Configuration.ProxyCreationEnabled = false;

Obiekt "context" jest parametrem konstruktora, którego używam w repozytorium bazowym, ponieważ używam iniekcji zależności. Możesz zmienić właściwość ProxyCreationEnabled w dowolnym miejscu, w którym utworzysz instancję datacontext zamiast tego.

Http://techie-tid-bits.blogspot.com/2015/09/jsonnet-serializer-and-error-self.html

Aby serializować usin NEWTONSOFTJSON gdy masz problem z pętlą, w moim przypadku nie musiałem modyfikować global.asax lub apiconfig. Po prostu używam JsonSerializesSettings ignorując obsługę pętli.

JsonSerializerSettings jss = new JsonSerializerSettings();
jss.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
var lst = db.shCards.Where(m => m.CardID == id).ToList();
string json = JsonConvert.SerializeObject(lst, jss);

Miałem ten wyjątek i moje rozwiązanie pracy jest łatwe i proste,

Ignoruj właściwość, o której mowa, dodając do niej atrybut JsonIgnore:

[JsonIgnore]
public MyClass currentClass { get; set; }

Reset właściwości po deserializacji:

Source = JsonConvert.DeserializeObject<MyObject>(JsonTxt);
foreach (var item in Source)
        {
            Source.MyClass = item;
        }

Korzystanie Z Newtonsoft.Json;

Jeśli używasz. NET Core 2.0, zaktualizuj sekcję ConfigureServices podczas uruchamiania.cs

Https://docs.microsoft.com/en-us/ef/core/querying/related-data#related-data-and-serialization

public void ConfigureServices(IServiceCollection services)
{
...

services.AddMvc()
    .AddJsonOptions(
        options => options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
    );

...
}

Ludzie już mówili o [JsonIgnore] do dodania do wirtualnej właściwości w klasie, na przykład:

[JsonIgnore]
public virtual Project Project { get; set; }

Podzielę się również inną opcją, [JsonProperty (NullValueHandling = NullValueHandling.Ignoruj)], która pomija właściwość z serializacji tylko wtedy, gdy jest null.

[JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
public virtual Project Project { get; set; }

Po prostu umieść Configuration.ProxyCreationEnabled = false; wewnątrz pliku kontekstowego; to rozwiąże problem.

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

Za to, że nie zapętlenie tego mi się udało-
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,

Rozwiązałem to wszystko tutaj-Entity Framework children serialization with. Net Core 2 WebAPI https://gist.github.com/Kaidanov/f9ad0d79238494432f32b8407942c606

Podobało mi się rozwiązanie, które robi to z Application_Start() jak w odpowiedzi Tutaj

Najwyraźniej nie mogłem uzyskać dostępu do obiektów json w JavaScript, używając konfiguracji w mojej funkcji, jak w odpowiedzi DalSoft, ponieważ zwrócony obiekt miał "\N \ r " na całym (key, val) obiektu.

W każdym razie cokolwiek działa jest świetne (ponieważ różne podejścia działają w różnych scenariuszach na podstawie komentarzy i zadawanych pytań) choć standardowy sposób to zrobić byłoby lepsze z dobra dokumentacja wspierająca to podejście.