Asp.Net Core 10 (.NET 10) | True Ultimate Guide

Install Visual Studio Community 2022 and the ASP.NET and web development workload to begin ASP.NET Core development; note SQL Server and Postman as prerequisites.

Create your first ASP.NET Core web app using the empty template, and learn about Program.cs, WebApplicationBuilder, and minimal middleware to return Hello World on localhost.

Explore Kestrel, the default cross-platform HTTP server for ASP.NET Core, and learn how it serves development requests while production relies on reverse proxies like IIS, Nginx, or Apache.

Configure launchsettings.json to switch between Kestrel and IIS Express, define profiles, ports, and environment variables for local development, with Kestrel as the default server.

Explore the HTTP protocol, its request-response model between browsers and the Kestrel server, including HTTPS, headers, and status codes, with browser developer tools to inspect requests.

Learn how http responses are structured in the http protocol, including the start line, status codes, and response headers, and observe the response body via the browser network tab.

Master common HTTP status codes (200, 302, 304, 400, 401, 404, 500) and learn to send responses using the HTTP context, status codes, and writeAsync in ASP.NET Core.

Learn how to read and set http response headers in an ASP.NET Core app using the response headers collection, including content type, date, server, cache-control, and location.

Explore how an HTTP request moves from browser to server, including the start line, URL, headers, and body, and how ASP.NET Core exposes these details via context.request.

Understand how the query string passes parameters from browser to server and how to read them with request.query in asp.net core, using id and name examples.

Explore how request headers convey browser information to the server, including accept, content-type, and user-agent. Read these headers in ASP.NET Core via request.headers and use Postman to add them.

Learn how to test ASP.NET Core apps and Web API controllers with Postman, sending diverse request bodies, inspecting headers and responses, and using custom headers for authorization during the course.

Compare get and post by examining their intentions and request bodies; get retrieves data, while post sends data in the request body as json, xml, or form data.

Learn to read the ASP.NET Core request body programmatically with a stream reader and readToEndAsync, then parse the query string into a dictionary using QueryHelpers for post requests.

Understand how middleware forms an application pipeline that handles requests and responses, with individual components performing single operations like https redirection, static files, authentication, and authorization.

Demonstrates building an empty ASP.NET Core project and implementing a terminating middleware with app.Run, using an async lambda and HTTP context to return a hello response.

Learn how to chain middlewares in an ASP.NET Core app using app.use and app.run, passing the HTTP context to the next middleware and conditionally short-circuiting the pipeline.

Create a custom middleware class implementing imiddleware to define invokeAsync, then register it as a transient service and use app.useMiddleware to run in the proper request pipeline order.

Implement a custom middleware and expose it via a static extension method on the web application, enabling useMyCustomMiddleware to inject it into the request pipeline with next.

Create a conventional asp.net core 6 middleware using a plain class with constructor-injected next and an invokeAsync context to read firstName and lastName and respond with a hello fullName.

Discover the recommended middleware order in ASP.NET Core, from exception handling and HSTS to static files, routing, authentication, authorization, and custom middlewares, ensuring secure, correct endpoint processing.

Learn how useWhen branches the middleware pipeline in ASP.NET Core based on a condition, executing a branch when true and continuing the main chain when false.

Learn how routing matches HTTP methods and URLs to endpoints in ASP.NET Core, with automatic routing and endpoints defined directly on the app via map methods.

Map endpoints with the map family (map, mapGet, mapPost) on the app object, routing requests to the matching middleware. Use mapFallback for unmatched URLs and distinguish endpoints by HTTP method.

Define and read route parameters in ASP.NET Core by using fixed literals and braces for variables, then access values via route values in endpoints like files/{filename}.{ext} and employee/profile/{employeeName}.

Discover how default route parameters work in asp.net core 10, with employee name defaulting to Scott and product id defaulting to 1.

Learn how to define optional parameters by suffixing with a question mark, defaulting to null, and handle not supplied cases using request.root values and conditional responses.

Master route constraints in ASP.NET Core to restrict parameter values to types like int and date time, ensuring correct routes or a fallback via the daily digest example.

Enforce route constraints with decimal and GUID IDs in ASP.NET Core. Create cities/{cityId} endpoints, extract from request.routeValues, convert to GUID, and respond.

