C#•2y ago

EF6 Relationships

I have two classes built in EF Core, that I used to scaffold the database and use in the frontend Blazor app.

c#
  public class StreamPointListenerStep {
    public Guid Id { get; set; } = Guid.NewGuid();
    //....
    public StreamPointIntegrationELogger? StreamPointIntegrationELogger { get; set; } = null;
  }

  public class StreamPointIntegrationELogger {
    public Guid Id { get; set; } = Guid.NewGuid();

    [ForeignKey(nameof(StreamPointListenerStep))]
    public Guid StepId { get; set; }
    public StreamPointListenerStep? StreamPointListenerStep { get; set; } = null;
    //...
  }

c#
  public class StreamPointListenerStep {
    public Guid Id { get; set; } = Guid.NewGuid();
    //....
    public StreamPointIntegrationELogger? StreamPointIntegrationELogger { get; set; } = null;
  }

  public class StreamPointIntegrationELogger {
    public Guid Id { get; set; } = Guid.NewGuid();

    [ForeignKey(nameof(StreamPointListenerStep))]
    public Guid StepId { get; set; }
    public StreamPointListenerStep? StreamPointListenerStep { get; set; } = null;
    //...
  }

c#
  public class StreamPointListenerStep {
    public Guid Id { get; set; } = Guid.NewGuid();
    //....
    public StreamPointIntegrationELogger? StreamPointIntegrationELogger { get; set; } = null;
  }

  public class StreamPointIntegrationELogger {
    public Guid Id { get; set; } = Guid.NewGuid();

    [ForeignKey(nameof(StreamPointListenerStep))]
    public Guid StepId { get; set; }
    public StreamPointListenerStep? StreamPointListenerStep { get; set; } = null;
    //...
  }

c#
  public class StreamPointListenerStep {
    public Guid Id { get; set; } = Guid.NewGuid();
    //....
    public StreamPointIntegrationELogger? StreamPointIntegrationELogger { get; set; } = null;
  }

  public class StreamPointIntegrationELogger {
    public Guid Id { get; set; } = Guid.NewGuid();

    [ForeignKey(nameof(StreamPointListenerStep))]
    public Guid StepId { get; set; }
    public StreamPointListenerStep? StreamPointListenerStep { get; set; } = null;
    //...
  }

Now, building and using this in Blazor is fine. However, I also need the table in a .NET Framework app. So I've ported the DB model to EF6 just to simply use the context for accessing the database and the models without writing the queries manually. However, EF6 refuses to work with this due to the relationship. It throws an error for

Because the Dependent Role properties are not the key properties, the upper bound of the multiplicity of the Dependent Role must be '*'.

Because the Dependent Role properties are not the key properties, the upper bound of the multiplicity of the Dependent Role must be '*'.

Because the Dependent Role properties are not the key properties, the upper bound of the multiplicity of the Dependent Role must be '*'.

Because the Dependent Role properties are not the key properties, the upper bound of the multiplicity of the Dependent Role must be '*'.

What solutions are there for getting around this? I have to use .NET Framework, and building an API is overhead that's just not needed.

deprecatio•2/24/24, 9:32 PM

if StreamPointIntegrationELogger contains a StreamPointListenerStep then shouldn't StreamPointIntegrationELogger field be an inverse property?

engineertdogOP•2/24/24, 9:33 PM

No, the step contains the ELogger

engineertdogOP•2/24/24, 9:35 PM

I previously had the ELogger ID on the Step, but that caused a FK in both tables which didn't make sense. Thinking about it, the ID should be on Step, and no ID on ELogger. It should be 1-1, so that should fix that then

deprecatio•2/24/24, 9:36 PM

it depends in which direction you need the relationship

engineertdogOP•2/24/24, 9:37 PM

A Step has an IntegrationElogger. Step->ELogger, it can't be the other way around

engineertdogOP•2/24/24, 9:37 PM

And I don't see there being a need to re-share the ELogger, so it should only be 1-1

deprecatio•2/24/24, 9:41 PM

