这是IQueryable 从一开始就存在的根本问题，经过这么多年没有开箱即用的解决方案。
问题在于IQueryable 翻译和代码封装/可重用性是相互排斥的。 IQueryable 翻译基于预先的知识，这意味着查询处理器必须能够“看到”实际代码，然后翻译“已知”的方法/属性。但是自定义方法/可计算属性的内容在运行时不可见，因此查询处理器通常会失败，或者在它们支持“客户端评估”的有限情况下（EF Core 仅针对最终预测）它们会生成低效的翻译，从而检索到很多比您的示例中需要的更多数据。
回顾一下，C# 编译器和 BCL 都不能帮助解决这个“核心问题”。一些第 3 方图书馆正试图以不同的程度解决它 - LinqKit、NeinLinq 和类似的。它们的问题在于，它们需要重构现有代码，以调用 AsExpandable()、ToInjectable() 等特殊方法。
最近我发现了一个名为 DelegateDecompiler 的小 gem，它使用另一个名为 Mono.Reflection.Core 的包将方法体反编译为其 lambda 表示。
使用起来非常简单。安装后您需要做的就是用自定义提供的[Computed] 或[Decompile] 属性标记您的自定义方法/计算属性（只要确保您使用表达式样式实现而不是代码块），然后调用Decompile() 或DecompileAsync() IQueryable 链中某处的自定义扩展方法。它不适用于构造函数，但支持所有其他构造。
以你的扩展方法为例：
public static class ItemExtensionMethods
{
[Decompile] // <--
public static MinimalItem MapToMinimalItem(this Item source)
{
return new MinimalItem
{
Id = source.Id,
Property1 = source.Property1
};
}
}
（注意：它支持其他方式来告诉哪些方法要反编译，例如特定类的所有方法/属性等）
现在
ctx.Items.Decompile()
.Select(x => x.MapToMinimalItem())
.ToList();
生产
// SELECT i."Id", i."Property1" FROM "Items" AS i
这种方法（和其他 3rd 方库）的唯一问题是需要调用自定义扩展方法 Decompile，以便使用自定义提供程序包装可查询对象，以便能够预处理最终查询表达式。
如果 EF Core 允许在其 LINQ 查询处理管道中插入自定义查询表达式预处理器，那就太好了，这样就无需在每个查询中调用自定义方法，这很容易被遗忘，而且自定义查询提供程序也不起作用与 AsTracking、AsNoTracking、Include/ThenInclude 等 EF Core 特定的扩展很好，所以它真的应该在它们之后被调用 等等。
目前有一个未解决的问题Please open the query translation pipeline for extension #19748，我试图说服团队添加一种简单的方法来添加表达式预处理器。您可以阅读讨论并投票。
在此之前，这是我的 EF Core 3.1 解决方案：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Query;
using Microsoft.Extensions.DependencyInjection;
namespace Microsoft.EntityFrameworkCore
{
public static partial class CustomDbContextOptionsExtensions
{
public static DbContextOptionsBuilder AddQueryPreprocessor(this DbContextOptionsBuilder optionsBuilder, IQueryPreprocessor processor)
{
var option = optionsBuilder.Options.FindExtension<CustomOptionsExtension>()?.Clone() ?? new CustomOptionsExtension();
if (option.Processors.Count == 0)
optionsBuilder.ReplaceService<IQueryTranslationPreprocessorFactory, CustomQueryTranslationPreprocessorFactory>();
else
option.Processors.Remove(processor);
option.Processors.Add(processor);
((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(option);
return optionsBuilder;
}
}
}
namespace Microsoft.EntityFrameworkCore.Infrastructure
{
public class CustomOptionsExtension : IDbContextOptionsExtension
{
public CustomOptionsExtension() { }
private CustomOptionsExtension(CustomOptionsExtension copyFrom) => Processors = copyFrom.Processors.ToList();
public CustomOptionsExtension Clone() => new CustomOptionsExtension(this);
public List<IQueryPreprocessor> Processors { get; } = new List<IQueryPreprocessor>();
ExtensionInfo info;
public DbContextOptionsExtensionInfo Info => info ?? (info = new ExtensionInfo(this));
public void Validate(IDbContextOptions options) { }
public void ApplyServices(IServiceCollection services)
=> services.AddSingleton<IEnumerable<IQueryPreprocessor>>(Processors);
private sealed class ExtensionInfo : DbContextOptionsExtensionInfo
{
public ExtensionInfo(CustomOptionsExtension extension) : base(extension) { }
new private CustomOptionsExtension Extension => (CustomOptionsExtension)base.Extension;
public override bool IsDatabaseProvider => false;
public override string LogFragment => string.Empty;
public override void PopulateDebugInfo(IDictionary<string, string> debugInfo) { }
public override long GetServiceProviderHashCode() => Extension.Processors.Count;
}
}
}
namespace Microsoft.EntityFrameworkCore.Query
{
public interface IQueryPreprocessor
{
Expression Process(Expression query);
}
public class CustomQueryTranslationPreprocessor : RelationalQueryTranslationPreprocessor
{
public CustomQueryTranslationPreprocessor(QueryTranslationPreprocessorDependencies dependencies, RelationalQueryTranslationPreprocessorDependencies relationalDependencies, IEnumerable<IQueryPreprocessor> processors, QueryCompilationContext queryCompilationContext)
: base(dependencies, relationalDependencies, queryCompilationContext) => Processors = processors;
protected IEnumerable<IQueryPreprocessor> Processors { get; }
public override Expression Process(Expression query)
{
foreach (var processor in Processors)
query = processor.Process(query);
return base.Process(query);
}
}
public class CustomQueryTranslationPreprocessorFactory : IQueryTranslationPreprocessorFactory
{
public CustomQueryTranslationPreprocessorFactory(QueryTranslationPreprocessorDependencies dependencies, RelationalQueryTranslationPreprocessorDependencies relationalDependencies, IEnumerable<IQueryPreprocessor> processors)
{
Dependencies = dependencies;
RelationalDependencies = relationalDependencies;
Processors = processors;
}
protected QueryTranslationPreprocessorDependencies Dependencies { get; }
protected RelationalQueryTranslationPreprocessorDependencies RelationalDependencies { get; }
protected IEnumerable<IQueryPreprocessor> Processors { get; }
public QueryTranslationPreprocessor Create(QueryCompilationContext queryCompilationContext)
=> new CustomQueryTranslationPreprocessor(Dependencies, RelationalDependencies, Processors, queryCompilationContext);
}
}
您无需了解该代码。其中大部分（如果不是全部）是一个样板管道代码，以支持当前缺少的IQueryPreprocessor 和AddQueryPreprocesor（类似于最近添加的拦截器）。如果 EF Core 将来添加该功能，我会对其进行更新。
现在您可以使用它将DelegateDecompiler 插入 EF Core：
using System.Linq.Expressions;
using Microsoft.EntityFrameworkCore.Query;
using DelegateDecompiler;
namespace Microsoft.EntityFrameworkCore
{
public static class DelegateDecompilerDbContextOptionsExtensions
{
public static DbContextOptionsBuilder AddDelegateDecompiler(this DbContextOptionsBuilder optionsBuilder)
=> optionsBuilder.AddQueryPreprocessor(new DelegateDecompilerQueryPreprocessor());
}
}
namespace Microsoft.EntityFrameworkCore.Query
{
public class DelegateDecompilerQueryPreprocessor : IQueryPreprocessor
{
public Expression Process(Expression query) => DecompileExpressionVisitor.Decompile(query);
}
}
大量代码只是为了能够调用
DecompileExpressionVisitor.Decompile(query)
在 EF Core 处理之前，但现在你只需要调用
optionsBuilder.AddDelegateDecompiler();
在您的派生上下文中 OnConfiguring 覆盖，您的所有 EF Core LINQ 查询都将被预处理并注入反编译的主体。
举个例子
ctx.Items.Select(x => x.MapToMinimalItem())
会自动转换成
ctx.Items.Select(x => new
{
Id = x.Id,
Property1 = x.Property1
}
EF Core 将其翻译成
// SELECT i."Id", i."Property1" FROM "Items" AS I
这是目标。
此外，在投影上作曲也可以，所以下面的查询
ctx.Items
.Select(x => x.MapToMinimalItem())
.Where(x => x.Property1 == "abc")
.ToList();
原本会产生运行时异常，但现在翻译并成功运行。