Web Application Development with .NET

Last updated: October 26, 2023 | Author: Microsoft Docs Team

This tutorial series provides a comprehensive guide to building robust and scalable web applications using the .NET ecosystem. We'll cover essential concepts, popular frameworks, and best practices to help you create modern web experiences.

.NET Web Development ASP.NET Core C# Tutorial

Table of Contents

1. Introduction to .NET Web Development

The .NET platform offers a powerful and versatile set of tools and frameworks for building web applications. Whether you're creating simple websites, complex enterprise applications, or RESTful APIs, .NET has you covered. The primary framework for modern web development in .NET is ASP.NET Core, a high-performance, open-source, cross-platform framework for building web UIs and web APIs.

2. Setting Up Your Development Environment

Before you start coding, you need to set up your development environment. This typically involves installing:

  • .NET SDK: Download and install the latest .NET SDK from the official Microsoft .NET website.
  • Code Editor: Visual Studio Code with the C# and IntelliCode extensions is highly recommended for a great cross-platform experience. Visual Studio (Windows) offers a more integrated IDE experience.
  • IDE (Optional): Visual Studio Community Edition is a free, full-featured IDE for Windows.

Verify your installation by opening a terminal or command prompt and running:

dotnet --version

3. Understanding the MVC Pattern

Many .NET web applications utilize the Model-View-Controller (MVC) architectural pattern. This pattern separates the application into three interconnected components:

  • Model: Represents the data and business logic of the application.
  • View: Responsible for presenting the data to the user.
  • Controller: Handles user input, interacts with the Model, and selects the appropriate View to render.

ASP.NET Core also introduces Razor Pages, a simpler page-centric model that is excellent for forms and simpler web interfaces.

4. Creating Razor Pages and Views

In ASP.NET Core, you can create web pages using:

  • Razor Pages: A page-focused programming model. Each Razor Page is a .cshtml file combined with a .cshtml.cs code-behind file.
  • MVC Views: Typically found in the Views folder, these are .cshtml files that work in conjunction with controllers.

Here's a simple example of a Razor Page (Index.cshtml):

@page
@model IndexModel
@{
    ViewData["Title"] = "Home Page";
}

<div class="text-center">
    <h1 class="display-4">Welcome</h1>
    <p>Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
</div>

And its corresponding code-behind (Index.cshtml.cs):

using Microsoft.AspNetCore.Mvc.RazorPages;

namespace MyWebApp.Pages
{
    public class IndexModel : PageModel
    {
        public void OnGet()
        {
        }
    }
}

5. Routing and URL Handling

Routing maps incoming HTTP requests to the appropriate handler (Controller Action or Razor Page). ASP.NET Core uses a convention-based and attribute-based routing system.

In Startup.cs (or Program.cs in .NET 6+), you configure the routing middleware:

app.UseRouting();
app.UseEndpoints(endpoints =>
{
    endpoints.MapRazorPages(); // For Razor Pages
    endpoints.MapControllerRoute(
        name: "default",
        pattern: "{controller=Home}/{action=Index}/{id?}"); // For MVC Controllers
});

6. Data Binding and Model Handling

Data binding simplifies the process of transferring data between the user interface and the application's model. ASP.NET Core's model binders can automatically map incoming request data (form values, route data, query strings) to C# objects.

Example Model:

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

Controller Action that accepts a Product model:

[HttpPost]
public IActionResult Create(Product product)
{
    // Process the product data
    return RedirectToAction("Index");
}

7. Handling Forms and User Input

Forms are fundamental to web applications. ASP.NET Core provides robust support for creating, submitting, and processing HTML forms. You can use HTML helpers or tag helpers to generate form elements.

Example Form in a View:

<form method="post">
    <div class="form-group">
        <label asp-for="Product.Name"></label>
        <input asp-for="Product.Name" class="form-control" />
    </div>
    <div class="form-group">
        <label asp-for="Product.Price"></label>
        <input asp-for="Product.Price" class="form-control" />
    </div>
    <button type="submit" class="btn btn-primary">Save</button>
</form>

The asp-for tag helper automatically binds to the specified model property.

8. Working with Databases (Entity Framework Core)

Entity Framework Core (EF Core) is a modern object-relational mapper (ORM) for .NET. It allows you to work with databases using C# objects, abstracting away much of the SQL code.

First, install the necessary NuGet packages:

dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools

Define your DbContext and entities:

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options) { }
    public DbSet<Product> Products { get; set; }
}

Configure the database connection in appsettings.json and Startup.cs (or Program.cs).

9. Authentication and Authorization

Securing your web application is crucial. ASP.NET Core Identity provides a robust membership system for handling user authentication and authorization.

  • Authentication: Verifying the identity of a user.
  • Authorization: Determining if an authenticated user has permission to perform an action or access a resource.

You can implement various authentication schemes like cookies, JWT Bearer tokens, OAuth, and more.

10. Building Web APIs

ASP.NET Core excels at building RESTful Web APIs. You can create controllers that return data in formats like JSON or XML, consumed by SPAs, mobile apps, or other services.

Example API Controller:

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;

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

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

    [HttpGet]
    public IEnumerable<Product> GetProducts()
    {
        return _context.Products.ToList();
    }
}

11. Deployment and Hosting

Once your application is built, you'll need to deploy it. ASP.NET Core applications can be deployed to various environments, including:

  • Windows Servers with IIS
  • Linux Servers with Nginx or Apache
  • Cloud Platforms like Azure, AWS, Google Cloud
  • Containerization with Docker

The dotnet publish command is used to create deployment artifacts.

Related Links