from a technical point of view you place the fk where you want, right? it's more of a matter of what is the meaning of it
if you have the fk in the Step then every time you add an "extension" class you have to add an fk column in that class, which means modifying it
if you keep the fk in the ELogger class then you don't need to change Step
just as an example, there are other cases

engineertdogOP•2/24/24, 9:41 PM

Yeah, the FK needs to be on Step

engineertdogOP•2/24/24, 9:41 PM

And that resolved that issue, but now there's a new one I haven't seen before

engineertdogOP•2/24/24, 9:42 PM

DbComparisonExpression requires arguments with comparable types.DbComparisonExpression requires arguments with comparable types. trying to see if it actually gives something useful

engineertdogOP•2/24/24, 9:44 PM

Nevermind, I was trying to send a string as the Guid

deprecatio•2/24/24, 9:44 PM

if it's a 1-1 it could even be an owned type

engineertdogOP•2/24/24, 11:06 PM

One other question if you're still able to help. I want eager loading....but only for properties I specifically tell it to load. I don't understand why they build the system this way

engineertdogOP•2/24/24, 11:06 PM

c#
      return await dbContext.StreamPointListeners
        .Include(s => s.PiCollectivePoint)
          .ThenInclude(p => p.PiCollective)
        .ToListAsync();

c#
      return await dbContext.StreamPointListeners
        .Include(s => s.PiCollectivePoint)
          .ThenInclude(p => p.PiCollective)
        .ToListAsync();

engineertdogOP•2/24/24, 11:07 PM

That causes this property PointsPoints on PiCollectivePiCollective to be loaded automatically. I don't want that, nor did I specify it. So why in the world is EF loading it?

c#
public IList<PiCollectivePoint> Points { get; set; } = new List<PiCollectivePoint>();

c#
public IList<PiCollectivePoint> Points { get; set; } = new List<PiCollectivePoint>();

tera•2/24/24, 11:42 PM

if you specified .ThenInclude(p => p.PiCollective).ThenInclude(p => p.PiCollective) then it will load all of PiCollectivePiCollective's properties. hard to tell what's what without the model.
BUT, you should most likely be creating a DTO here since i see you're returning the result somewhere. So project your result to a DTO (.Select(x => new DTO{...} .Select(x => new DTO{...} before ToListAsync) and then you don't have to worry about including values.

engineertdogOP•2/24/24, 11:42 PM

Yeah, I get the DTO approach. It's just a stupid way to design the system - creating more work for no reason because the tooling isn't sufficient.

engineertdogOP•2/24/24, 11:43 PM

I'll be able to get around this particular problem by not doing the ThenInclude, and pulling the data ref another, more efficient way. But it's something I'll need to consider.

tera•2/25/24, 12:13 AM

its usually not a good idea to pass around entities directly anyway. keep them next to the dbcontext they are pulled (tracked) from.. then you cant end up adding them to a different dbcontext or something. keeps your data flow sane.
and creating a dto these days is as simple as record Whatever(...)record Whatever(...)

not much work

engineertdogOP•2/25/24, 12:22 AM

I despise entity tracking and turn that crap off anyway

Eengineertdog Yeah, I get the DTO approach. It's just a stupid way to design the system - crea...

Nox•2/25/24, 5:09 AM

It's not a stupid way to design the system, I don't get what you're talking about

Eengineertdog That causes this property `Points` on `PiCollective` to be loaded automatically....

Nox•2/25/24, 5:09 AM

You're starting from X, loading Y, and then loading Z

Nox•2/25/24, 5:10 AM

And you're complaining that loading Z loads Y?

engineertdogOP•2/25/24, 5:10 AM

No, I'm starting from X and loading X. If I want Y, I'll tell EF I want Y, otherwise I don't want it.

Nox•2/25/24, 5:10 AM

That's exactly what you're saying with IncludeInclude

engineertdogOP•2/25/24, 5:10 AM

No, because it's including things that I'm not telling it to include.

Nox•2/25/24, 5:10 AM

Like what?

