实体框架 + ODATA + 动态列映射

Question

我有两个 OData 控制器：

PersonsController
PersonsUnrestrictedController

它们不同的唯一方式是几个属性必须根据控制器从persons表中的不同列获取它们的值。

PersonsController 将发回 Person 列表，其中 Person 的名字、姓氏等是别名，而 PersonsUnrestrictedController 将发回带有这些人的真实姓名的 Person 列表。所有其他属性将完全相同，包括导航属性及其与其他表的关系。

PersonsController 在任何情况下都不能透露一个人的真实姓名，这一点非常重要。

是否可以动态切换：

[Column("AltGivenName")]
public string GivenName { get; set; }

和

[Column("GivenName")]
public string GivenName { get; set; }

取决于控制器？

或者有两个属性 GivenName 和 AltGivenName 并根据控制器动态隐藏/显示其中 1 个：

[DataMember(Name="GivenName")] //Either should this one be ignored
public string AltGivenName { get; set; }

public string GivenName { get; set; } //or this one, depending on controller

或者还有其他可能的解决方法吗？

编辑：添加我的代码

Startup.cs

    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext<PersonContext>(options => { options.UseSqlServer(Configuration.GetConnectionString("MyConnection")); });
            services.AddOData();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseRouting();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapODataRoute("odata", "odata", GetEdmModel());
                endpoints.Select().Expand().MaxTop(null).Count();
            });
        }

        private static IEdmModel GetEdmModel()
        {
            var builder = new ODataConventionModelBuilder();
            var persons = builder.EntitySet<Person>("Persons");
            return builder.GetEdmModel();
        }
    }

PersonContext.cs

    public class PersonContext : DbContext
    {
        public DbSet<DbPerson> Persons { get; set; }

        public PersonContext(DbContextOptions<PersonContext> options) : base(options)
        {
        }
    }

DbPerson.cs

    [Table("Person")]
    public class DbPerson
    {
        [Key]
        public int Id { get; set; }

        public string GivenName { get; set; }

        public string AltGivenName { get; set; }
    }

Person.cs

    public class Person
    {
        [Key]
        public int Id { get; set; }

        public string GivenName { get; set; }
    }

MappingHelper.cs

    public static class MappingHelper
    {
        public static Person ToPerson(this DbPerson dbPerson)
        {
            return new Person
            {
                Id = dbPerson.Id,
                GivenName = dbPerson.GivenName,
            };
        }

        public static Person ToAnonymousPerson(this DbPerson dbPerson)
        {
            return new Person
            {
                Id = dbPerson.Id,
                GivenName = dbPerson.AltGivenName,
            };
        }
    }

PersonsController.cs

    public class PersonsController : ODataController
    {
        private readonly PersonContext _context;

        public PersonsController(PersonContext context)
        {
            _context = context;
        }

        [EnableQuery]
        public IActionResult Get()
        {
            return new ObjectResult(_context.Persons.Select(MappingHelper.ToPerson));
        }
    }

运行以下查询需要 5-10 秒 http://localhost:4871/odata/persons?$top=10

如果我改变：

            return new ObjectResult(_context.Persons.Select(MappingHelper.ToPerson));

到

            return new ObjectResult(_context.Persons);

改变

var persons = builder.EntitySet<Person>("Persons"); 

到

var persons = builder.EntitySet<DbPerson>("Persons");

相同的查询需要 50-100 毫秒

person 表中有大约 150k 人。

Answer 1

配置 PersonsUnrestrictedController 以返回标准的 DB 操作集，这实际上是您的内部 DbPerson api，并将 PersonsController 定义为专用控制器，用于访问名为的数据传输对象Person.

您已经定义了大部分元素，我们需要更改的只是控制器实现。

以下内容没有变化：

• DbPerson.cs
• Person.cs
• PersonContext.cs

在EdmModel 中定义两个控制器：

private static IEdmModel GetEdmModel()
{
    var builder = new ODataConventionModelBuilder();
    var persons = builder.EntitySet<Person>("Persons");
    var unrestricted = builder.EntitySet<DbPerson>("PersonsUnrestricted");
    return builder.GetEdmModel();
}

与其创建一个 Mapping 方法来映射对象，更简单的模式是在控制器中添加一个方法来提供 base 查询，all 该控制器中的操作应该使用。

通过这种方式，您可以强制执行通用过滤条件、包含或排序，而无需在每个操作中声明相同的查询。它是一种更容易长期维护的模式，当您有 20 个操作或函数都具有需要重构的相同查询时，或者当您必须跨多个控制器重构类似条件​​时，您会感谢我。

