C# and .NET Core Appreciation Post. The most beautiful piece of code I have ever seen... this month!

I hate C# LINQ query syntax. It is completely pointless. You can always use LINQ methods directly.

This is a warning to anyone who thinks it's cool.

• It gives you nothing. It's not shorter, it's not more readable, it's not faster... It's actually harder to refactor and maintain.

• I used to love them at first: they look so cool, right? Well, I've been using C# for many, many years, and the experience has always converged to: avoid them, you will regret the temptation. - Use lambdas directly instead: Lambdas are great.

• Nice simple example: Often, you need to split the query into 2 places: super simple with normal syntax: you just copy part of it elsewhere, keeping it as IEnumerable/IQueryable. - With LINQ syntax, you now have to figure out how to split the nonlinear query, the beginning and end is always repeated, you have to type them over..... Zero added value, only problems. After all, its design was inspired by the ergonomically ~worst language: SQL. (I admit, this is opinionated; what I say about LINQ syntax: not so much)

• Most importantly: Not all LINQ/extension methods have LINQ syntax, so now you have to mix it, and it's completely horrible.

• Also, it has nothing to do with .NET Core: It's been in C# since before 2008.

btw. Don't get me wrong: LINQ extension methods are great... except, for no good reason, C# decided to call all the methods differently than every language ever - but the LINQ syntax was 100% a mistake.

Here is your example written using an async method and lambda expression syntax:

private async Task<User> GetUserByTokenAsync(string token) => await _context.Users
.Join(_context.Tokens.Where(t => t.Body == token), u => u.Id, t => t.UserId, (u, t) => u)
.SingleOrDefaultAsync();

Note: you will need to include additional namespaces for the async extension methods on IQueryable<> and for Task<>

Great! Now try lambda expression, you will be happier:)

I will add my voice to the others here who recommend avoiding LINQ syntax. Most MS development shops have gotten away from LINQ syntax and your query shows one good reason:

It might be more efficient for the where to execute before the join. With the LINQ syntax you can do it but it looks odd.

var user = (from t in _context.Tokens
    where t.Body == token
    join u in _context.Users
        on t.UserId equals u.Id
    select u).SingleOrDefault();

Now compare:

var user = _context
    .Tokens
    .Where(t => t.Body == token)
    .Join(
        _context.Users,
        t => t.UserId,
        u => u.Id,
        (t, u) => u)
    .SingleOrDefault();

For your specific case, I suggest you turn _context.Tokens into an IDictionary<string, Token> or even IDictionary<string, User> where the token body is the key. Then your method looks like this:

#nullable disable
private User GetUserByToken(string token)
    => _context.UsersByToken.TryGetValue(token, out var user)
    ? user
    : default;
#nullable restore

You shouldn't use the join keyword, a second "from" is best:

i) you get to use the equality operator;
ii) you can arrange the operands any way you like;
iii) you can add on the DefaultIfEmpty() function on the end to change to a left join and vice versa.

private User GetUserByToken(string token)
{
    var user = (from u in _context.Users
        from t in _context.Tokens.Where(T => t.UserId == u.Id)
        where t.Body == token
        select u).SingleOrDefault();

    return user;
}

Also, I always use the LINQ format instead of chained functions. Simply because it's more readable.

Yeah... LINQ is solid stuff. Had a dev on my team give the same reaction a few weeks back.

Now if you want it to run 10 times faster, drop entity framework and use dapper

The next step up from this is to combine this with webapi odata, that way the framework generated this sort of linq expression for you from a URL.

The irony here is the discovery .net core 3 and the EF core libs that make this possible are right now in a worse state than the ef6 and .net 4.x stuff regular .net people just migrated from.

Give it a couple years though and this will be special under .net 5 when you start notice it's literally write once, run anywhere.

LINQ, like SQL, is declarative.

I felt it bro, C# is easy and beautiful