Nox•2/25/24, 5:11 AM

If I have LibraryLibrary with BookBooks and AuthorAuthors on each books, and I say ctx.Libraries.Include(x => x.Books).ThenInclude(x => x.Authors)ctx.Libraries.Include(x => x.Books).ThenInclude(x => x.Authors), the collection BooksBooks will be populated on the AuthorAuthor

engineertdogOP•2/25/24, 5:12 AM

So given that example above, that .ThenInclude.ThenInclude causes a recursive loop (due to the properties which I'll show). If I wanted an endless loop, I would have told it to give it to me.

Nox•2/25/24, 5:12 AM

No.

Nox•2/25/24, 5:12 AM

It's not endless.

Nox•2/25/24, 5:12 AM

The entities already loaded by the context will be populated.

engineertdogOP•2/25/24, 5:13 AM

c#
      return await dbContext.StreamPointListeners
        .Include(s => s.PiCollectivePoint)
          .ThenInclude(p => p.PiCollective)
        .ToListAsync();

c#
      return await dbContext.StreamPointListeners
        .Include(s => s.PiCollectivePoint)
          .ThenInclude(p => p.PiCollective)
        .ToListAsync();

Given this code, it is called once. It will return a loop of PiCollective with Points which then contain the Collective which then contains the points. I only want 1 level of depth (the depth of which I have explicitly stated)

Nox•2/25/24, 5:14 AM

There is only one level of depth.

engineertdogOP•2/25/24, 5:14 AM

No, there isn't lol

Nox•2/25/24, 5:14 AM

Only one level will be loaded.

engineertdogOP•2/25/24, 5:14 AM

Nope.

engineertdogOP•2/25/24, 5:14 AM

That's why I had to remove the ThenInclude, or tell the JSON parser to ignore recursive loops.

Nox•2/25/24, 5:15 AM

Well, all of the levels which are possible with PiCollectivePointPiCollectivePoint will be loaded

Nox•2/25/24, 5:15 AM

Uhhh

engineertdogOP•2/25/24, 5:15 AM

Which is stupid. If I wanted that, I would include that in my query.

Nox•2/25/24, 5:15 AM

Nox•2/25/24, 5:15 AM

Your first mistake is JSON Serializing DB entities

Nox•2/25/24, 5:15 AM

Your second mistake is assuming there are multiple levels

Nox•2/25/24, 5:15 AM

There only needs to be one level for that issue to occur.

engineertdogOP•2/25/24, 5:15 AM

I'm not assuming. It's literally in the debugger when you view the results.

engineertdogOP•2/25/24, 5:16 AM

c#
public class PiCollectivePoint : IPiCollectivePoint {
  //....
  public Guid PiCollectiveId { get; set; }
  public PiCollective? PiCollective { get; set; } = null;
}

public class PiCollective : IPiCollective {
  //...
  public IList<PiCollectivePoint> Points { get; set; } = new List<PiCollectivePoint>();

c#
public class PiCollectivePoint : IPiCollectivePoint {
  //....
  public Guid PiCollectiveId { get; set; }
  public PiCollective? PiCollective { get; set; } = null;
}

public class PiCollective : IPiCollective {
  //...
  public IList<PiCollectivePoint> Points { get; set; } = new List<PiCollectivePoint>();

Nox•2/25/24, 5:16 AM

var book = ctx.Books.Include(x => x.Author).First()var book = ctx.Books.Include(x => x.Author).First()

This will load one book.
book.Authorbook.Author

this is populated
book.Author.Books.First()book.Author.Books.First()
- this is populated
  book.Author.Books.First().Authorbook.Author.Books.First().Author
  - this is populated

engineertdogOP•2/25/24, 5:16 AM

When I use that .ThenInclude.ThenInclude, it populates PointsPoints

which I don't ask for, which then populates Points, which populates the Collective, which gets the Points again.

Nox•2/25/24, 5:17 AM

It's fulfilling relational navigation on the entities.

EF6 Relationships

Similar Threads

Similar Threads

Similar Threads