Front-end Web Development with .NET for Beginners
.NET makes front-end web development easy with Blazor, a modern frontend web framework based on HTML, CSS, and C#. In this video series we'll learn the basics of frontend web development with Blazor…
- 8.4K likes on YouTube
- 756.5K views
Created by dotnet on YouTube
What you'll learn
- ASP.NET Core • What it is
- What Blazor is
- Setting up a development environment
- Components and Razor files
- Routing with the @page directive
- Project structure
- Handling UI events
- Data binding with @bind
Explore related topics
Course content
01What is ASP.NET Core? | Web Development with .NET for BeginnersPreview02:17
This chapter introduces ASP.NET Core, a modern, open-source framework from Microsoft for building fast and secure web applications. Hosts Daniel Roth and Safia Abdullah explain that it can power interactive web user interfaces, back-end services, and small or large-scale web apps. It is free to use and works across different platforms.
- ASP.NET Core • What it is
- ASP.NET Core • Key features and built-in components
- C# • Language choice for web development
- .NET • Building many kinds of applications
- ASP.NET Core • Real-world usage
- ASP.NET Core • Next steps: Minimal APIs and Blazor
02What is Blazor? [Pt 1] | Front-end Web Development with .NET for BeginnersPreview01:11
This chapter introduces Blazor, presented by Daniel Roth, Product Manager for Blazor at Microsoft. Blazor is a modern front-end web framework that lets you build web apps using HTML and C#, which helps you build web apps faster. Instead of writing everything in separate languages for each part of an app, you can use C# throughout.
- What Blazor is
- Components
- Client and server hosting
- Relationship to .NET
- Web Development • Front-end frameworks
03Build and run your first Blazor web app [Pt 2] | Front-end Web Development with .NET for BeginnersPreview09:34
This chapter walks through setting up a development environment and creating a first Blazor web app. Daniel Roth from the Blazor team starts at blazor.net, where the Blazor tutorial gives instructions for Windows, Mac, and Linux. On Windows, the easiest route is Visual Studio Community with the web development workload, then the Blazor Web App template. The template creates a project with a home page, a counter page, and a weather page. The app is run with the green play button, which builds it and starts the debugger.
- Setting up a development environment
- Creating a Blazor Web App with Visual Studio
- Creating and running a project from the command line
- dotnet run vs dotnet watch
- Hot reload
- Developing with Visual Studio Code
04Introducing Blazor Components [Pt 3] | Front-end Web Development with .NET for BeginnersPreview12:33
This chapter introduces components in Blazor, Microsoft's .NET framework for building interactive web user interfaces. A component is a reusable piece of web UI that holds both its rendering logic and the code that handles its UI events. Components are written in Razor files (.razor), which mix HTML markup with C# code. The presenter shows the project's components folder, including Home, Counter, and Weather, and explains the @page directive, which assigns a route so a component is shown at a URL. The PageTitle component is a built-in component that sets the browser tab title. Components can be reused inside other components by writing their name as a custom HTML-style tag, such as a Counter or Weather tag placed on the Home page.
- Components and Razor files
- Routing with the @page directive
- Mixing C# and HTML with Razor syntax
- Event handlers and re-rendering
- Control flow in Razor
- Component parameters
05Pages, Routing, and Layouts in Blazor [Pt 4] | Front-end Web Development with .NET for BeginnersPreview12:44
This chapter covers how Blazor controls page routing and shared layouts. A component becomes a page when you add the @page directive at its top, and that directive sets its URL. A component can have several @page directives, so one component can respond to several URLs.
- Routing with the @page directive
- Route parameters and constraints
- The Router and App components
- Layouts and @Body
- NavLink and active styling
06Blazor Web App Project Structure [Pt 5] | Front-end Web Development with .NET for BeginnersPreview07:28
This chapter walks through the structure of a Blazor Web App project created with .NET. It explains that the project file (.csproj) holds build settings such as the target framework version and package references. The entry point is Program.cs, which creates a web application builder, registers services for dependency injection, sets up middleware such as HTTPS redirection, static files and antiforgery protection, and maps Razor components so the root component App.razor can be served. The run step then starts the app.
- Project structure
- Program.cs and app startup
- Components and pages folder
- Configuration files
- Static files in wwwroot
- _Imports.razor
07Handling UI Events in Blazor Web Apps [Pt 6] | Front-end Web Development with .NET for BeginnersPreview18:30
This chapter of the Blazor course explains how to handle UI events in Blazor components. It starts with the counter button's onclick event and shows that event handlers can be synchronous or asynchronous, can take an optional event argument such as MouseEventArgs, or can be written as inline lambda expressions. Visual Studio's code actions (the light bulb or Ctrl+.) can generate these handlers for you.
- Handling UI events
- Event handler patterns (sync, async, lambda)
- Input events (onchange vs oninput)
- Custom component events with EventCallback
- Child content with RenderFragment
- Capturing extra attributes
08Data Binding in Blazor Web Apps [Pt 7] | Front-end Web Development with .NET for BeginnersPreview15:30
This chapter introduces data binding in Blazor Web Apps, using a small counter-page example. It starts by reading an input's value with an onchange event handler and writing it back by setting the input's value attribute manually. The instructor then shows the simpler approach: the @bind directive ties an input's value to a C# field in both directions, so typing updates the field and changing the field updates the input. The chapter also covers changing the triggering event with @bind:event="oninput" so updates happen on every keystroke, and running code after a binding updates with @bind:after.
- Data binding with @bind
- Event handling and manual value updates
- Changing the bind event with @bind:event
- Running code after binding with @bind:after
- Rendering lists and handling forms in a to-do app
- Interactive render mode for UI events
09Blazor Component Render Modes [Pt 8] | Front-end Web Development with .NET for BeginnersPreview20:23
This chapter explains Blazor component render modes, which control how components are rendered and how they respond to users. By default, Blazor components use static server-side rendering (static SSR): the server generates plain HTML, sends it to the browser, and the component instance is discarded, so no state is kept on the server. Static components are ideal when content does not need to respond to UI events. Blazor can still improve static pages with enhanced navigation, which uses fetch requests and patches only the changed parts of the DOM, and optional enhanced form handling. Streaming rendering lets a page show placeholder content immediately, then send updates over the same connection when long-running async tasks finish.
- Static server-side rendering
- Enhanced navigation and streaming rendering
- Interactive Server rendering
- Interactive WebAssembly and Auto render modes
- Applying render modes to components and whole apps
10Work with Data in Blazor [Pt 9] | Front-end Web Development with .NET for BeginnersPreview15:30
This chapter shows how to connect a Blazor web app to a database and display its data with almost no hand-written code. The presenter starts a Blazor Web App in Visual Studio 17.9 or later, adds an existing Movie class as a simple data model, and uses the built-in scaffolder to generate create, read, update, and delete (CRUD) pages. The scaffolder also creates an Entity Framework Core DbContext, which is the type that links .NET objects to a database.
- Scaffolding CRUD pages
- Entity Framework Core • DbContext and migrations
- QuickGrid columns, sorting, and formatting
- Render modes and interactivity
- Pagination with PaginationState
- Filtering with data binding and LINQ
11Forms & Validation in Blazor Web Apps [Pt 10] | Front-end Web Development with .NET for BeginnersPreview09:47
This chapter introduces building forms in Blazor Web Apps using the built-in EditForm component. Forms let users submit data such as search queries, new records, or edits to existing data. EditForm renders a normal HTML form tag but binds it to a data model passed in through the Model parameter. The model property is marked with the SupplyParameterFromForm attribute, so incoming form data is bound to that object. The OnValidSubmit callback runs only after the data passes validation. A FormName is needed when a page has several forms, so Blazor knows which form data belongs to which model. The Enhance attribute makes form submission use a fetch request, and Blazor patches the response into the page, similar to enhanced navigation.
- EditForm and model binding
- Input components and @bind-Value
- Data annotation validation
- Form options (FormName, Enhance, render mode)
Description
.NET makes front-end web development easy with Blazor, a modern frontend web framework based on HTML, CSS, and C#. In this video series we'll learn the basics of frontend web development with Blazor, including how to set up your development environment, create a new project, run & debug, and work with Blazor components.
About the creator
- YouTube channel
- 357K subscribers
- 1 course on Studyio
The videos in this course are made by dotnet and play from YouTube, credited to them. Studyio adds the chapters, notes, quizzes and a certificate around them.





