Proposal: Expression Members

[Shiney]

Summary

Allow methods and properties to be usefully used in API's that take expression trees

Motivation

API's such as LINQ to entities use expression trees to convert C# code into queries on a remote database. However this can often lead to repeated code when using objects that have, properties that would if called from .NET be abstracted behind a property cannot be when used with API's that take Expression trees.

A specific example:

class Post
{
    public int Id {get; set;}
    public string Author {get;set}
    public string Text{get;set}
    public bool Deleted {get; set;}
    public bool PassedModeration {get;set;}
    public bool Visible => !Deleted && PassedModeration;
}

// if it's in memory it's easy to write this
public IEnumerable<Post> GetVisiblePostsFromMemory() => InMemoryPosts.Where(p => p.Visible);

// but if you have to call out to the database you have to do
public IQueryable<Post> GetVisiblePostsFromDatabase() => DatabasePosts.Where(p => !p.Deleted && p.PassedModeration);
// So that the LINQ provider can know what being Visible means

It would be nice if you could use the Visible property in both to ensure the code can be shared and changes in the way that Visible is defined are reflected in the database queries.

e.g.

public IQueryable<Post> GetVisiblePostsFromDatabase() => DatabasePosts.Where(p => p.Visible);

Proposal

If Visible were instead declared as

    public expr bool Visible => !Deleted && PassedModeration;

Then if the method was called from normal C# code then it would act the same as before however if it is called in a context which generates expression trees then the contents of the property are inlined in the generated expression tree.

[alrz]

Just to mentioned, F# uses an attribute for this [ReflectedDefiniation].

[jveselka]

This could be probably solved with more generall approach if C# allowed annotating expression bodied methods and properties with inlined keyword and they would function more or less like macros. Their every reference would be replaced with their bodies as one of first compiler steps.

[koenbeuk]

With SourceGenerators this is now perfectly possible, 2 projects that are doing this already:
https://github.com/koenbeuk/EntityFrameworkCore.Projectables
and
https://github.com/ClaveConsulting/Expressionify

Both projects are currently tied to EFCore however the same pattern may be used in a more generalized project.

Having source generators in the mix, I don't see a direct need for having the need from the compiler to natively generate Expression Members. I've would suggest we close this issue.