Create a left join query without navigation property - entity-framework

Question

I would achieve this goal using EFCore method syntax
Given an user retrieve all roles and set IsInRole = 1 if the given user has the role, otherwise 0
in tsql is something like
CREATE TABLE USER(USERNAME VARCHAR(200) PRIMARY KEY);
CREATE TABLE ROLE(ROLENAME VARCHAR(200) PRIMARY KEY);
CREATE TABLE USERROLE(USERNAME VARCHAR(200), ROLENAME VARCHAR(200));
INSERT INTO USER VALUES('LELU');
INSERT INTO ROLE VALUES('ROLE1');
INSERT INTO ROLE VALUES('ROLE2');
INSERT INTO USERROLE VALUES('LELU', 'ROLE1');
SELECT R.ROLENAME, CASE WHEN T.ROLEID IS NULL THEN 0 ELSE 1 END ISINROLE
FROM ROLE R
LEFT JOIN (
SELECT UR.ROLENAME ROLEID
FROM USERROLE UR
WHERE UR.USERNAME='LELU'
) T ON T.ROLEID=R.ROLENAME
ROLENAME ISINROLE
-------------------------------------
ROLE1 1
ROLE2 0
I would like to achive this goal using EF core without navigation properties.
I have the following entities
public class User
{
[Key]
public string Username {get; set;}
}
public class Role
{
[Key]
public string Rolename {get; set;}
}
public class UserRole
{
public string Username {get; set;}
public string Rolename {get; set;}
}
where UserRole (Username, Rolename) are primary keys
public class MyDbContext : DbContext
{
public DbSet<User> Users {get; set;}
public DbSet<Role> Roles {get; set;}
public DbSet<UserRole> UsersRoles {get; set;}
...
}
I do some research online but i didn't find anything that can accomplish a left join without navigation properties.
How can I achive this goal without using navigation property neither injecting raw query in EFCore?

Answer 1

It is possible without navigation properties. It's not pretty by any stretch and depending on what details you want from the associated entities it will get a lot uglier. However, to get a list of Roles with a flag for whether the provided user is assigned to them or not:
using (var context = new MyDbContext())
{
var roles = context.Roles
.SelectMany(r => context.UserRoles.Where(ur => ur.RoleName == r.RoleName
&& ur.UserName == userName).DefaultIfEmpty(),
(r, ur) => new
{
RoleName = r.RoleName,
IsInRole = ur != null
}).ToList();
}
That would return each role, and whether the provided userName value was assigned to that role using a Left join via the DefaultIfEmpty().

Answer 2

Although LINQ query syntax is generally disliked, I believe it fits the scenario of joining entities without navigation properties very nicely.
var query =
from role in context.Roles
join userRole in context.UserRoles on userRole.RoleName equals role.RoleName
select new
{
...
};
Albeit the left join is not as nice.
var query =
from role in context.Roles
join userRole in context.UserRoles on userRole.RoleName equals role.RoleName into ur
from userRole in ur.DefaultIfEmpty()
select new
{
RoleName = role.RoleName,
IsInRole = userRole != null
};
As a bonus, in case you need to do multiple joins, with LINQ query syntax you only have to add a single additional line describing the join.