C# Code Generator (Free AI Tool)

Plain English:
"Create an ASP.NET Core API controller for managing books
with GET all, GET by ID, POST create, PUT update, and DELETE.
Include async methods, model validation, and proper status codes."

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading.Tasks;
using BookStore.Models;
using BookStore.Services;

namespace BookStore.Controllers
{
    /// <summary>
    /// API controller for managing book resources.
    /// </summary>
    /// <remarks>
    /// Provides CRUD operations for books with async methods
    /// and proper HTTP status code responses.
    /// </remarks>
    [ApiController]
    [Route("api/[controller]")]
    public class BooksController : ControllerBase
    {
        private readonly IBookService _bookService;
        
        /// <summary>
        /// Initializes a new instance of the BooksController.
        /// </summary>
        /// <param name="bookService">Service for book operations</param>
        public BooksController(IBookService bookService)
        {
            _bookService = bookService;
        }
        
        /// <summary>
        /// Retrieves all books.
        /// </summary>
        /// <returns>List of all books</returns>
        /// <response code="200">Returns the list of books</response>
        [HttpGet]
        [ProducesResponseType(typeof(IEnumerable<Book>), 200)]
        public async Task<ActionResult<IEnumerable<Book>>> GetAllBooks()
        {
            var books = await _bookService.GetAllAsync();
            return Ok(books);
        }
        
        /// <summary>
        /// Retrieves a specific book by ID.
        /// </summary>
        /// <param name="id">Book identifier</param>
        /// <returns>Book with specified ID</returns>
        /// <response code="200">Returns the book</response>
        /// <response code="404">Book not found</response>
        [HttpGet("{id}")]
        [ProducesResponseType(typeof(Book), 200)]
        [ProducesResponseType(404)]
        public async Task<ActionResult<Book>> GetBookById(int id)
        {
            var book = await _bookService.GetByIdAsync(id);
            
            if (book == null)
            {
                return NotFound(new { message = $"Book with ID {id} not found" });
            }
            
            return Ok(book);
        }
        
        /// <summary>
        /// Creates a new book.
        /// </summary>
        /// <param name="book">Book data to create</param>
        /// <returns>Created book</returns>
        /// <response code="201">Book created successfully</response>
        /// <response code="400">Invalid book data</response>
        [HttpPost]
        [ProducesResponseType(typeof(Book), 201)]
        [ProducesResponseType(400)]
        public async Task<ActionResult<Book>> CreateBook([FromBody] Book book)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            
            var created = await _bookService.CreateAsync(book);
            return CreatedAtAction(nameof(GetBookById), new { id = created.Id }, created);
        }
        
        /// <summary>
        /// Updates an existing book.
        /// </summary>
        /// <param name="id">Book identifier</param>
        /// <param name="book">Updated book data</param>
        /// <returns>No content</returns>
        /// <response code="204">Book updated successfully</response>
        /// <response code="400">Invalid data or ID mismatch</response>
        /// <response code="404">Book not found</response>
        [HttpPut("{id}")]
        [ProducesResponseType(204)]
        [ProducesResponseType(400)]
        [ProducesResponseType(404)]
        public async Task<IActionResult> UpdateBook(int id, [FromBody] Book book)
        {
            if (id != book.Id)
            {
                return BadRequest(new { message = "ID mismatch" });
            }
            
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            
            var exists = await _bookService.ExistsAsync(id);
            if (!exists)
            {
                return NotFound(new { message = $"Book with ID {id} not found" });
            }
            
            await _bookService.UpdateAsync(book);
            return NoContent();
        }
        
        /// <summary>
        /// Deletes a book.
        /// </summary>
        /// <param name="id">Book identifier</param>
        /// <returns>No content</returns>
        /// <response code="204">Book deleted successfully</response>
        /// <response code="404">Book not found</response>
        [HttpDelete("{id}")]
        [ProducesResponseType(204)]
        [ProducesResponseType(404)]
        public async Task<IActionResult> DeleteBook(int id)
        {
            var exists = await _bookService.ExistsAsync(id);
            if (!exists)
            {
                return NotFound(new { message = $"Book with ID {id} not found" });
            }
            
            await _bookService.DeleteAsync(id);
            return NoContent();
        }
    }
}

