Adatátviteli objektumok (DTO-k) létrehozása

Befejezett projekt letöltése

A webes API jelenleg az adatbázis-entitásokat teszi elérhetővé az ügyfél számára. Az ügyfél közvetlenül az adatbázistáblákhoz hozzárendelt adatokat fogad. Ez azonban nem mindig jó ötlet. Előfordulhat, hogy módosítani szeretné az ügyfélnek küldött adatok alakját. Előfordulhat például, hogy a következőt szeretné:

• Körkörös hivatkozások eltávolítása (lásd az előző szakaszt).
• Elrejtheti azokat a tulajdonságokat, amelyeket az ügyfeleknek nem kell megtekintenie.
• Kihagy néhány tulajdonságot a hasznos adat méretének csökkentése érdekében.
• Beágyazott objektumokat tartalmazó objektumdiagramok simítása az ügyfelek számára kényelmesebbé tétele érdekében.
• Kerülje a "túl közzétett" biztonsági réseket. (Lásd a modellérvényesítést a túlzott közzétételről szóló részletezésért.)
• A szolgáltatásréteg leválasztása az adatbázisrétegről.

Ehhez definiálhat egy adatátviteli objektumot (DTO). A DTO egy objektum, amely meghatározza az adatok hálózaton keresztüli küldésének módját. Lássuk, hogyan működik ez a Book entitással. A Modellek mappában adjon hozzá két DTO-osztályt:

namespace BookService.Models
{
    public class BookDto
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public string AuthorName { get; set; }
    }
}

namespace BookService.Models
{
    public class BookDetailDto
    {
        public int Id { get; set; }
        public string Title { get; set; }
        public int Year { get; set; }
        public decimal Price { get; set; }
        public string AuthorName { get; set; }
        public string Genre { get; set; }
    }
}

Az BookDetailDto osztály tartalmazza a Könyv modell összes tulajdonságát, kivéve, hogy AuthorName a szerző nevét tartalmazó sztring. Az BookDto osztály a tulajdonságok egy részhalmazát tartalmazza a BookDetailDto-ből.

Ezután cserélje le az osztály két GET metódusát a BooksController DTO-kat visszaváltó verziókra. A LINQ Select utasítást fogjuk használni a Könyv entitásokból DTO-kká alakításához.

// GET api/Books
public IQueryable<BookDto> GetBooks()
{
    var books = from b in db.Books
                select new BookDto()
                {
                    Id = b.Id,
                    Title = b.Title,
                    AuthorName = b.Author.Name
                };

    return books;
}

// GET api/Books/5
[ResponseType(typeof(BookDetailDto))]
public async Task<IHttpActionResult> GetBook(int id)
{
    var book = await db.Books.Include(b => b.Author).Select(b =>
        new BookDetailDto()
        {
            Id = b.Id,
            Title = b.Title,
            Year = b.Year,
            Price = b.Price,
            AuthorName = b.Author.Name,
            Genre = b.Genre
        }).SingleOrDefaultAsync(b => b.Id == id);
    if (book == null)
    {
        return NotFound();
    }

    return Ok(book);
}

Itt található az új GetBooks metódus által létrehozott SQL. Láthatja, hogy az EF lefordítja a LINQ Select parancsot egy SQL SELECT utasításra.

SELECT 
    [Extent1].[Id] AS [Id], 
    [Extent1].[Title] AS [Title], 
    [Extent2].[Name] AS [Name]
    FROM  [dbo].[Books] AS [Extent1]
    INNER JOIN [dbo].[Authors] AS [Extent2] ON [Extent1].[AuthorId] = [Extent2].[Id]

Végül módosítsa a PostBook metódust, hogy egy DTO-t adjon vissza.

[ResponseType(typeof(BookDto))]
public async Task<IHttpActionResult> PostBook(Book book)
{
    if (!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }

    db.Books.Add(book);
    await db.SaveChangesAsync();

    // New code:
    // Load author name
    db.Entry(book).Reference(x => x.Author).Load();

    var dto = new BookDto()
    {
        Id = book.Id,
        Title = book.Title,
        AuthorName = book.Author.Name
    };

    return CreatedAtRoute("DefaultApi", new { id = book.Id }, dto);
}

Megjegyzés:

Ebben az oktatóanyagban manuálisan konvertálunk DTO-kká kódban. Egy másik lehetőség egy olyan kódtár használata, mint az AutoMapper , amely automatikusan kezeli az átalakítást.

ElőzőKövetkező