The difference between a LINQ to entity left join right connection and an inner join notation

What's the difference between a LINQ to entity left-connected right connection and an inner join notation, and how to write with a lambda expression, which is more efficient?

[Workaround]
Left join right or connected this actually you don't need to care. Just write the query based on the mapping of the entity, and the framework will automatically help you build it.
As for the efficiency of LINQ query syntax and extension methods, it should be the same, for example:

C # code

var users= (from U in db. Users where u.userroleid==1 select u). ToList (); var users2=db. Users.where (u=>u.userroleid==1). ToList ();
[Workaround]
INNER JOIN:
var =from x in db. T1
     Join Y in db. T2
     On X.yid equals y.id
     Select X;

Left JOIN:

var =from x in db. T1
     Join Y in db. T2
     On X.yid equals y.id into Temp
     From Y in temp. Defalutifempty ()
     Select New{x.id,name=y==null? ": Y.name};

Right join principle with LEFT Join

As for efficiency, LAMDA expressions are the same as standard expressions
[Workaround]
A LINQ expression is a lambda expression that, for a database, translates to SQL running on the database side, so it's as efficient.
[Workaround]
Take a look at the sixth article.

And a friend upstairs, LINQ to EF, with from-   x in temp. Defalutifempty () is not a hundred percent execution left connected

LINQ to entity left join right joins and differences in inner joins (go)