Use JsonSerializerSettings

• ReferenceLoopHandling.Error (predeterminado) se producirá un error si se encuentra un bucle de referencia. Esta es la razón por la que se obtiene una excepción.
• ReferenceLoopHandling.Serialize es útil si los objetos están anidados pero no indefinidamente.
• ReferenceLoopHandling.Ignore no serializará un objeto si es un objeto hijo en sí mismo.

Ejemplo:

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

Si tiene que serializar un objeto que está anidado indefinidamente, puede usar PreserveObjectReferences para evitar un StackOverflowException.

Ejemplo:

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

Elija lo que tiene sentido para el objeto que está serializando.

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

La solución es ignorar las referencias de bucle y no serializarlas. Este comportamiento se especifica en JsonSerializerSettings.

Soltero JsonConvert con una sobrecarga:

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

Configuración global con código en Application_Start() en Global.asax.cs:

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

Referencia: https://github.com/JamesNK/Newtonsoft.Json/issues/78

La forma más sencilla de hacerlo es instalar Json.NET desde nuget y añadir el atributo [JsonIgnore] a la propiedad virtual de la clase, por ejemplo:

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

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

Aunque en estos días, creo un modelo con solo las propiedades que quiero pasar por lo que es más ligero, no incluye colecciones no deseadas, y no pierdo mis cambios cuando reconstruyo los archivos generados...

En.NET Core 1.0, puede establecer esto como una configuración global en su inicio.archivo 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));
        });
    }

Podemos agregar estas dos líneas en DbContext class constructor para deshabilitar el bucle de Auto-referencia, como

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

También puede aplicar un atributo a la propiedad. El atributo [JsonProperty( ReferenceLoopHandling = ... )] es muy adecuado para esto.

Por ejemplo:

/// <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...    
}

Esperanza que ayuda, Jaans

Para ignorar las referencias de bucle y no serializarlas globalmente en MVC 6 use lo siguiente en startup.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);
        });
    }

Use esto en WebApiConfig.cs clase:

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

Para mí tuve que ir por un camino diferente. En lugar de tratar de arreglar el JSON.Net serializador Tuve que ir después de la carga perezosa en mi datacontext.

Acabo de añadir esto a mi repositorio base:

context.Configuration.ProxyCreationEnabled = false;

El objeto "context" es un parámetro constructor que uso en mi repositorio base porque uso inyección de dependencias. Puede cambiar la propiedad ProxyCreationEnabled en cualquier lugar donde cree una instancia de su datacontext en su lugar.

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

Para serializar usin NEWTONSOFTJSON cuando tiene un problema de bucle, en mi caso no necesitaba modificar global.asax o apiconfig. Solo uso JsonSerializesSettings ignorando el manejo de bucles.

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

Tuve esta excepción y mi solución de trabajo es Fácil y Simple,

Ignore la propiedad Referenciada agregándole el atributo JsonIgnore:

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

Restablecer la propiedad al Deserializar es:

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

Usando Newtonsoft.Json;

Si está utilizando.NET Core 2.0, actualice la sección ConfigureServices en Inicio.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
    );

...
}

La gente ya ha hablado acerca de [JsonIgnore] para ser añadido a la propiedad virtual en la clase, por ejemplo:

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

También compartiré otra opción, [JsonProperty(NullValueHandling = NullValueHandling.Ignore)] que omite la propiedad de serialización solo si es null.

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

Simplemente coloque Configuration.ProxyCreationEnabled = false; dentro del archivo de contexto; esto resolverá el problema.

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

Para no loopear esto funcionó para mí-
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,

Lo he resuelto todo aquí-Serialización de Entity Framework children con. Net Core 2 WebAPI https://gist.github.com/Kaidanov/f9ad0d79238494432f32b8407942c606

Apreciará cualquier comentario. tal vez alguien pueda usarlo alguna vez.

Me gustó la solución que lo hace desde Application_Start() como en la respuesta aquí

Aparentemente no pude acceder a los objetos json en JavaScript usando la configuración dentro de mi función como en la respuesta de DalSoft, ya que el objeto devuelto tenía "\n \r" en todo el (key, val) del objeto.

De todos modos, lo que funciona es genial (porque los diferentes enfoques funcionan en diferentes escenarios basados en los comentarios y preguntas formuladas), aunque una forma estándar de hacerlo sería preferible con alguna buena documentación que respalde el enfoque.