How should I disable Entity Framework table refren

Question

I'm using Sqlite database and System.Data.SQLite 1.0.92 There is 2 table here:

---

Table Person:

PersonId

PersonName

---

Table Student:

StudentId

PersonId(reference table Person FK)

StudentNo

---

Now every time I get the Persons Collection in EF5:

using (var ctx = new myEntities)
{
  AllPersons = ctx.Persons.ToList();
}

There is also has AllPersons.student collection will include in the result;

But I don't need it. Of course that's just an example, There is a lot of big table has so many references, it always has performance problems here because of that.

So I'm trying to do not let it in my result. So I change it:

using (var ctx = new myEntities)
{
      ctx.Configuration.ProxyCreationEnabled = false;
      ctx.Configuration.LazyLoadingEnabled = false;
      AllPersons= ctx.Persons.ToList();
}

Now fine, because AllPersons.student collection will always be null

But now I found: If I get Person and Student together:

using (var ctx = new myEntities)
{
    ctx.Configuration.ProxyCreationEnabled = false;
    ctx.Configuration.LazyLoadingEnabled = false;
    AllPersons= ctx.Persons.ToList();
    AllStudents = ctx.Student.ToList();
}

Now the reference still include in.

So Is there anyway to don't let the reference include in any time in this situation? Thank you.

---

Update

For some friends request, I explain why I need it:

