How to avoid circular loop in Linq to Sql query?

Question

Currently I am using [JsonIgnore] property to avoid circular references in the models. But I think, it will be applied in all implementations.

Right now I am using like this-

I have two Models:

public class Project
{
    public int ProjectID { get; set; }

    [Required]
    public string ProjectName { get; set; }

    public DateTime? EstimatedEndDate { get; set; }
    public DateTime? ProjectStartDate { get; set; }
    public string OrderNumber { get; set; }

    public string ProjectDescription { get; set; }
    public virtual List<ServiceObject> ServiceObjects { get; set; }

    [Required]
    public string RegardingUser { get; set; }

    public string CreatedBy { get; set; }
    public DateTime CreatedDate { get; set; }
    public string ModifiedBy { get; set; }
    public DateTime ModifiedDate { get; set; }
    public bool IsProjectDeleted { get; set; }
    [NotMapped]
    public int? ServiceObjectTemplateID { get; set; }

}

One another Model is-

public class ServiceObject
{
    public int ServiceObjectID { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public string RegardingUser { get; set; }
    public int? ParentServiceObjectID { get; set; }
    [ForeignKey("ParentServiceObjectID")]
    public virtual List<ServiceObject> ServiceObjects { get; set; }
    public int ProjectID { get; set; }
    [JsonIgnore]
    public virtual Project Project { get; set; }<--------------------------- 
    public virtual List<ServicePicture> ServicePictures { get; set; }
    public bool IsServiceObjectDeleted { get; set; }
    public string CreatedBy { get; set; }
    public DateTime CreatedDate { get; set; }
    public string ModifiedBy { get; set; }
    public DateTime ModifiedDate { get; set; }
}

But I want to apply JsonIgnore property or any other property In Linq to Sql query itself. I mean I want to apply it dynamically.

The Query is like-

var projectList = (from pro in context.Projects.All
                   select pro).ToList();

I want to apply conditionally.

Thanks in advance.

Attributes must be applied at compile time, so you can't add them dynamically. — TGH, Oct 10 '14 at 04:13
Yes you have to apply them to your properties at compile time. — TGH, Oct 10 '14 at 04:16
Your problem has NOTHING to do with Linq-to-SQL and everything to do with Json.Net — Aron, Oct 10 '14 at 05:55
@Aron: Its not. Which is why I'm asking. Often, it is better to understand the problem before building the solution. I have a feeling what the OP is asking is not his real problem. — Mrchief, Oct 10 '14 at 06:03
@Mrchief The problem should be serialization and nothing to do with the DAL (separation of concern and least surprise). This should be solved with Json.Net and not with LinqToSQL. — Aron, Oct 10 '14 at 06:07

Aron · Answer 1 · 2014-10-10T06:09:42.020

XY problem. Your actual problem is "I want to control at runtime what properties get serialized".

The most common method of controlling what properties are serialized is using the JsonIgnoreAttribute. However as others have commented, attributes are applied at compile time, and cannot normally be modified at runtime (nor would you want to, since it would in effect be a global setting being changed at runtime, you would run into a ton of Threading issues).

Instead, the answer is to use the IContractResolver interface to change the serialization behavior.

public class OmitPropertyContractResolver
       : IContractResolver
{
    private readonly string[] _ignoredProperties;
    private readonly IContractResolver _resolver;

    public OmitPropertyContractResolver(IContractResolver resolver, params string[] ignoredProperties)
    {
        _ignoredProperties = ignoredProperties;
        _resolver = resolver;        
    }
    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        var properties = _resolver.CreateProperties(type, memberSerialization);
        return properties
               .Where(p => _ignoredProperties.Contains(p.Name) == false)
               .ToList();
    }
}

The other possibility is to use ReferenceLoopHandling setting in your Json.net settings.

var serializer = new JsonSerializer(
                      new JsonSerializerSetting()
                               { 
                                   ReferenceLoopHandling = ReferenceLoopHandling.Ignore 
                               } );

This will serialize each object only once.

The last option is to use ItemReferenceLoopHandling. This is a non-standard way of serializing (and deserializing) Object-Graphs (note, graph and not tree) which have circular references.

The disadvantage of this method is that it is non-standard, and might not work on the client end.

Hmm... Actually my application is client side application completely. — Abhinav, Oct 10 '14 at 09:04

score 1 · Accepted Answer · answered Oct 10 '14 at 14:46

Ok, so based on your inputs and as I suspected, what you're seeing is a typical EF Code First issue. EF generates dynamic proxies for each of your entity so that it can track changes to it. However, this makes serialization difficult since they are created as dynamic objects. There are few ways to avoid this:

Option A: Disable proxy creation just for the particular query:

// disable proxy creation just for the duration of query
context.Configuration.ProxyCreationEnabled = false;

// do the query, serialize, go crazy!

// enable proxy again. or if your context goes out of scope after this call, then you can ignore re-enabling.
context.Configuration.ProxyCreationEnabled = true;

Option B: If you are not going to modify and update the entity at some later point

var entity = context.Where(...);  // or whatever query

// detach entity
context.Entry(entity).State = EntityState.Detached;

Option C: Avoid proxies by modifying type definition:

If you create sealed type or type without virtual properties, EF will not create a proxy since there is nothing for the proxy to do.

public sealed class Project {...}

// or make it non virtual
...
public List<ServiceObject> ServiceObjects { get; set; }
...

Note that in this case, you have to load related objects manually:

context.Projects.Include(p => p.ServiceObjects).ToList();

Option D: Disable proxy creation permanently:

// in your initializer or DbContext class' constructor
DbContext.Configuration.ProxyCreationEnabled = false;

Note: If proxy creation is disabled, EF will not tracked changes automatically. You can manually track them using the Snapshot method.

You can follow one or more of these options depending on your design. I usually stick with option A or B.

Thank you for giving me several solutions. All the solutions were good. I hope all these ways are standard ways. :) — Abhinav, Oct 11 '14 at 03:07
These are all the officially documented ways that I know of. — Mrchief, Oct 11 '14 at 13:37
I think `ProxyCreationEnabled ` is for Entity Framework only and not Linq to SQL, the questioner is asking about Linq to SQL — Luke T O'Brien, Oct 11 '17 at 13:34
@LukeTO'Brien I confirmed with OP about EF. Check comments on the question itself. — Mrchief, Oct 12 '17 at 12:32

How to avoid circular loop in Linq to Sql query?

2 Answers2