
https://github.com/gavilanch/BlazorMovies
Blazor lets you build interactive web apps with .NET using WebAssembly. You can run it client-side in the browser or server-side with SignalR, in any modern browser.
Explore how Razor syntax blends C# and HTML in a single file, enabling variable, method, and class declarations, loops, conditionals, and dynamic HTML rendering with MarkupString.
Explore arbitrary parameters in Blazor components using IDictionary and CaptureUnmatchedValues, enabling attribute splatting and handling undeclared parameters like placeholder and disabled in a custom dummy textbox.
JavaScript isolation loads JavaScript modules on demand, loading them only when a user navigates to a component, and invokes them from C# to keep the global state clean and efficient.
Explore cascading parameters in Blazor by defining AppState values in a main layout, accessing them with cascading parameters, and propagating color and size across components.
Clean up a Blazor app by removing unused services and components, then implement a poster-based movie list with a horizontal layout, title shortening, and admin-specific actions to improve UI.
Learn how Blazor route parameters bind to url segments using an int movieId. Explore string route names, 404 behavior, and titles with dashes for movie details.
Learn how to implement lazy loading in Blazor by deferring assembly downloads until needed, loading the Massenet numerics library only when navigating to the counter component.
Explore building forms in Blazor using model-based validations with data annotations, implement data binding, and create reusable components with text boxes, plus dynamic elements like multiple selectors.
Learn to create and post genres using a centralized HTTP service with a generic HTTP response wrapper, a genre repository, and a server-side API controller that saves to the database.
Learn to create a people controller and repository in a Blazor ASP.NET Core 5 app, wire services, and test with sample entry before saving a picture in the next video.
offers an alternative to Azure storage by saving images to the www root directory on the local computer, implemented via a local file storage service with dependency injection.
Create and submit a movie form by mapping selected genres and actors, add a temporary character field, and wire a movies repository with async API calls for movie details.
Implement server-side pagination in Blazor ASP.NET Core 5 by calculating total pages from the record count, enforcing records per page, and exposing results via a reusable helper and API response.
Use hdd client service to create a vb request class with configuration, build a database from models, store images as blobs, segment results, and filter or sort queries with core.
Use AuthorizeView to conditionally render the user interface for authenticated versus anonymous users, and leverage claims (name, role) to customize content and hide buttons and menu items based on authorization.
Configure ASP.NET Core Identity with Entity Framework Core, create identity tables, and implement JWT-based authentication and authorization via an accounts controller.
Build authentication components in a Blazor app, including register, login, and logout, with a logging links component, accounts repository, and API calls for user tokens.
Migrate the blazer movies app to identityserver4 by updating packages, configuring identity in startup, scaffolding identity pages, configuring the client, and aligning the front-end to authenticate via identity server.
Learn how to deploy a Blazor app with its web API in one place, evaluate cheaper client-only publishing versus full deployment, and automate publishing with Azure DevOps.
Deploy a Blazor app on Azure App Service using IdentityServer4, resolve production certificate setup by generating and uploading a self-signed certificate, and configure the identity store for secure token signing.
Learn to deploy a Blazor WebAssembly app to Azure Storage by enabling static website hosting, publishing the app, and uploading the static files with Storage Explorer.
Learn continuous delivery with Azure DevOps, automating build, test, and deployment to staging or production from the main branch, using GitHub pipelines and migrations.
Deploy a Blazor application so end users can access it, either with or without its web API, and automate the deployment process to publish websites.
Learn how to register routable components from multiple Razor class library assemblies in a Blazor app using the router's additional assemblies feature.
Pass data to routable components using cascading parameters and cascading values in Blazor. Define and retrieve ancestor data across components for reusable code in dual architecture contexts.
Migrate the Blazor Movies components into a shared Razor class library to enable a dual architecture and reuse components across server-side and client-side Blazor applications.
Discover how to use JavaScript in Blazor Server apps, avoiding initialization-time calls and using OnAfterRender with first render checks and a display message service for safe interop.
We adopt a dual architecture to share front-end code and a shared data access layer using entity framework core between blazor web assembly and blazor server side apps.
Implement the genres entity in the backend by building a repository, wiring it with dependency injection, and enabling crud operations through the controller.
Deploy a Blazor server-side app to Azure App Service and configure Azure SignalR for real-time communication by setting the connection string and sticky mode, then publish and connect to database.
Blazor is a Microsoft technology that allows us to make interactive web applications with C# without using JavaScript.
In this course we will learn to develop web applications with Blazor.
Throughout the course we will create an application applying what has been learned.
We will go from the basics to the advanced. We will create forms, components, entities, relations with our entities, and user system with roles and more.
We will use an ASP.NET Core 5 application to serve our Blazor project, and with Entity Framework Core 5 we will create our database.
In the end, we will use Azure services, such as Azure App Service and Azure DevOps, to publish our application to production.
This is some of the things that we'll learn in the course:
- Creating a new Blazor project
- Review Razor syntax
- Learn how to work with components
- Reusing code using components
- Pass parameters to components
- Execute events from components to send messages to the parent component
- Use dependency injection
- Invoking JavaScript code from C#
- Invoking C# code from JavaScript
- Use routing to allow users to navigate in our page
- Building forms with validations
- Communicate from the front-end to the back-end using HTTP
- Creating a database and interacting with it using Entity Framework Core
- Creating a user system so that users can log in our app
- Deploy our web app into a production environment