公共人员控制者：

public class PersonsController : ODataController
{
    private readonly PersonContext _context;

    public PersonsController(PersonContext context)
    {
        _context = context;
    }
    
    private IQueryable<Person> GetQuery() 
    {
        return from p in _context.Persons
               select new Person 
               { 
                   Id = p.Id,
                   GivenName = p.AltGivenName 
               };
    }

    [EnableQuery]
    public IActionResult Get()
    {
        return Ok(GetQuery());
    }

    [EnableQuery]
    public IActionResult Get(int key)
    {
        return Ok(GetQuery().Single(x => x.Id == key));
    }
}

不受限制的控制器：

public class PersonsUnrestrictedController : ODataController
{
    private readonly PersonContext _context;

    public PersonsUnrestrictedController(PersonContext context)
    {
        _context = context;
    }

    private IQueryable<DbPerson> GetQuery() 
    {
        return _context.Persons;
    }

    [EnableQuery]
    public IActionResult Get()
    {
        return Ok(GetQuery());
    }

    [EnableQuery]
    public IActionResult Get(int key)
    {
        return Ok(GetQuery().Single(x => x.Id == key));
    }
}

Answer 2

这里的其他答案特别关注您对映射到同一个表的 2 个单独控制器的请求，但听起来您真正需要的是来自 OData 实体的自定义只读提要，它仍然具有查询支持。

在 OData 中，这通常通过在返回一组可查询 DTO 的标准控制器上定义 Function 端点来实现。

以下内容没有变化：

• DbPerson.cs
• Person.cs
• PersonContext.cs

然而，在这个解决方案中，我们将有一个PersonsController，它具有标准的Get() 端点和一个函数 View() 端点。

private static IEdmModel GetEdmModel()
{
    var builder = new ODataConventionModelBuilder();
    var persons = builder.EntitySet<DbPerson>("Persons");
    persons.EntityType.Collection.Function("View").ReturnsCollection<Person>();
    return builder.GetEdmModel();
}

PersonsController.cs

public class PersonsController : ODataController
{
    private readonly PersonContext _context;

    public PersonsController(PersonContext context)
    {
        _context = context;
    }
    
    [HttpGet]
    [EnableQuery]
    public IActionResult Get()
    {
        return Ok(_context.Persons);
    }

    [HttpGet]
    [EnableQuery]
    public IActionResult View()
    {
        return Ok(from p in _context.Persons
                  select new Person 
                  { 
                      Id = p.Id,
                      GivenName = p.AltGivenName 
                  });
    } 

}

OP 已专门询问过asp.net-core，但此回复适用于EF6 和asp.net 和asp.net-core

Answer 3

在这种情况下（事实上，作为一般规则），我建议您将数据库模型与业务模型分开，并在两者之间设置一些映射逻辑。

这样您就可以拥有两个业务模型Person 和AnonymousPerson 和一个数据库模型DbPerson（随意称呼它们）。然后实现一些映射逻辑，将DbPerson 转换为Person，将DbPerson 转换为AnonymousPerson，并根据您所处的情况使用适当的映射逻辑。

例如，查看this fiddle。有关更多详细信息，请考虑我们有以下数据库模型和两个业务对象模型：

public class DbPerson
{
    public string GivenName { get; set; }
    public string FamilyName { get; set; }
    public string AltGivenName { get; set; }
}

public class Person
{
    public string GivenName { get; set; }
    public string FamilyName { get; set; }
}

public class AnonymousPerson
{
    public string Nickname { get; set; }
}

然后我们需要一些逻辑来将数据库模型转换为两个业务对象中的任何一个。我在这里使用extension methods，但如果您愿意，也可以使用普通方法：

public static class MappingHelper
{
    public static Person ToPerson(this DbPerson dbPerson)
    {
        return new Person
        {
            GivenName = dbPerson.GivenName,
            FamilyName = dbPerson.FamilyName
        };
    }
    
    
    public static AnonymousPerson ToAnonymousPerson(this DbPerson dbPerson)
    {
        return new AnonymousPerson
        {
            Nickname = dbPerson.AltGivenName
        };
    }
}

现在，要以正确的格式获取数据，您只需使用所需的映射方法（使用类似实体框架的方法）：

// From PersonsController (or a service beneath)
var persons = myDatabase.Persons.Select(MappingHelper.ToPerson);
// Same as                       Select(p => p.ToPerson())
// or                            Select(p => MappingHelper.ToPerson(p))


// And from PersonsUnrestrictedController
var anonPersons = myDatabase.Persons.Select(MappingHelper.ToAnonymousPerson);