GET /api/books/1
Accept: application/json
→ { "id": 1, "title": "Clean Code", ... }

GET /api/books/1
Accept: application/xml
→ <Book><Id>1</Id><Title>Clean Code</Title>...</Book>

GET /api/books/1
Accept: text/csv
→ Id,Title,Author,Year
  1,Clean Code,Robert Martin,2008

GET /api/books/1 HTTP/1.1
Accept: application/json

Accept: application/json, application/xml;q=0.9, text/csv;q=0.8

POST /api/books HTTP/1.1
Content-Type: application/json

{ "title": "Clean Code", "author": "Robert Martin" }

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8

{ "id": 1, "title": "Clean Code" }

HTTP Request Body (JSON/XML/CSV) → InputFormatter → C# Object

C# Object → OutputFormatter → HTTP Response Body (JSON/XML/CSV)

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using BooksApi.Data;
using BooksApi.Models;

namespace BooksApi.Controllers;

[ApiController]
[Route("api/[controller]")]
[Produces("application/json", "application/xml")] // Підтримувані формати
public class BooksController : ControllerBase
{
    private readonly BookDbContext _db;
    private readonly ILogger<BooksController> _logger;

    public BooksController(BookDbContext db, ILogger<BooksController> logger)
    {
        _db = db;
        _logger = logger;
    }

    /// <summary>
    /// Отримати всі книги
    /// </summary>
    /// <returns>Список книг у запитаному форматі</returns>
    /// <response code="200">Успішно отримано список</response>
    /// <response code="406">Формат не підтримується</response>
    [HttpGet]
    [ProducesResponseType(typeof(IEnumerable<Book>), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status406NotAcceptable)]
    public async Task<ActionResult<IEnumerable<Book>>> GetAll()
    {
        _logger.LogInformation("Fetching all books. Accept header: {AcceptHeader}", 
            Request.Headers.Accept.ToString());
        
        var books = await _db.Books
            .OrderBy(b => b.Title)
            .ToListAsync();
        
        return Ok(books);
    }