Explore route constraints in ASP.NET Core, using min length, max length, length, range, alpha, and regex to validate route segments with practical examples like employee name and sales report.

Implement a custom route constraint class in ASP.NET Core, using a match method to validate month values with a regular expression, and register it under a months constraint.

Discover how endpoint routing selects a matching route using four precedence rules: more URL segments, literal text over parameters, constrained templates over unconstrained, and catch-all least preferred.

Learn how to serve static content in ASP.NET Core by enabling useStaticFiles, using wwwroot by default, and configuring custom webroot paths or multiple folders with a physical file provider.

Learn to organize endpoints with controllers in ASP.NET Core 10, enable controllers as services, and apply attribute routing to map actions like say hello.

Discover attribute routing and default routes for empty URL, map multiple routes to one action method, apply parameters, constraints, and regular expressions with escaping and returning IActionResult in ASP.NET Core.

Suffix the class name with controller or apply the controller attribute to mark a controller, then use addControllers and mapControllers for routing and request handling.

Understand ContentResult in ASP.NET Core 10, returning various content types by specifying content and MIME type, using the shortcut content method on controllers.

Learn to return json data as key-value pairs from an asp.net core controller by converting a model object to json and using jsonresult or the json shorthand for application/json response.

Learn three file result types in asp.net core: virtual file, physical file, and file content results, plus using shortcut file methods for efficient responses.

Use IActionResult as the action return type to return any content, JSON, or file result, since it is the parent interface for all ASP.NET Core action results.

Use status code results to return bad request, unauthorized, and not found without manually setting status codes. Return methods automatically set 400, 401, or 404, with optional messages.

Demonstrates redirecting an old url bookstore to store/books using redirect to action result, and explains 301 vs 302 and permanent versus temporary redirects and the location header.

Explore 301 and 302 redirects in asp.net core 10, using RedirectToAction, RedirectToActionPermanent, and LocalRedirect, including route values like id, and distinguish local redirects from redirects to another domain.

Explain how ASP.NET Core model binding retrieves data from request sources such as headers, query strings, body, and route parameters, and how to specify exact sources and binding priority.

Learn how ASP.NET Core model binding prioritizes route data over query string parameters, mapping route parameters to action method inputs and handling optional values when data is missing.

Explore how model binding prioritizes route data over query strings by default, and how to override with from route or from query attributes for action parameters.

Discover how ASP.NET Core model binding automatically creates a Book object from route data and query strings, binding BookId and Other, with optional post data handling.

Explore how form fields in html forms are submitted and bound to models. Distinguish form url encoded from form data, their content types, and how route data affects binding.

Learn to replace repetitive inline validations with model validations using data annotation attributes like [Required], letting model binding create a person object and run validation after binding.

Explore how model state in the controller base tracks validation results after model binding, exposing is valid, values, and error count to return detailed bad requests with error messages.

Explore all validation rules in ASP.NET Core 10, including required, range, stringLength, and compare attributes, and how display name and string.Format generate dynamic error messages.

Apply regular expression attributes to enforce alphabets or numbers and formats like email or phone, with customizable error messages; use compare and required attributes with model binding for validation.

Derive a custom validation attribute from the validation base class and override isValid, then configure dynamic error messages via a constructor for reusable model validation during binding.

Develop a custom cross-field validator by creating DateRangeValidatorAttribute to compare fromDate to toDate using reflection and validation context, ensuring fromDate is older than or equal to toDate.

Implement IValidatableObject to perform model-specific validation inside the model class, validating that either date of birth or age is provided, using yield to return validation results after binding.

Use the bind attribute to specify which properties participate in model binding, preventing overposting. Exclude specific fields with bind never, and use the name of operator for dynamic property listing.

Learn how to build custom model binders to handle complex data binding with IModelBinder, BindModelAsync, and value providers, enabling concatenation of first and last names and parsing composite fields.

Create a global custom model binder by implementing a binder provider that binds person type parameters across the app, and register it at the first position in program.cs.

Learn how built-in model binding accepts multiple values for the same key by binding to a string list or array using indexed inputs like tags[0], tags[1], in ASP.NET Core.

Learn how to read request headers via model binding in ASP.NET Core 10 using the FromHeader attribute to bind the User-Agent header into an action parameter.

