Scaffolding in C# 9.0: Building Fast & Efficient Code Structures

Introduction

Scaffolding is a powerful feature in software development that automates the generation of code and project structures, helping developers quickly set up the foundation of an application. In the context of C# 9.0, scaffolding has seen significant enhancements that streamline the development process and improve productivity. This article deep dive into the concept of scaffolding in C# 9.0, exploring its benefits and features and providing practical code snippets to illustrate its usage.

Understanding Scaffolding

Scaffolding is the process of generating boilerplate code and structures based on predefined templates. It helps developers by automating repetitive tasks, thus allowing them to focus on the core logic and functionality of the application. In C#, scaffolding is commonly used in conjunction with ASP.NET Core, where it generates controllers, views, and models, setting up a basic CRUD (Create, Read, Update, Delete) operations framework.

The Evolution of Scaffolding in C#

The concept of scaffolding has been present in various forms in the C# ecosystem for quite some time. With each iteration, the tools and frameworks supporting scaffolding have evolved, becoming more sophisticated and user-friendly. C# 9.0, released as part of .NET 5, introduces new features and improvements that make scaffolding even more powerful.

Key Features of Scaffolding in C# 9.0

• Simplified Syntax: C# 9.0 introduces simplified syntax and patterns that make the scaffolding process more intuitive. Features like records, with-expressions, and improved pattern matching contribute to cleaner and more concise code generation.
• Enhanced Performance: The underlying scaffolding engine has been optimized for performance, resulting in faster code generation and reduced build times.
• Improved Customization: Developers can now customize scaffolded code more easily, tailoring it to meet specific project requirements. This includes custom templates and options for modifying generated code structures.

Setting Up Scaffolding in a C# 9.0 Project

To get started with scaffolding in a C# 9.0 project, we need to set up your development environment with the necessary tools and packages.

Step 1. Ensure you have the .NET 8 SDK installed and create a new ASP.NET Core project.

dotnet new webapp -n MyScaffoldedApp
cd MyScaffoldedApp

Step 2. Add the required scaffolding package to your project.

dotnet add package Microsoft.VisualStudio.Web.CodeGeneration.Design

Step 3. Generating a Scaffolded Controller.

With the setup complete, you can use the scaffolding tools to generate a controller and associated views for a model. For this example, let's create a simple Product model.

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public string Description { get; set; }
}

Step 4. To generate a controller and views for the Product model, use the following command.

dotnet aspnet-codegenerator controller \
  -name ProductsController \
  -m Product \
  -dc ApplicationDbContext \
  --relativeFolderPath Controllers \
  --useDefaultLayout \
  --referenceScriptLibraries

This command generates a ProductsController along with the associated CRUD views, creating a complete set of pages to manage Product entities.

Customizing Scaffolded Code

One of the strengths of scaffolding in C# 9.0 is the ability to customize the generated code. You can modify the templates used by the scaffolding engine to fit your project's specific needs. For example, if you want to change the default layout of the generated views, you can create custom Razor templates and specify them during the scaffolding process.

Step 1. Consider an ASP.NET Core application that manages a list of books. First, define the Book model.

public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Author { get; set; }
    public decimal Price { get; set; }
}

Step 2. Generate a scaffolded API controller.

dotnet aspnet-codegenerator controller 
    -name BooksController 
    -m Book 
    -api 
    -dc ApplicationDbContext 
    --relativeFolderPath Controllers 
    --useDefaultLayout 
    --referenceScriptLibraries

This command creates a BooksController with API endpoints for managing books. The scaffolded controller includes methods for GET, POST, PUT, and DELETE operations.

[ApiController]
[Route("api/[controller]")]
public class BooksController : ControllerBase
{
    private readonly ApplicationDbContext _context;

    public BooksController(ApplicationDbContext context)
    {
        _context = context;
    }

    [HttpGet]
    public async Task<ActionResult<IEnumerable<Book>>> GetBooks()
    {
        return await _context.Books.ToListAsync();
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<Book>> GetBook(int id)
    {
        var book = await _context.Books.FindAsync(id);

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

        return book;
    }

    [HttpPost]
    public async Task<ActionResult<Book>> PostBook(Book book)
    {
        _context.Books.Add(book);
        await _context.SaveChangesAsync();

        return CreatedAtAction("GetBook", new { id = book.Id }, book);
    }

    [HttpPut("{id}")]
    public async Task<IActionResult> PutBook(int id, Book book)
    {
        if (id != book.Id)
        {
            return BadRequest();
        }

        _context.Entry(book).State = EntityState.Modified;

        try
        {
            await _context.SaveChangesAsync();
        }
        catch (DbUpdateConcurrencyException)
        {
            if (!BookExists(id))
            {
                return NotFound();
            }
            else
            {
                throw;
            }
        }

        return NoContent();
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteBook(int id)
    {
        var book = await _context.Books.FindAsync(id);
        if (book == null)
        {
            return NotFound();
        }

        _context.Books.Remove(book);
        await _context.SaveChangesAsync();

        return NoContent();
    }

    private bool BookExists(int id)
    {
        return _context.Books.Any(e => e.Id == id);
    }
}

Conclusion

Scaffolding in C# 9.0 provides developers with a powerful tool to quickly generate boilerplate code and project structures, saving time and reducing the likelihood of errors. By leveraging the enhancements in C# 9.0 and the .NET 5 ecosystem, scaffolding becomes an indispensable part of the development process, allowing developers to focus on building high-quality, robust applications. Whether you are creating simple CRUD operations or complex APIs, scaffolding in C# 9.0 offers a streamlined and efficient way to kickstart your projects.