    /// <summary>
    /// Отримати книгу за ID
    /// </summary>
    /// <param name="id">Ідентифікатор книги</param>
    /// <returns>Книга у запитаному форматі</returns>
    [HttpGet("{id:int}")]
    [ProducesResponseType(typeof(Book), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    [ProducesResponseType(StatusCodes.Status406NotAcceptable)]
    public async Task<ActionResult<Book>> GetById(int id)
    {
        var book = await _db.Books.FindAsync(id);
        
        if (book is null)
        {
            return NotFound(new ProblemDetails
            {
                Title = "Book not found",
                Detail = $"Book with ID {id} does not exist",
                Status = StatusCodes.Status404NotFound
            });
        }
        
        return book;
    }

    /// <summary>
    /// Створити нову книгу
    /// </summary>
    /// <param name="book">Дані книги</param>
    /// <returns>Створена книга</returns>
    [HttpPost]
    [Consumes("application/json", "application/xml")] // Приймаємо JSON або XML
    [ProducesResponseType(typeof(Book), StatusCodes.Status201Created)]
    [ProducesResponseType(StatusCodes.Status400BadRequest)]
    [ProducesResponseType(StatusCodes.Status415UnsupportedMediaType)]
    public async Task<ActionResult<Book>> Create(Book book)
    {
        _logger.LogInformation("Creating book: {Title}. Content-Type: {ContentType}", 
            book.Title, Request.ContentType);
        
        // Перевірка на дублікат ISBN
        if (!string.IsNullOrEmpty(book.ISBN))
        {
            var existingBook = await _db.Books
                .FirstOrDefaultAsync(b => b.ISBN == book.ISBN);
            
            if (existingBook is not null)
            {
                return Conflict(new ProblemDetails
                {
                    Title = "Duplicate ISBN",
                    Detail = $"A book with ISBN '{book.ISBN}' already exists",
                    Status = StatusCodes.Status409Conflict
                });
            }
        }
        
        _db.Books.Add(book);
        await _db.SaveChangesAsync();
        
        return CreatedAtAction(nameof(GetById), new { id = book.Id }, book);
    }

    /// <summary>
    /// Оновити книгу
    /// </summary>
    [HttpPut("{id:int}")]
    [Consumes("application/json", "application/xml")]
    [ProducesResponseType(typeof(Book), StatusCodes.Status200OK)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<ActionResult<Book>> Update(int id, Book book)
    {
        if (id != book.Id)
        {
            return BadRequest(new ProblemDetails
            {
                Title = "ID mismatch",
                Detail = "The ID in the URL does not match the ID in the request body",
                Status = StatusCodes.Status400BadRequest
            });
        }
        
        var existingBook = await _db.Books.FindAsync(id);
        
        if (existingBook is null)
        {
            return NotFound();
        }
        
        // Оновлення властивостей
        existingBook.Title = book.Title;
        existingBook.Author = book.Author;
        existingBook.ISBN = book.ISBN;
        existingBook.PublicationYear = book.PublicationYear;
        existingBook.Pages = book.Pages;
        existingBook.Genre = book.Genre;
        existingBook.Rating = book.Rating;
        existingBook.IsAvailable = book.IsAvailable;
        
        await _db.SaveChangesAsync();
        
        return existingBook;
    }

    /// <summary>
    /// Видалити книгу
    /// </summary>
    [HttpDelete("{id:int}")]
    [ProducesResponseType(StatusCodes.Status204NoContent)]
    [ProducesResponseType(StatusCodes.Status404NotFound)]
    public async Task<IActionResult> Delete(int id)
    {
        var book = await _db.Books.FindAsync(id);
        
        if (book is null)
        {
            return NotFound();
        }
        
        _db.Books.Remove(book);
        await _db.SaveChangesAsync();
        
        return NoContent();
    }
}

builder.Services.AddControllers()
    .AddJsonOptions(options =>
    {
        // Naming policy
        options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
        
        // Форматування
        options.JsonSerializerOptions.WriteIndented = true;
        
        // Null-значення
        options.JsonSerializerOptions.DefaultIgnoreCondition = 
            JsonIgnoreCondition.WhenWritingNull;
        
        // Enum як рядки
        options.JsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
        
        // Дозволити trailing commas
        options.JsonSerializerOptions.AllowTrailingCommas = true;
        
        // Case-insensitive property names
        options.JsonSerializerOptions.PropertyNameCaseInsensitive = true;
        
        // Циклічні посилання (з .NET 6)
        options.JsonSerializerOptions.ReferenceHandler = ReferenceHandler.IgnoreCycles;
    });

dotnet add package Microsoft.AspNetCore.Mvc.NewtonsoftJson

builder.Services.AddControllers()
    .AddNewtonsoftJson(options =>
    {
        // Naming strategy
        options.SerializerSettings.ContractResolver = 
            new CamelCasePropertyNamesContractResolver();
        
        // Форматування
        options.SerializerSettings.Formatting = Formatting.Indented;
        
        // Null-значення
        options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
        
        // Enum як рядки
        options.SerializerSettings.Converters.Add(new StringEnumConverter());
        
        // Циклічні посилання
        options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
        
        // Дати у ISO 8601
        options.SerializerSettings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
    });

using Microsoft.AspNetCore.Mvc.Formatters;
using Microsoft.Net.Http.Headers;
using System.Text;
using BooksApi.Models;

namespace BooksApi.Formatters;

public class CsvOutputFormatter : TextOutputFormatter
{
    public CsvOutputFormatter()
    {
        // Реєструємо підтримувані MIME-типи
        SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("text/csv"));
        SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/csv"));
        
        // Підтримувані кодування
        SupportedEncodings.Add(Encoding.UTF8);
        SupportedEncodings.Add(Encoding.Unicode);
    }

    // Перевірка, чи можемо серіалізувати цей тип
    protected override bool CanWriteType(Type? type)
    {
        // Підтримуємо Book та IEnumerable<Book>
        if (type == typeof(Book))
            return true;
        
        if (type == null)
            return false;
        
        // Перевірка на колекцію
        if (typeof(IEnumerable<Book>).IsAssignableFrom(type))
            return true;
        
        return false;
    }

    // Основний метод серіалізації
    public override async Task WriteResponseBodyAsync(
        OutputFormatterWriteContext context, 
        Encoding selectedEncoding)
    {
        var httpContext = context.HttpContext;
        var response = httpContext.Response;
        
        var csv = new StringBuilder();
        
        // Заголовок CSV
        csv.AppendLine("Id,Title,Author,ISBN,PublicationYear,Pages,Genre,Rating,IsAvailable");
        
        // Серіалізація даних
        if (context.Object is IEnumerable<Book> books)
        {
            foreach (var book in books)
            {
                csv.AppendLine(FormatBookAsCsvRow(book));
            }
        }
        else if (context.Object is Book book)
        {
            csv.AppendLine(FormatBookAsCsvRow(book));
        }
        
        // Запис у response stream
        await response.WriteAsync(csv.ToString(), selectedEncoding);
    }

    // Допоміжний метод для форматування рядка
    private static string FormatBookAsCsvRow(Book book)
    {
        return $"{book.Id}," +
               $"\"{EscapeCsvValue(book.Title)}\"," +
               $"\"{EscapeCsvValue(book.Author)}\"," +
               $"\"{EscapeCsvValue(book.ISBN ?? "")}\"," +
               $"{book.PublicationYear}," +
               $"{book.Pages}," +
               $"\"{EscapeCsvValue(book.Genre ?? "")}\"," +
               $"{book.Rating}," +
               $"{book.IsAvailable}";
    }

    // Екранування спеціальних символів CSV
    private static string EscapeCsvValue(string value)
    {
        if (string.IsNullOrEmpty(value))
            return value;
        
        // Подвоюємо лапки для екранування
        return value.Replace("\"", "\"\"");
    }
}

using BooksApi.Formatters;

builder.Services.AddControllers(options =>
{
    options.ReturnHttpNotAcceptable = true;
    
    // Додаємо наш кастомний CSV форматер
    options.OutputFormatters.Add(new CsvOutputFormatter());
})
.AddJsonOptions(/* ... */)
.AddXmlSerializerFormatters();

[ApiController]
[Route("api/[controller]")]
[Produces("application/json", "application/xml", "text/csv")] // Додали CSV
public class BooksController : ControllerBase
{
    // Методи залишаються без змін!
}

using Microsoft.AspNetCore.Mvc.Formatters;
using Microsoft.Net.Http.Headers;
using System.Text;
using BooksApi.Models;

namespace BooksApi.Formatters;

public class CsvInputFormatter : TextInputFormatter
{
    public CsvInputFormatter()
    {
        SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("text/csv"));
        SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/csv"));
        
        SupportedEncodings.Add(Encoding.UTF8);
        SupportedEncodings.Add(Encoding.Unicode);
    }

    protected override bool CanReadType(Type type)
    {
        return type == typeof(Book) || 
               typeof(IEnumerable<Book>).IsAssignableFrom(type);
    }

    public override async Task<InputFormatterResult> ReadRequestBodyAsync(
        InputFormatterContext context, 
        Encoding encoding)
    {
        var httpContext = context.HttpContext;
        var request = httpContext.Request;
        
        using var reader = new StreamReader(request.Body, encoding);
        var csv = await reader.ReadToEndAsync();
        
        try
        {
            var books = ParseCsv(csv);
            
            // Якщо очікується один об'єкт, повертаємо перший
            if (context.ModelType == typeof(Book))
            {
                return await InputFormatterResult.SuccessAsync(books.FirstOrDefault()!);
            }
            
            return await InputFormatterResult.SuccessAsync(books);
        }
        catch (Exception ex)
        {
            context.ModelState.AddModelError(string.Empty, 
                $"CSV parsing error: {ex.Message}");
            return await InputFormatterResult.FailureAsync();
        }
    }

    private static List<Book> ParseCsv(string csv)
    {
        var books = new List<Book>();
        var lines = csv.Split('\n', StringSplitOptions.RemoveEmptyEntries);
        
        // Пропускаємо заголовок
        for (int i = 1; i < lines.Length; i++)
        {
            var line = lines[i].Trim();
            if (string.IsNullOrEmpty(line)) continue;
            
            var values = ParseCsvLine(line);
            
            if (values.Length < 9)
                throw new FormatException($"Invalid CSV format at line {i + 1}");
            
            var book = new Book
            {
                Id = int.Parse(values[0]),
                Title = values[1],
                Author = values[2],
                ISBN = string.IsNullOrEmpty(values[3]) ? null : values[3],
                PublicationYear = int.Parse(values[4]),
                Pages = int.Parse(values[5]),
                Genre = string.IsNullOrEmpty(values[6]) ? null : values[6],
                Rating = double.Parse(values[7]),
                IsAvailable = bool.Parse(values[8])
            };
            
            books.Add(book);
        }
        
        return books;
    }

    // Парсинг рядка CSV з урахуванням лапок
    private static string[] ParseCsvLine(string line)
    {
        var values = new List<string>();
        var currentValue = new StringBuilder();
        bool inQuotes = false;
        
        for (int i = 0; i < line.Length; i++)
        {
            char c = line[i];
            
            if (c == '"')
            {
                if (inQuotes && i + 1 < line.Length && line[i + 1] == '"')
                {
                    // Подвійні лапки — екранування
                    currentValue.Append('"');
                    i++; // Пропускаємо наступну лапку
                }
                else
                {
                    inQuotes = !inQuotes;
                }
            }
            else if (c == ',' && !inQuotes)
            {
                values.Add(currentValue.ToString());
                currentValue.Clear();
            }
            else
            {
                currentValue.Append(c);
            }
        }
        
        values.Add(currentValue.ToString());
        return values.ToArray();
    }
}

builder.Services.AddControllers(options =>
{
    options.ReturnHttpNotAcceptable = true;
    
    // Output форматери
    options.OutputFormatters.Add(new CsvOutputFormatter());
    
    // Input форматери
    options.InputFormatters.Add(new CsvInputFormatter());
})
.AddJsonOptions(/* ... */)
.AddXmlSerializerFormatters();

[HttpPost]
[Consumes("application/json", "application/xml", "text/csv")] // Додали CSV
[ProducesResponseType(typeof(Book), StatusCodes.Status201Created)]
public async Task<ActionResult<Book>> Create(Book book)
{
    // Логіка залишається без змін!
}

dotnet add package YamlDotNet

using Microsoft.AspNetCore.Mvc.Formatters;
using Microsoft.Net.Http.Headers;
using System.Text;
using YamlDotNet.Serialization;

namespace BooksApi.Formatters;

public class YamlOutputFormatter : TextOutputFormatter
{
    private readonly ISerializer _serializer;

