EF 4.1 - Code First - JSON Circular Reference Serialization Error

Question

I am getting an a Circular Reference Serialization Error although, to my knowledge I do not have any circular references. I am retrieving a set of Orders from the database and sending them to the client as JSON. All the code is shown below.

This is the error:

Error

A circular reference was detected while serializing an object of type 'System.Data.Entity.DynamicProxies.Order_83CECF2AA4DE38232F9077D4B26941AB96BC61230419EA8AC42C9100E6072812'. Description: An unhandled exception occurred during the execution of the current web request. Please review the stack trace for more information about the error and where it originated in the code.

Exception Details: System.InvalidOperationException: A circular reference was detected while serializing an object of type 'System.Data.Entity.DynamicProxies.Order_83CECF2AA4DE38232F9077D4B26941AB96BC61230419EA8AC42C9100E6072812'.

Source Error:

An unhandled exception was generated during the execution of the current web request. Information regarding the origin and location of the exception can be identified using the exception stack trace below.

My classes are as follows:

Order

public class Order
{
    [Key]
    public int OrderId { get; set; }

    public int PatientId { get; set; }
    public virtual Patient Patient { get; set; }

    public int CertificationPeriodId { get; set; }
    public virtual CertificationPeriod CertificationPeriod { get; set; }

    public int AgencyId { get; set; }
    public virtual Agency Agency { get; set; }

    public int PrimaryDiagnosisId { get; set; }
    public virtual Diagnosis PrimaryDiagnosis { get; set; }

    public int ApprovalStatusId { get; set; }
    public virtual OrderApprovalStatus ApprovalStatus { get; set; }

    public int ApproverId { get; set; }
    public virtual User Approver { get; set; }

    public int SubmitterId { get; set; }
    public virtual User Submitter { get; set; }

    public DateTime ApprovalDate { get; set; }

    public DateTime SubmittedDate { get; set; }
    public Boolean IsDeprecated { get; set; }
}

Patient

public class Patient
{
    [Key]
    public int PatientId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string MiddleInitial { get; set; }
    public bool IsMale;
    public DateTime DateOfBirth { get; set; }

    public int PatientAddressId { get; set; }
    public Address PatientAddress { get; set; }

    public bool IsDeprecated { get; set; }
}

Certification Period

public class CertificationPeriod
{
    [Key]
    public int CertificationPeriodId { get; set; }
    public DateTime startDate { get; set; }
    public DateTime endDate { get; set; }
    public bool isDeprecated { get; set; }
}

Agency

public class Agency
{
    [Key]
    public int AgencyId { get; set; }
    public string Name { get; set; }

    public int PatientAddressId { get; set; }
    public virtual Address Address { get; set; }
}

Diagnosis

public class Diagnosis
{
    [Key]
    public int DiagnosisId { get; set; }
    public string Icd9Code { get; set; }
    public string Description { get; set; }
    public DateTime DateOfDiagnosis { get; set; }
    public string Onset { get; set; }
    public string Details { get; set; }
}

OrderApprovalStatus

public class OrderApprovalStatus
{
    [Key]
    public int OrderApprovalStatusId { get; set; }
    public string Status { get; set; }
}

User

public class User
{
    [Key]
    public int UserId { get; set; }
    public string Login { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string NPI { get; set; }
    public string Email { get; set; }

}

NOTE: ADDRESS CLASS IS NEW ADDITION DURING EDIT

Address

public class Address
{
    [Key]
    public int AddressId { get; set; }
    public string StreetAddress { get; set; }
    public string City { get; set; }
    public string State { get; set; }
    public string Zip { get; set; }
    public string Phone { get; set; }
    public string Title { get; set; }
    public string Label { get; set; }
}

The code that executes the serialization is here:

Excerpt from OrderController

