ASP.NET 8 - Creating Minimal APIs + EF Core 8

Learn to create a minimal API project in Visual Studio Code and Visual Studio, configure Entity Framework, a database, and Solution Explorer, use the dotnet CLI, and enable https.

Create minimal APIs with ASP.NET core using Visual Studio 2022 or Visual Studio Code. Choose between empty and web API templates, and enable the open API swagger interface.

Learn to create a minimal API project with the dotnet cli in VS Code, install Entity Framework tool, and use dotnet 8.0.3, dotnet new web, and run with dotnet run.

Explore creating an ASP.NET Core empty project in Visual Studio Code and Visual Studio 2022 using in-IDE options and the dotnet CLI, then run with or without the CLI.

Execute your asp.net 8 project with dotnet watch over https by configuring launch settings, managing dev certificates, and enforcing secure ports for api and frontend integration.

Practice creating a new solution named beta movies and a minimal API project named movies.api using Visual Studio Code, starting from scratch for this exercise.

Create two folders, db contexts and entities, with director and movie entity classes; define id, name (required), title, year, rating, and a director–movies relationship within an EF Core context.

Install and configure entity framework core with sqlite in a dotnet 8 app, add a db context and db sets for movie and director, and enable migrations.

Master the dotnet ef cli to manage entity framework core migrations, scripts, and updates for sqlite databases using migrations like initial migration and database update.

We design a database with director and movie classes, map to tables directories and movies, and configure a many-to-many relationship using EF Core with SQLite.

Create and seed a database with EF Core 8 for a minimal API, configuring entities, keys, required fields, max length, and the movies-to-directories relationship, then run migrations.

Initialize a git repository, add a dotnet gitignore and readme.md, commit changes, and push to GitHub for the ASP.NET minimal APIs course, documenting section two basic structure.

Create and configure endpoints in minimal APIs using various parameter injections, AutoMapper, and DTOs; explore results types such as no content and OK, and organize with DTOs and profiles.

Explore minimal APIs and endpoints in asp.net 8, configuring program.cs, builder, and entity framework with sqlite, mapping a get endpoint like /movies, and understanding args, docker, and http/https hosting.

Master url patterns for minimal APIs by using parameters to differentiate endpoints, handle numbers and names, and resolve route conflicts.

Explore how to use the database within your app, pass the movies context to a delegate, and fetch data via endpoints with EF Core.

Implement minimal APIs with a shared URL, inject the data context, and resolve route conflicts by type-constrained parameters (int vs string) to return a movie or all movies.

Discover parameter binding in minimal APIs by passing parameters via query strings, headers, or custom names, and learn how to configure binding with from query and header.

Explore making minimal API endpoints asynchronous with async and await, using first or default async to handle requests, and validate the faster, reliable app with Postman.

Modify the minimal API to filter movies by title using contains, make the title query optional, and return all movies when not provided, as tested with postman.

Learn how to use http results in minimal APIs by returning typed results, including no content and ok responses, and how typed results improve readability and unit testing.

Solve a minimal API challenge by filtering movies via query strings, returning all movies when no title is provided, with examples like Toy Story.

Explore creating minimal apis with ef core 8, wiring endpoints for movies and directors, address circular reference errors, and introduce AutoMapper to break cycles.

Configure automapper to map domain models to DTOs with profiles, build maps for movie and director DTOs, and enable reverse mapping in program startup.

Implement dto mapping in minimal APIs by injecting AutoMapper and configuring type maps to convert movie data into directory DTOs, using include to expose directories and avoid cycle problems.

Add a movie dto to an endpoint with a mapper, map a movie to movie dto, and fix mapping when the dto lacks the directors array.

Add automapper to map an enumerable list of movie dto objects. Normalize to lowercase and test with toy story and spider-man.

Learn to create minimal APIs endpoints, inject dependencies, match URL parameters, and implement auto mapper, using a profile file to expose dtos and hide the domain, then commit to git.

Explore manipulating resources in minimal APIs on ASP.NET 8, including creating, deleting, updating (put), and retrieving endpoints, while using dtos to change profiles, with EF Core 8.

Create a post endpoint for ASP.NET 8 minimal APIs using a creating DTO, from body binding, and AutoMapper to map to a movie and save.

Learn to return a 201 created with a location header when posting new items, using a link generator or create at root with a named route.

Master the put endpoint in ASP.NET 8 minimal APIs with EF Core 8, updating a movie by id using an updating DTO, AutoMapper, and proper not found or ok responses.

Create a delete endpoint in a minimal API by reusing the put pattern, delete by id with context.movies.remove(movie), return no content (no body required), and organize resources for clarity.

Organize the API by grouping routes and standardizing url patterns, using plural resource names and consistent movie id parameters, and test endpoints before moving to route groups.