    public YamlOutputFormatter()
    {
        SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/yaml"));
        SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("text/yaml"));
        
        SupportedEncodings.Add(Encoding.UTF8);
        
        _serializer = new SerializerBuilder()
            .WithNamingConvention(YamlDotNet.Serialization.NamingConventions.CamelCaseNamingConvention.Instance)
            .Build();
    }

    protected override bool CanWriteType(Type? type)
    {
        return type != null;
    }

    public override async Task WriteResponseBodyAsync(
        OutputFormatterWriteContext context, 
        Encoding selectedEncoding)
    {
        var yaml = _serializer.Serialize(context.Object!);
        await context.HttpContext.Response.WriteAsync(yaml, selectedEncoding);
    }
}

id: 1
title: Clean Code
author: Robert C. Martin
isbn: 978-0132350884
publicationYear: 2008
pages: 464
genre: Programming
rating: 4.7
isAvailable: true

dotnet add package MessagePack
dotnet add package MessagePack.AspNetCoreMvcFormatter

using MessagePack.AspNetCoreMvcFormatter;
using MessagePack.Resolvers;

builder.Services.AddControllers(options =>
{
    // Додаємо MessagePack форматери
    options.OutputFormatters.Add(new MessagePackOutputFormatter(ContractlessStandardResolver.Options));
    options.InputFormatters.Add(new MessagePackInputFormatter(ContractlessStandardResolver.Options));
})
.AddJsonOptions(/* ... */);

