这是如何使用 Entity Framework Core 和 ASP.NET Core MVC 2.2+ 和 3.0 创建数据传输对象 (DTO)

Question

在使用 ASP.NET Core MVC 2.2 创建 RESTful Api 时，我注意到没有像 2014 Web api 示例那样的 DTO 示例。

ASP.NET Core MVC 2.2 Rest api 2019 example

ASP.NET web-api 2014 example

所以，我决定为我的一些控制器动词 HTTPGet、HTTPPost 和 HTTPPut 创建 DTO

我的最终结果中有 2 个问题。

1. 这是一般意义上的推荐方法吗？或者，新的 Entity Framework Core 中是否存在与 2014 年基于 Entity Framework 6 或更早版本的示例不同或更好的内容？

2. 一般来说应该使用 DTO 设计模式吗？或者 Entity Framework Core 中是否存在与 DTO 模式完全不同的东西。具体来说，有没有办法从数据库中获取数据并将其传递给视图/客户端，这正是我需要传递的方式？

关于提出问题第 2 部分原因的更多背景信息。我已经阅读了有关 DTO 是反模式的信息，人们说不要出于某种原因使用它们。然而，许多开发人员恳求他们的使用以及何时以及为什么应该使用它们。我个人的一个例子是工作以及 Angular 和 React 项目。接收我需要的数据是一件美妙的事情，我无法想象任何其他选择，即执行所有类型的箍和解析以通过一个整体对象在屏幕上显示地址和位置。

但是随着时代的变化，是否有一种设计模式或另一种模式可以做同样的事情，但费用和计算成本更低。

1. 就此而言，服务器和 dbserver 使用这种模式是否会产生很大的计算成本？

2. 最后，与 EF 6 或 linq to sql 框架相比，下面的代码是否期望在 Entity Framework Core 中使用 DTO 模式？

我已经包含了下面的代码更改，以说明我在下面的练习中为 TodoItem 模型创建的 DTO。

Project(TodoApi) --> DTO --> TodoItemDTO.cs:

using System.ComponentModel;
using System.ComponentModel.DataAnnotations;

namespace TodoApi.Models
{
    public class TodoItemDTO
    {
        [Required]
        public string Names { get; set; }

        [DefaultValue(false)]
        public bool IsCompletes { get; set; }
    }

    public class TodoItemDetailDTO
    {
        public long Id { get; set; }

        [Required]
        public string Names { get; set; }

        [DefaultValue(false)]
        public bool IsCompletes { get; set; }
    }
}

Project(TodoApi) --> 控制器--> TodoController.cs:

using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using TodoApi.Models;

// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860

namespace TodoApi.Controllers
{
    [Produces("application/json")]
    [Route("api/[controller]")]
    [ApiController]
    public class TodoController: ControllerBase
    {
        private readonly TodoContext _context;

        public TodoController(TodoContext context)
        {
            _context = context;

            if (_context.TodoItems.Count() == 0)
            {
                // Create a new TodoItem if collection is empty, 
                // which means you can't delte all TodoItems.
                _context.TodoItems.Add(new TodoItem { Name = "Item1" });
                _context.SaveChanges();
            }

            // Console.WriteLine(GetTodoItems());
        }

        // Get: api/Todo
        [HttpGet]
        public async Task<ActionResult<IQueryable<TodoItem>>> GetTodoItems()
        {
            var todoItems = await _context.TodoItems.Select(t =>
                        new TodoItemDetailDTO()
                        {
                            Id = t.Id,
                            Names = t.Name,
                            IsCompletes = t.IsComplete
                        }).ToListAsync();

            return Ok(todoItems);

            // previous return statement
            //return await _context.TodoItems.ToListAsync();
        }

        // Get: api/Todo/5
        [HttpGet("{id}")]
        [ProducesResponseType(typeof(TodoItemDetailDTO), 201)]
        public async Task<ActionResult<TodoItem>> GetTodoItem(long id)
        {
            var todoItem = await _context.TodoItems.Select(t =>
            new TodoItemDetailDTO()
            {
                Id = t.Id,
                Names = t.Name,
                IsCompletes = t.IsComplete
            }).SingleOrDefaultAsync(t => t.Id == id);

            if (todoItem == null)
            {
                return NotFound();
            }

            return Ok(todoItem);

            //var todoItem = await _context.TodoItems.FindAsync(id);

            //////if (todoItem == null)
            //{
            //    return NotFound();
            //}

            //return todoItem;
        }