Plain English:
"Create a method that queries a database for orders,
filters by date range and customer, includes related products,
calculates totals, and returns grouped results using LINQ."

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using OrderManagement.Models;

namespace OrderManagement.Services
{
    /// <summary>
    /// Service for querying and analyzing order data.
    /// </summary>
    public class OrderQueryService
    {
        private readonly ApplicationDbContext _context;
        
        /// <summary>
        /// Initializes a new instance of OrderQueryService.
        /// </summary>
        /// <param name="context">Database context</param>
        public OrderQueryService(ApplicationDbContext context)
        {
            _context = context;
        }
        
        /// <summary>
        /// Retrieves orders with totals grouped by customer.
        /// </summary>
        /// <param name="startDate">Start of date range</param>
        /// <param name="endDate">End of date range</param>
        /// <param name="customerId">Optional customer ID filter</param>
        /// <returns>List of customer order summaries</returns>
        /// <exception cref="ArgumentException">If date range is invalid</exception>
        public async Task<List<CustomerOrderSummary>> GetOrderSummaryAsync(
            DateTime startDate,
            DateTime endDate,
            int? customerId = null)
        {
            // Validate date range
            if (endDate < startDate)
            {
                throw new ArgumentException(
                    "End date must be greater than or equal to start date",
                    nameof(endDate)
                );
            }
            
            // Build query with optional customer filter
            var query = _context.Orders
                .Include(o => o.OrderItems)
                    .ThenInclude(oi => oi.Product)
                .Include(o => o.Customer)
                .Where(o => o.OrderDate >= startDate && o.OrderDate <= endDate);
            
            // Apply customer filter if provided
            if (customerId.HasValue)
            {
                query = query.Where(o => o.CustomerId == customerId.Value);
            }
            
            // Execute query and group by customer
            var results = await query
                .GroupBy(o => new
                {
                    o.CustomerId,
                    o.Customer.Name,
                    o.Customer.Email
                })
                .Select(g => new CustomerOrderSummary
                {
                    CustomerId = g.Key.CustomerId,
                    CustomerName = g.Key.Name,
                    CustomerEmail = g.Key.Email,
                    OrderCount = g.Count(),
                    TotalAmount = g.Sum(o => o.OrderItems.Sum(oi => oi.Quantity * oi.UnitPrice)),
                    AverageOrderValue = g.Average(o => o.OrderItems.Sum(oi => oi.Quantity * oi.UnitPrice)),
                    FirstOrderDate = g.Min(o => o.OrderDate),
                    LastOrderDate = g.Max(o => o.OrderDate),
                    ProductCount = g.SelectMany(o => o.OrderItems).Select(oi => oi.ProductId).Distinct().Count()
                })
                .OrderByDescending(s => s.TotalAmount)
                .ToListAsync();
            
            return results;
        }
    }
    
    /// <summary>
    /// Summary of customer orders within a date range.
    /// </summary>
    public class CustomerOrderSummary
    {
        /// <summary>Customer unique identifier</summary>
        public int CustomerId { get; set; }
        
        /// <summary>Customer full name</summary>
        public string CustomerName { get; set; }
        
        /// <summary>Customer email address</summary>
        public string CustomerEmail { get; set; }
        
        /// <summary>Total number of orders</summary>
        public int OrderCount { get; set; }
        
        /// <summary>Sum of all order amounts</summary>
        public decimal TotalAmount { get; set; }
        
        /// <summary>Average value per order</summary>
        public decimal AverageOrderValue { get; set; }
        
        /// <summary>Date of first order</summary>
        public DateTime FirstOrderDate { get; set; }
        
        /// <summary>Date of most recent order</summary>
        public DateTime LastOrderDate { get; set; }
        
        /// <summary>Number of unique products ordered</summary>
        public int ProductCount { get; set; }
    }
}