Understand how to receive JSON or XML data in ASP.NET Core by applying the FromBody attribute to enable input formatters that parse the request body into a model object.

Learn how ASP.NET Core uses input formatters to transform request bodies into model objects, automatically reading JSON with the JSON input formatter or XML with XMLSerializerInputFormatter.

Explain how the model-view-controller pattern separates concerns by routing requests to controllers, invoking business models and view models, and rendering HTML via views with data passed through a view model.

Discover how ASP.NET Core views render HTML by combining server-side C# with client-side HTML, guided by controllers passing a ViewModel to determine the appropriate view.

Master razor code blocks and razor expressions to render server-side logic in asp.net core views, declare c-sharp variables, and print dynamic data that becomes plain html for the browser.

Demonstrate conditional rendering in razor views using the if statement, handling nullable date of birth, and printing content only when conditions are met, with else and nested if possibilities.

Navigate switch in razor views to print html content based on a gender enum, including default handling and dynamic output in index.chhtml.

Explore how to use the for-each loop in Razor to render HTML from a collection, generating repeated divs, list items, or table rows on the server.

Learn to use the for loop in c# to repeat an html tag or read a collection by index, compare for with foreach, and briefly cover while and do-while loops.

Learn to print static text in razor without converting it to c-sharp code by using the right colon, text tag, or a div or span.

Use local functions in a Razor view to create reusable C# code that computes age from a nullable date of birth and prints it within the same view.

Learn how html.raw allows executing stored html or JavaScript in ASP.NET Core by bypassing default sanitization, with a caution about security when code comes from user input.

Learn how the controller supplies data to the view with ViewData, a key-value dictionary. Read and cast ViewData to access app title and a people list in the view.

Explore passing data from controller to view with ViewData, compare it to ViewBag, and apply custom css from wwwroot to render boxes and a table.

Master view bag in asp.net core 10 to access view data without explicit typecasting, using dot notation, while understanding dynamic types, null handling, and compatibility with view data.

Learn how strongly typed views tightly bind to a specific model class with the at model directive, enabling direct access to the controller-supplied model object or collection in the view.

Learn how to implement strongly typed views in ASP.NET Core by binding a single person model, wiring details routes, and generating dynamic links for person details.

Learn to bind two models to a single strongly typed view via a wrapper model, exposing PersonData and ProductData in ASP.NET Core.

Learn how to centralize namespace imports with _viewimports.cshtml, so the models namespace becomes available across all views. Distinguish global versus local view imports and understand their execution order.

Place a shared view in the views/shared folder to be accessible from any controller, with the framework first checking the controller-specific folder before the shared folder.

Create a shared layout in ASP.NET Core to unify header, sidebar, and footer via _layout.cshtml and render body content across views, with wwwroot assets from HomeController and ProductsController.

Create an index view named index.cshtml in the home controller, connect it to the shared layout via the layout property, and render the merged output with the render body.

Create multiple pages like home, about, contact, and products with razor views and a shared layout (views/shared/_layout.cshtml) to apply navigation and CSS across controllers.

Explore how view data passes from controller to view and into the layout view in ASP.NET Core 10, enabling shared data like title across views via a dictionary.

Explore how __viewstart.cshtml sets a common layout across views, with global settings overridden by local viewstart or individual views. Understand execution order and folder-specific overrides for efficient, centralized layout management.

Learn to dynamically set a view's layout based on a condition, using the view bag and a product ID in the route to switch between products layout and underscore layout.

Learn how ASP.NET Core layout view sections let you supply content from views, render it in the layout, and include scripts or side content like a photo area or sidebar.

Master nested layout views by applying one layout inside another, using underscore master layout, underscore layout, and underscore products layout to share a common structure.

Learn to create and reuse partial views in ASP.NET Core, call them with tag helpers or HTML helpers, and compare partial tag helper, partial async, and render partial async.

Explore passing dynamic data to partial views in ASP.NET Core using view data or view bag, where a copied view data object updates independently for each invocation.

Learn to pass a model object to a strongly tapered, strongly typed partial view, using a list model with a title and items.

Return a partial view result from the controller to handle asynchronous browser requests via fetch. Pass a model, render HTML on the server, and inject it into a page div.