        // POST: api/Todo
        /// <summary>
        /// Creates a TodoItem.
        /// </summary>
        /// <remarks>
        /// Sample request:
        ///
        ///     POST /Todo
        ///     {
        ///        "id": 1,
        ///        "name": "Item1",
        ///        "isComplete": true
        ///     }
        ///
        /// </remarks>
        /// <param name="item"></param>
        /// <returns>A newly created TodoItem</returns>
        /// <response code="201">Returns the newly created item</response>
        /// <response code="400">If the item is null</response>            
        [HttpPost]
        [ProducesResponseType(typeof(TodoItemDTO), 201)]
        [ProducesResponseType(typeof(TodoItemDTO), 400)]
        public async Task<ActionResult<TodoItem>> PostTodoItem(TodoItem item)
        {
            _context.TodoItems.Add(item);
            await _context.SaveChangesAsync();

            _context.Entry(item).Property(x => x.Name);
            var dto = new TodoItemDTO()
            {
                Names = item.Name,
                IsCompletes = item.IsComplete
            };

            // didn't use because CreatedAtAction Worked
            // return CreatedAtRoute("DefaultApi", new { id = item.Id }, dto);

            return CreatedAtAction(nameof(GetTodoItem), new { id = item.Id }, dto);

            // original item call for new todoitem post
            //return CreatedAtAction(nameof(GetTodoItem), new { id = item.Id }, item);
        }

        // PUT: api/Todo/5
        [HttpPut("{id}")]
        [ProducesResponseType(typeof(TodoItemDTO), 201)]
        [ProducesResponseType(typeof(TodoItemDTO), 400)]
        public async Task<IActionResult> PutTodoItem(long id, TodoItem item)
        {
            if (id != item.Id)
            {
                return BadRequest();
            }

            _context.Entry(item).State = EntityState.Modified;
            await _context.SaveChangesAsync();

            var dto = new TodoItemDTO()
            {
                Names = item.Name,
                IsCompletes = item.IsComplete
            };

            return CreatedAtAction(nameof(GetTodoItem), new { id = item.Id }, dto);
        }

        // DELETE: api/Todo/5
        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteTodoItem(long id)
        {
            var todoItem = await _context.TodoItems.FindAsync(id);

            if (todoItem == null)
            {
                return NotFound();
            }

            _context.TodoItems.Remove(todoItem);
            await _context.SaveChangesAsync();

            return NoContent();
        }
    }
}

Answer 1

我认为您对语义过于依赖了。严格来说，“实体”只是一个具有身份的对象（即具有标识符），与“值对象”之类的东西形成对比。 Entity Framework（Core or no）是一个抽象对象持久性的对象/关系映射器（ORM）。提供给 EF 的“实体”是一个类，它表示持久层中的一个对象（即特定表中的一行）。仅此而已。

但是，因此，它在其他情况下通常并不是非常有用。 SRP（单一职责原则）几乎规定实体应该只关心对持久性很重要的实际内容。处理特定请求、为特定视图提供数据等的需求可以并且将会与此不同，这意味着您需要使实体类做太多事情，或者您需要专门用于这些目的的其他类。这就是 DTO、视图模型等概念发挥作用的地方。

简而言之，正确的做法是在特定情况下使用有意义的东西。如果您正在处理 CRUD 类型的 API，那么在该场景中直接使用实体类可能是有意义的。然而，通常情况下，即使在 CRUD 的场景中，通常还是最好有一个自定义类来绑定请求体。这使您可以控制诸如序列化之类的事情以及哪些属性是可查看、可编辑等。从某种意义上说，您将 API 与持久层分离，允许两者相互独立地工作。

例如，假设您需要更改实体上的属性名称。如果您的 API 直接使用实体，那么这将需要对 API 进行版本控制并使用旧属性名称处理先前版本的弃用。为每个类使用一个单独的类，您可以简单地更改映射层，API 会在不知不觉中愉快地运行。与 API 交互的客户端无需更改。作为一般规则，您希望始终追求组件之间耦合最小的路径。