Learn to build and test route groups in ASP.NET 8 minimal APIs by creating a movies group, grouping resources and endpoints, and validating get and post routes.

Execute an exercise to apply map group usage and concatenation with another map group, creating a new map to host the Get, Put, and Delete endpoints within the route tree.

Create and test route handlers for movies groups with ID in a minimal API, mapping /movies and /movies/{id}, and perform get, put, and delete operations.

This final part demonstrates building a route by combining directory segments with an app group, then testing a get call for an id under directories to verify it works.

Send your minimal APIs to git by committing changes to program.cs, adding endpoints for delete, put, and post, and updating dtos and profile in section four.

Learn to build minimal API endpoints in two lines by organizing code into endpoint handlers as true classes and adding extension methods.

Organize ASP.NET 8 minimal APIs by moving endpoint logic into a dedicated endpoint handler class with static methods for get, post, put, and delete, integrating AutoMapper, MVC, and EF Core.

Implement post and put methods in a minimal api by creating and updating movies via the root route and a movies handler, then test the results.

Implement and test the delete endpoint for the ASP.NET 8 minimal API, validating deletion by id and handling failures, then organize related methods before moving them to the move handler.

Fix http status codes in minimal APIs by returning typed results for endpoints, using movie and directory dto types to represent not found and successful responses.

Create and test minimal API endpoints to fetch movies by id and directories by id, using a movies handler and a directories handler with Entity Framework references and AutoMapper.

Organize your ASP.NET 8 minimal APIs by creating an endpoint route builder extensions class with two public static methods: register movies endpoints and register directories endpoints.

Push the updated minimal API structure to git, noting a refactored program.cs from 118 to about 18 lines, plus two handlers and an extension method in section five.

Explore how to structure exceptions and logs in a minimal api, distinguishing development from production environments, and review move found and move not found scenarios, including parameter usage.

Explore exception handling in a minimal API by throwing a not implemented exception in a post endpoint, and compare development versus production environments for friendly messages and structured error views.

Implement a global exception handler in a minimal API middleware, configure HTTP status codes and content type, and enable problem detail responses that differ between development and production environments.

Learn to implement an exception handler and robust logging in a minimal API. Use a logger to record movie queries, noting when a movie is found or not found.

Explore centralized exception handling and structured error responses for minimal APIs, practice simple logging, and commit and push changes to GitHub.

Learn to create endpoint filters and apply logic in minimal APIs, implement validation with mini validation, and experiment with Toy Story endpoints for updating, deleting, and posting.

Explore creating an endpoint filter in ASP.NET 8 to inject business logic using HTTP context and the next delegate, returning 400 problem results and avoiding duplicate code.

Learn to implement a generic endpoint filter in ASP.NET minimal APIs, creating an AI endpoint filter that processes context and next, and applying it to put and delete operations.

Implement and test a generic filter in asp.net 8 minimal apis to extract the movie id from varying request positions based on put or delete, enforcing cannot change or delete.

Apply a generic filter for perfect movies and implement a locked filter to prevent edits, demonstrating parameterized, safe data handling.

Explore grouping in minimal APIs by applying map group filters and the chain of responsibility, optimize performance, and debug with breakpoints to trace next.invoke behavior.

Tackle a bug in a minimal API endpoint by adjusting internal logic (without changing the class), then test to prevent a system not supported exception.

Explore lazy and eager filters in minimal APIs, showing how endpoint filters can run before or after delegates, log not found responses, and handle not found vs no content results.

Explore mini validation in ASP.NET 8 minimal APIs by implementing data-annotated DTO validation, enforcing required fields and min/max lengths, and applying a custom endpoint filter for validation.

The instructor demonstrates solving a problem by using endpoint route builder map group to create minimal api routes, then test get, put, and delete.

Explains section seven on filters and validations, showing how to create validations, implement logging for not found items, and apply filters with and without groups.

Configure swagger with identity endpoints, enabling authentication and token-based authorization for your APIs. Learn to handle unauthorized responses (401) and implement ASP.NET Core Identity features through swagger authentication and authorization.

Learn to install swashbuckle for ASP.NET Core, configure swagger in program.cs, and enable api explorer in development to view and test minimal APIs.

Explore swagger for testing minimal APIs, learn how to mark endpoints as deprecated with open API, add summaries and descriptions, and guide users to new routes like movies by ID.

Implement JWT bearer authentication in a minimal API by configuring authentication and authorization in program.cs and app settings, then test secured endpoints with tokens.

Learn to configure Swagger for a bearer token in ASP.NET 8, defining security definitions and requirements, and enable anonymous endpoints to test authorization in the UI.

Discover how to quickly add ASP.NET Core Identity with EF Core, configure identity services, set up identity endpoints, run migrations, and authenticate with tokens to access protected minimal API routes.