GET /api/books/1
Accept: application/x-msgpack
→ [бінарні дані MessagePack]

// На рівні контролера (для всіх методів)
[ApiController]
[Route("api/[controller]")]
[Produces("application/json", "application/xml")]
public class BooksController : ControllerBase
{
    // Всі методи підтримують JSON та XML
}

// На рівні методу (перевизначає контролер)
[HttpGet("export")]
[Produces("text/csv", "application/yaml")]
public async Task<ActionResult<IEnumerable<Book>>> Export()
{
    // Цей метод підтримує тільки CSV та YAML
}

[HttpPost]
[Consumes("application/json")] // Приймає тільки JSON
public async Task<ActionResult<Book>> CreateJson(Book book)
{
    // ...
}

[HttpPost("xml")]
[Consumes("application/xml")] // Приймає тільки XML
public async Task<ActionResult<Book>> CreateXml(Book book)
{
    // ...
}

[HttpPost]
[Consumes("application/json", "application/xml", "text/csv")]
[Produces("application/json", "application/xml")]
[ProducesResponseType(typeof(Book), StatusCodes.Status201Created)]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status415UnsupportedMediaType)]
public async Task<ActionResult<Book>> Create(Book book)
{
    // Приймає JSON/XML/CSV, повертає JSON/XML
}