¶ New Project
Open a terminal and use dotnet --help to see available commands. Additionally, use dotnet new --help to view options available to the new project command.
Run the following command to view every type of project template for your SDK:
dotnet new --list
¶ Create a .NET Solution
A solution is a collection of projects. It is the glue that binds all of the individual projects into a logical unit.
dotnet new sln
¶ Create Core MVC Project
ASP.NET Core MVC is the Model-View-Controller architecture for the ASP.NET framework.
dotanet new mvc
¶ Using Rider
Open the Rider Project Launcher by opening the application without selecting an existing project. At the top, there will be a button to create a New Solution. Click it, and then select ASP.NET Core Web Application under the .NET/.NET Core section. The screen should look similar to the one below.
From here, you can specify the Solution Name and Project Name and it will create both the solution file and the project files for you. The Auth selector will allow you to choose a form of authentication that the project will automatically set up upon creation. By selecting Individual authentication, for example, the project will set up a database, user models, and a migration DTO.
¶ File Structure
New ASP.NET Core MVC project with individual authentication
/Solution
/Project
/Dependencies
/.NET 6.0
/Imports
/Properties
launchSettings.json
/Areas
/Identity
/Controllers
/Data
/Models
/Views
/Shared
/wwwroot
/css
/js
/lib
appsettings.json
appsettings.Development.json
Program.cs
- Dependencies — These are the files that make the framework function. They include all of the class files, libraries, and packages that make the app work. You generally do not need to interact with the content of this folder.
- Properties — By default, this just contains
launchSettings.jsonwhich specifies how the app is launched when you usedotnet runin the console or press the play button in an editor. - Areas — This is where the identity system lives. Identity is an API that support user interface login functionality. It manages users, passwords, profile data, roles, claims, tokens, emails, confirmation, and more.
- Controllers — These are the components that handle user interaction, work with the model, and ultimately select a view to render.
- Data — This is where the Migrations and
DbContextfiles live. These are the files that make up the connection and configuration of the application’s data source. - Models — These are the classes that represent the state of the application and any business logic or operations that should be performed by it.
- Views — These are templates that are responsible for presenting content through the user interface. In this particular ASP.NET architecture, these files are generally powered by the Razor view engine which will allow you to embed .NET code into HTML markup. Views have minimal imbedded logic, because the computation of dynamic content should be resolved in the controllers.
- wwwroot — This is where all of the static files live. These are generally the stylesheets, JavaScript files, JavaScript libraries, and frontend frameworks (like Bootstrap).
- appsettings.json/appsettings.Development.json — These are the general application settings for the project. By default they include connection strings, logging permissions, and allowed hosts. The development file is the non-production version of the configurations and will override the non-development file when the program is ran in “developer mode”. It is expected to be shared when working with other developers, so generally, it will not contain private information that is exclusive for a single developer’s workstation.
- Program.cs — This is the primary file that tells the framework that tells the framework how to start the application. It contains the connections to all of the Services, Exceptions, Middleware, Authentication, and more.
¶ Program.cs
The Program.cs file contains all of the instructions to start the application.
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using TestApp.Data;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlite(connectionString));
builder.Services.AddDatabaseDeveloperPageExceptionFilter();
builder.Services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
.AddEntityFrameworkStores<ApplicationDbContext>();
builder.Services.AddControllersWithViews();
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseMigrationsEndPoint();
}
else
{
app.UseExceptionHandler("/Home/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
app.MapRazorPages();
app.Run();
builder.Services.AddDbContext<>()— This is the method to establish a connection string with the data source, which in this case, is SQLite. The connection comes from theConfigurationclass which pulls fromappsettings.Development.jsonorappsettings.jsonrespectively.builder.Services.AddDefaultIdentity<>()— This method establishes a default Identity using Entity Frameworks data store. This is the authentication for user login.builder.Services.AddControllerWithViews()— This will look through the Controllers folder and add all controllers that have views to the services list. This is an automation to adding the controllers manually. It uses dependency injection to add the controllers as dependencies.app.UseMigrationsEndPoint()— If the app is in “Development Mode”, it will check if the database has any pending migrations and will apply them if needed. If it is not in development mode, throw an error to/Home/Error.app.UseHttpsRedirection()— Redirect users to the HTTPS protocol if accessing the site via HTTP.app.UseStaticFiles()— This enables access to the files inwwwroot.- Enable Routing, Authentication and Authorization
app.MapControllerRoute()— This defines the routes for accessing various views on the application and which controllers to pull form. Thedefaultroute (which defines the starting page when going to the root URL for the application) is mapped to theHomecontroller, which through naming conventions, knows to look forControllers/HomeController.cs.app.MapRazorPages()— This will scan for Razor pages and map their associated routes. Because this is technically a different routing configuration, the Razor routes should not contain similar names to the Controller routes.
¶ Controllers
HomeController.cs
using System.Diagnostics;
using Microsoft.AspNetCore.Mvc;
using TestApp.Models;
namespace TestApp.Controllers;
public class HomeController : Controller
{
private readonly ILogger<HomeController> _logger;
public HomeController(ILogger<HomeController> logger)
{
_logger = logger;
}
public IActionResult Index()
{
return View();
}
public IActionResult Privacy()
{
return View();
}
[ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
public IActionResult Error()
{
return View(new ErrorViewModel {RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier});
}
}
public HomeController(ILogger<HomeController> logger)— This is a the constructor that brings inILoggerof typeHomeController. ILogger is the default logging system inside .NET Core. The constructor brings in a logger and assigns it to a private immutable class variable.public IActionResult Index()— This is the default action. You should always have an Index Action on your controllers because (by default) the default route for each controller is always mapped to the Index action. This can be changed, however, inProgram.cs. This method just returns the View, which through naming conventions, knows to look forViews/Home/Index.cshtml.public IActionResult Privacy()— This is another action that returns the appropriate view if the Privacy route is accessed. By naming convention, theView()method will look forViews/Home/Privacy.cshtml.public IActionResult Error()— This will return a special view that pulls from theErrorViewModel. The decorator above the this method tells the framework that if this particular route is accessed, do not cache this page in the browser. That way it always has the latest information.
¶ Models
Models in ASP.NET are just about displaying data. They are used as a middle layer between Data Transfer Objects and Controllers. They are a place to manipulate the data that you retrieve from the database before the Controllers have access to it.
ErrorViewModel.cs
namespace TestApp.Models;
public class ErrorViewModel
{
public string? RequestId { get; set; }
public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
}
¶ Views
Views/Shared/_Layout.cshtml
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8"/>
<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
<title>@ViewData["Title"] - TestApp</title>
<link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.min.css"/>
<link rel="stylesheet" href="~/css/site.css" asp-append-version="true"/>
<link rel="stylesheet" href="~/TestApp.styles.css" asp-append-version="true"/>
</head>
<body>
<header>
<nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
<div class="container-fluid">
<a class="navbar-brand" asp-area="" asp-controller="Home" asp-action="Index">TestApp</a>
<button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target=".navbar-collapse" aria-controls="navbarSupportedContent"
aria-expanded="false" aria-label="Toggle navigation">
<span class="navbar-toggler-icon"></span>
</button>
<div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
<ul class="navbar-nav flex-grow-1">
<li class="nav-item">
<a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
</li>
<li class="nav-item">
<a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
</li>
</ul>
<partial name="_LoginPartial"/>
</div>
</div>
</nav>
</header>
<div class="container">
<main role="main" class="pb-3">
@RenderBody()
</main>
</div>
<footer class="border-top footer text-muted">
<div class="container">
© 2022 - TestApp - <a asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
</div>
</footer>
<script src="~/lib/jquery/dist/jquery.min.js"></script>
<script src="~/lib/bootstrap/dist/js/bootstrap.bundle.min.js"></script>
<script src="~/js/site.js" asp-append-version="true"></script>
@await RenderSectionAsync("Scripts", required: false)
</body>
</html>
@code — Any code that has an @ symbol before it will be rendered as C# code. This is considered part of the Razor Syntax, which is a small language of symbols that tell the framework to recognize parts of the code as C# instead of HTML inside the views.
<partial name="_LoginPartial"/> — This is essentially an injection of cshtml code into this specific part of the DOM. The name refers to the file in the same folder called _LoginPartial.cshtml.
Views/Shared/_LoginPartial.cshtml
@using Microsoft.AspNetCore.Identity
@inject SignInManager<IdentityUser> SignInManager
@inject UserManager<IdentityUser> UserManager
<ul class="navbar-nav">
@if (SignInManager.IsSignedIn(User))
{
<li class="nav-item">
<a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Manage/Index" title="Manage">Hello @User.Identity?.Name!</a>
</li>
<li class="nav-item">
<form class="form-inline" asp-area="Identity" asp-page="/Account/Logout" asp-route-returnUrl="@Url.Action("Index", "Home", new {area = ""})">
<button type="submit" class="nav-link btn btn-link text-dark">Logout</button>
</form>
</li>
}
else
{
<li class="nav-item">
<a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Register">Register</a>
</li>
<li class="nav-item">
<a class="nav-link text-dark" asp-area="Identity" asp-page="/Account/Login">Login</a>
</li>
}
</ul>
This will add links to the navigation bar based on if the user is logged in or not. If you are not logged in, the view will show to links to Register and Login, but if you are logged in, it will display your name and a link to logout.