Entity Framework one-to-one relationships

Question

I'm having some issues with understanding how to property set up one-to-one relationships for a Web API using Entity Framework Core.

Consider the following objects:

public class Car
{  
    [JsonIgnore]
    public Int32 CarId { get; set; }

    public virtual Horn Horn { get; set; }
    public virtual ICollection<Wheel> Wheels { get; set; }
}

public class Horn
{
    [JsonIgnore]
    public Int32 HornId { get; set; }
    public Sound Sound { get; set; }
}

public class Sound
{
    // some other props
}

When I perform a query in my repository, one-to-many is by default excluded unless I use .Include(), however, for one-to-one properties, they are by default included when I serialize.

e.g. It gets really messy because I query for a car and it returns all it's sub-components in the JSON response.

I can set car.Horn = null, etc, but that seems difficult to maintain for complex objects. I would like it to function like .Include(), but by default be excluded (in case I do want to query the full object).

Edit: Note, this issue is recursive, the car pulls in horn which pulls in sound. On a real world example like a user table, the automatically pulled in data when serialized is huge unless specifically nullifying the child properties.

EDIT2:

Here is an example of a repository call that by default bring back all one-to-one properties:

var group = _context.Car.Include(c => c.Wheels).SingleOrDefault(u => u.CarId == id);

Note the Include works as expected for many-to-one, but this query, even when the Include is removed, will recursively return all child objects that are one-to-one.

It does appear some type of lazy loading is being introduced in EF CORE 2.1

Show your configuration of the entities - are you using complex types, table splitting? — Moho, Oct 03 '17 at 15:14
I am using EF Core, simple entities with relationships on the primary key. — user1854458, Oct 03 '17 at 16:38
It doesn't happen in the latest EFC 2.0. What EFC version are you on? Also you need to provide [mcve]. — Ivan Stoev, Oct 03 '17 at 17:07
Well, according to your EDIT 2, you are using some sort of a prelease EFC 2.1 build. I don't think asking a questions for not released software is correct and just wastes our time. — Ivan Stoev, Oct 03 '17 at 19:30
There's no need to be rude. I never said I was using 2.1 or a pre-release. I am using EF Core 2.0. — user1854458, Oct 03 '17 at 23:34
I'm not trying to be rude. My first comment started with *It doesn't happen in the latest EFC 2.0*. I'm not saying that you don't have an issue, just the issue is not reproducible with the information provided, so you need to provide [mcve]. — Ivan Stoev, Oct 04 '17 at 11:14

Bobo · Answer 1 · 2017-10-03T15:22:42.973

1

This article should give you a hint. https://msdn.microsoft.com/en-us/library/jj574232(v=vs.113).aspx Mainly:

Turn lazy loading off for serialization

Lazy loading and serialization don’t mix well, and if you aren’t careful you can end up querying for your entire database just because lazy loading is enabled. Most serializers work by accessing each property on an instance of a type. Property access triggers lazy loading, so more entities get serialized. On those entities properties are accessed, and even more entities are loaded. It’s a good practice to turn lazy loading off before you serialize an entity. The following sections show how to do this.

EDIT: Here is the way to disable lazy loading for all entities. But note you have to achieve this several way, so check the other options in the article...

public class YourContext : DbContext 
{ 
    public YourContext() 
    { 
        this.Configuration.LazyLoadingEnabled = false; 
    } 
}

edited Oct 03 '17 at 15:22

answered Oct 03 '17 at 15:17

Bobo

335
2
10

This isn't really an answer. Show how you turn it off and then it could be a valid answer. – Mark C. Oct 03 '17 at 15:19
Lazy loading is not supported in EF Core – Aistis Taraskevicius Oct 03 '17 at 15:22
Yes, this would be valid only for classic EF – Bobo Oct 03 '17 at 15:32
It's too bad this doesn't work in EF Core - this is similar to what I'm looking for. This problem becomes much worse when it's a larger table with many one-to-one tables, such as a "user" table. Unless nullified, even the child tables bring in the one-to-one child relationships off those tables, so it's recursive!! – user1854458 Oct 03 '17 at 16:43

score 0 · Answer 2 · answered Oct 03 '17 at 15:27

Context mapping

   modelBuilder.Entity<SessionFeedbackModel>(entity =>
        {
            entity.HasOne(s => s.Session).WithOne(p => p.Feedback)
                .HasForeignKey<SessionFeedbackModel>(s => s.SessionId).OnDelete(DeleteBehavior.Restrict);
        });

        modelBuilder.Entity<SessionQuestionModel>(entity =>
        {
            entity.HasOne(e => e.SessionResult).WithOne(e => e.SessionQuestion)
                .HasForeignKey<SessionQuestionResultModel>(e => e.SessionQuestionId)
                .OnDelete(DeleteBehavior.Restrict);

        });

Models

   public class SessionQuestionResultModel
    {
        public int Id { get; set; }

        public int SessionQuestionId { get; set; }

        public SessionQuestionModel SessionQuestion { get; set; }
    }


    public class SessionFeedbackModel
    {
        public int Id { get; set; }
        public int SessionId { get; set; }

        public SessionModel Session { get; set; }

    }

EF Core 1.x or 2.x does not support 1 to 1 very well or at all, but it can be done this way, this would be radically different for EF 6.x.x

Entity Framework one-to-one relationships

2 Answers2