1: When I convert it to json it will be a dead loop. even I already use Json.net ReferenceLoopHandling, the json size very big to crash the server.(if no references, it's just a very small json)

2:Every time I get the client data and need to save, it will display exception about model state, until I set it to null.

Example:

using (myEntities ctx = new myEntities())
 {
 ctx.Configuration.LazyLoadingEnabled = false;
 ctx.Configuration.ProxyCreationEnabled = false;



  Person model= ThisIsAModel();

  model.students = null;  // This is a key, I need set the students collection references to null , otherwise it will throw exception

  ctx.Entry(model).State = EntityState.Modified;
  ctx.SaveChanges();

}

3: This is More important problem. I already get all data and cache on the server. But It will let the loading time very long when server start. (because the data and references are so many, that is the main problem), I don't know I'll meet what kind of problem again....

public List<Person> PersonsCache; // global cache
public List<Student> StudentsCache; // global cache
using (myEntities ctx = new myEntities())
 {
     ctx.Configuration.LazyLoadingEnabled = false;
     ctx.Configuration.ProxyCreationEnabled = false;
 // There is so many references and data, will let it very slow , when I first time get the all cache. even I only get the Person model, not other , just because some Collection has some references problem. It will very slow....

   PersonsCache = ctx.Persons.ToList();
   StudentsCache= ctx.Student.ToList();
}

Answer 1

Is there anyway to don't let the reference include in any time in this situation?

The solution to this seems to be very simple: don't map the association. Remove the Student collection. Not much more I can say about it.

Answer 2

The Problem

As you said, when you load both of Parent and Child lists even when LazyLoading is disabled, and then look in parent.Childs you see child items has been loaded too.

var db = new YourDbContext();
db.Configuration.LazyLoadingEnabled = false;
var parentList= db.YourParentSet.ToList();
var childList= db.YourChildSet.ToList();

---

What happened? Why childs are included in a parent?

The childs under a parent entity, are those you loaded using db.YourChildSet.ToList(); Exactly themselves; In fact Entity Framework never loads childs for a parent again but because of relation between parent and child in edmx, they are listed there.

---

Is that affect Perforemance?

According to the fact that childs only load once, It has no impact on perforemance because of loading data.

---

But for serialization or something else's sake, How can I get rid of it?

you can use these solutions:

Solution 1:

Use 2 different instance of YourDbContext:

var db1 = new YourDbContext();
db1.Configuration.LazyLoadingEnabled = false;
var parentList= db.YourParentSet.ToList();

var db2 = new YourDbContext();
db2.Configuration.LazyLoadingEnabled = false;
var childList= db.YourChildSet.ToList();

• Now when you look in parent.Childs there is no Child in it.

Solution 2:

use Projection and shape your output to your will and use them.

var db1 = new YourDbContext();
db1.Configuration.LazyLoadingEnabled = false;
var parentList= db.YourParentSet
                  .Select(x=>new /*Model()*/{
                      Property1=x.Property1,
                      Property2=x.Property2, ...
                  }).ToList();

• This way when serialization there is nothing annoying there.
• Using a custom Model class is optional and in some cases is recommended.

---

Additional Resources

As a developer who use Entity Framework reading these resources is strongly recommended:

• Performance Considerations for Entity Framework 4, 5, and 6
• Connection Management

Answer 3

Explicitly select what you want to return from the Database.

Use Select new. With the select new clause, you can create new objects of an anonymous type as the result of a query and don't let the reference include in. This syntax allows you to construct anonymous data structures. These are created as they are evaluated (lazily). Like this:

using (var ctx = new myEntities())
{
     var AllPersons = ctx.People.Select(c => new {c.PersonId, c.PersonName}).ToList();
}

And even you don't need to disable lazy loading anymore.

After running query above:

This query currently allocates an anonymous type using select new { }, which requires you to use var. If you want allocate a known type, add it to your select clause:

private IEnumerable<MyClass> AllPersons;//global variable

using (var ctx = new myEntities())
{
     AllPersons = ctx.People
         .Select(c => new MyClass { PersonId = c.PersonId, PersonName = c.PersonName }).ToList();
}

And:

public class MyClass
{
    public string PersonId { get; set; }
    public string PersonName { get; set; }
}

Answer 4

If I understand you correctly, you're just trying to make sure you only get what you specifically ask for right?

This was mentioned a little above, but to do this correctly you just want to select an anonymous type.

var students = from s in _context.Students
               select new{
               StudentId,
               StudentNo};

Then, when you want to update this collection/object, I'd recommend use GraphDiff. GraphDiff really helps with the problems of disconnected entities and updates (https://github.com/refactorthis/GraphDiff)

So your method would look similar to this:

void UpdateStudent(Student student){
   _context.UpdateGraph(student, map =>
                    map
                        .AssociatedEntity(c => c.Person));
_context.SaveChanges();
}

This way, you're able to update whatever properties on an object, disconnected or not, and not worry about the association.

This is assuming that you correctly mapped your entities, and honestly, I find it easier to declare the object as a property, not just the ID, and use a mapping file to map it correctly.

So:

class Person{
int Id{get;set;}
string Name{get;set}
}

class Student{
int Id{get;set;}
string StudentNo{get;set;}
Person Person{get;set;}

public class StudentMap : EntityTypeConfiguration<Student>
    {
        public StudentMap()
        {
            // Primary Key
            HasKey(t => t.Id);


            // Table & Column Mappings
            ToTable("Students");
            Property(t => t.Id).HasColumnName("StudentId");

           // Relationships
            HasRequired(t => t.Person)                
                .HasForeignKey(d => d.PersonId);
  }
}

Hopefully that makes sense. You don't need to create a view model, but you definitely can. This way does make it easier to map disconnected items back to the database though.

Answer 5

In normally your student collection doesn't fill from database. it's fill when you reach to property. In addition if you use ToList() method so Entity Framework read data from data to fill your collection.

Pls check this. https://msdn.microsoft.com/en-us/data/jj574232.aspx#lazy https://msdn.microsoft.com/en-us/library/vstudio/dd456846(v=vs.100).aspx

Answer 6

Decorate any properties with [IgnoreDataMember] if you are using 4.5+

https://msdn.microsoft.com/en-us/library/system.runtime.serialization.ignoredatamemberattribute(v=vs.110).aspx

Also sounds like you are trying to do table inheritance which is a different problem with EF

http://www.asp.net/mvc/overview/getting-started/getting-started-with-ef-using-mvc/implementing-inheritance-with-the-entity-framework-in-an-asp-net-mvc-application

http://www.entityframeworktutorial.net/code-first/inheritance-strategy-in-code-first.aspx