    public ActionResult GetAll()
    {
        return Json(ppEFContext.Orders, JsonRequestBehavior.AllowGet);
    }

Thanks

@Guido: No need to add a sig in your question. SO autosigns all posts with SO flair. — Paul Sasik, Oct 10 '11 at 04:35

score 50 · Accepted Answer · edited May 23 '17 at 12:17

You could try to remove the virtual keyword from all navigation properties to disable lazy loading and proxy creation and then use eager loading instead to load the required object graph explicitely:

public ActionResult GetAll()
{
    return Json(ppEFContext.Orders
                           .Include(o => o.Patient)
                           .Include(o => o.Patient.PatientAddress)
                           .Include(o => o.CertificationPeriod)
                           .Include(o => o.Agency)
                           .Include(o => o.Agency.Address)
                           .Include(o => o.PrimaryDiagnosis)
                           .Include(o => o.ApprovalStatus)
                           .Include(o => o.Approver)
                           .Include(o => o.Submitter),
        JsonRequestBehavior.AllowGet);
}

Referring to your previous post it looks like your application isn't relying on lazy loading anyway because you introduced there the virtual properties to load the object graph lazily, possibly causing now the serialization trouble.

Edit

It's not necessary to remove the virtual keyword from the navigation properties (which would make lazy loading completely impossible for the model). It's enough to disable proxy creation (which disables lazy loading as well) for the specific circumstances where proxies are disturbing, like serialization:

ppEFContext.Configuration.ProxyCreationEnabled = false;

This disables proxy creation only for the specific context instance ppEFContext.

(I've just seen, @WillC already mentioned it here. Upvote for this edit please to his answer.)

@Slauma: Thanks! That worked. What exactly is happening with all of those .Include statements? — Guido Anselmi, Apr 07 '11 at 23:39
It causes to load all the related entities when the query is executed. You can find a little tutorial about the different options to load related entities here: http://blogs.msdn.com/b/adonet/archive/2011/01/31/using-dbcontext-in-ef-feature-ctp5-part-6-loading-related-entities.aspx. It is part of this series on EF 4.1: http://blogs.msdn.com/b/adonet/archive/2011/01/27/using-dbcontext-in-ef-feature-ctp5-part-1-introduction-and-model.aspx — Slauma, Apr 07 '11 at 23:49
Was the `Include()` method removed from the 4.1 release? The version I have wants a `string` as parameter. — Yuck, May 23 '11 at 19:35
@Yuck: No, it's not removed. You need a reference to `EntityFramework.dll` assembly in your project and `using System.Data.Entity;` as namespace, then you should have the overload with the lambda expression. — Slauma, May 23 '11 at 19:45

WillC · Answer 2 · 2020-01-30T05:21:07.767

When you know that you need to serialize from a particular context, you can disable proxy creation for that particular query like below. This has worked for me and is better than revising my model classes.

using (var context = new MeContext())
{
    context.Configuration.ProxyCreationEnabled = false;
    return context.cars.Where(w => w.Brand == "Ferrari")
}

This approach takes away the proxy object type for this particular instance of the context so the returned objects are the actual class and therefore serialization is not a problem.

ie:

{Models.car}

instead of

{System.Data.Entity.DynamicProxies.car_231710A36F27E54BC6CE99BB50E0FE3B6BD4462EC‌A19695CD1BABB79605296EB}

score 10 · Answer 3 · answered Apr 07 '11 at 22:11

10

The problem is that your are actually serializing an entity framework generated proxy object. Unfortunatly this has some issues when used with the JSON serializer. You might consider to map your entities to special simple POCO classes for the sake of JSON compatibility.

answered Apr 07 '11 at 22:11

Christoph

26,519
28
95
133

3

This is correct, you don't need to change your EF entities, just map them to an entity that will only be used by the View. – Ricardo Sanchez Jun 06 '12 at 05:02
This is an elegant enough solution for most cases. – rafasoares Sep 11 '12 at 21:50

score 8 · Answer 4 · answered Oct 09 '11 at 19:36

8

There is an attribute to add to Entity Framework objects

[ScriptIgnore]

This makes the code not perform Circular references.

answered Oct 09 '11 at 19:36

bdparrish

3,216
3
37
58

1

This did not prevent my circular reference problem, BUT is did allow me to remove attributes from the serialization that I didn't want to return in my API. Thanks! – Jimmy Bosse Oct 05 '12 at 15:20

John B · Answer 5 · 2012-04-10T18:38:22.880

I think they have fixed this in the latest version.

Check out the help docs under the section "Serializing and Deserializing JSON -> Serialization and Preserving Object References".

Set this setting when initializing the JSON.Net Serializer:

PreserveReferencesHandling = PreserveReferencesHandling.Objects;

So an example would be this:

var serializerSettings = new JsonSerializerSettings { PreserveReferencesHandling = PreserveReferencesHandling.Objects };

string json = JsonConvert.SerializeObject(people, Formatting.Indented, serializerSettings);

I verified that this works with my code first solution, and a circular reference in the navigation properties. If you look at the resulting JSON it should have "$id" and "$ref" properties everywhere.

Wrote a blog post on the subject: Wrote a blog post on the subject: http://www.johnnycode.com/blog/2012/04/10/serializing-circular-references-with-json-net-and-entity-framework/ — John B, Apr 10 '12 at 18:37

score 6 · Answer 6 · edited Jul 10 '12 at 18:24

6

An alternative solution would be to use anonymous types as the result of a LINQ query.

In my project, I am using lazy loading extensively, and disabling it was not the right thing to do.

edited Jul 10 '12 at 18:24

p.campbell

98,673
67
256
322

answered Mar 18 '12 at 11:03

abdelkarim

586
6
11

score 3 · Answer 7 · answered Sep 02 '13 at 03:34

An alternative solution, if only some values from objects are necessary, is build an anonymous class and return it, like the example below:

public JsonResult AjaxFindByName(string term)
{
    var customers = context.Customers
        .Where(c => c.Name.ToUpper().Contains(term.ToUpper())).Take(10)
        .AsEnumerable()
        .Select(c => new { 
            value = c.Name, 
            SSN = String.Format(@"{0:000\-00\-0000}", c.SSN),
            CustomerID = c.CustomerID });

    return Json(customers, JsonRequestBehavior.AllowGet);
}

Useful suggestion. I am setting navigational properties (that are cyclic) to null before setting the return value of the ASP.Net Web Api method. — nzsai, Jan 20 '20 at 07:54

score 2 · Answer 8 · answered Mar 04 '14 at 11:36

The circular reference happens because you use eager loading on the object.

You have a couple of methods:

Turn off eager loading when your loading your Query (linq or lambda) DbContext.Configuration.ProxyCreationEnabled = false;
Remove the virtual keyword from the Domainmodel
Detach the objects (= no eager loading functionality & no proxy)
- Repository.Detach(entityObject)
- DbContext.Entry(entityObject).EntityState = EntityState.Detached
Clone the properties
- You could use something like AutoMapper to clone the object, don't use the ICloneable interface, because it also clones the ProxyProperties in the object, so that won't work.
In case you are building an API, try using a separte project with a different configuration (that doesn't return proxies)

PS. Proxies is the object that's created by EF when you load it from the Entity Framework. In short: It means that it holds the original values and updated values so they can be updated later. It handles other things to ;-)

score 0 · Answer 9 · edited Sep 30 '12 at 21:07

0

You can remove the virtual keyword:

public virtual Patient Patient { get; set; } -> public Patient Patient { get; set; }

Keep in mind that when you remove the virtual keyword, lazy loading will be turned off.

edited Sep 30 '12 at 21:07

Jack

10,943
13
50
65

answered Aug 18 '12 at 05:49

Reza Abolfathi

3,061
2
18
14

score 0 · Answer 10 · answered May 22 '13 at 17:23

0

I was able to solve this problem by using the method described here:

http://mytechworld.officeacuity.com/index.php/2010/02/serializing-entity-framework-objects-into-json-using-asp-net-mvc/

answered May 22 '13 at 17:23

steveareeno

1,925
5
39
59

1

Link is dead. This is why it is frowned upon to do link-only answers. You should always quote/re-iterate the important parts of the link. – Shelby115 Sep 22 '15 at 18:37

score 0 · Answer 11 · answered Feb 23 '12 at 12:06

For those using the proxy EF/Linq2SQL classes my solution was to simply remove the parent reference on my child entities.

So in my model, I selected the relationship and changed the Parent reference to be Internal rather than Public.

May not be an ideal solution for all, but worked for me.

EF 4.1 - Code First - JSON Circular Reference Serialization Error

11 Answers11

Linked