ASP.NET CORE and C# REST API With Real World Projects

Explore how web API works to build a foundation for ASP.NET Core and C# REST APIs. Learn the data communication, storage, and presentation patterns that underpin real world projects.

Learn how the data communication pattern powers web APIs as clients and a web API exchange HTTP requests and responses to fetch resources via endpoints.

Explore how REST API requests map to resources on a web server, using controllers and actions, with HTTP methods such as GET, POST, PUT, and DELETE, and returning JSON data.

Explore data storage patterns for real-world ASP.NET Core apps, distinguishing static data in storage blob from dynamic data in databases, and using ORM and SQL.

Learn how data presentation patterns connect your database to users by using serialization to convert between framework models and standard formats like JSON in ASP.NET Core REST APIs.

Highlight three lectures on data communication patterns, data storage patterns, and data presentation patterns in the Web API context. Conclude this section and look forward to the next section.

Get started with implementing a REST API using ASP.NET Core, exploring the MVC pattern, building a Web API, and working with models, controllers, storage, and serialization.

Explore the MVC pattern by examining the model, view, and controller and how they interact to structure software. Enable collaboration, testing, and scalable development across teams.

Explore how ASP.NET Core implements the MVC pattern for web APIs, detailing model, controller, and serialization to JSON. Understand routing, model binding, validation, dependency injection, filters, and project structure.

Discover how ASP.NET Core implements the MVC pattern by organizing controllers, models, and view models, configuring appsettings, csproj, program and startup files, and hosting a REST API.

Build a basic ASP.NET Core web API that serves a weather forecast via get endpoint, using a weather forecast model with date, temperature in Celsius and Fahrenheit, and a summary.

Create a basic ASP.NET Core Web API and test its endpoints with Postman. The app serves weather forecast data with date, temperature in Celsius and Fahrenheit, and a summary.

Work with models in ASP.NET Core explains how Entity Framework maps a model's properties to a database table, covering common field types like int, string, bool, DateTime, and enums.

Explore how controllers drive ASP.NET Core REST APIs, with action methods handling HTTP verbs and routing. Learn to inject repositories or services and fetch or modify data through the controller.

Explore how REST API routing in ASP.NET Core maps controllers and action methods to resources, following the default REST pattern with MVC and the single responsibility principle.

Explore data storage in ASP.NET Core using an ORM, especially Entity Framework, to generate tables from models and support multiple databases while considering performance, security, and protection from SQL injection.

Explore how asp.net core automatically serializes rest api data to json by default, with options to switch to xml through explicit configuration, and how model binding maps data to models.

Explore the structure of an ASP.NET Core Web API project, including controllers, models, repositories, services, migrations, and an entity framework database, for maintainable apps.

Explore the MVC pattern, its benefits, and its implementation in an ASP.NET project, covering models, controllers, storage options, serialization, and the structure of typical web API projects for SMBs.

Set up and build a real-world REST API using ASP.NET Core, including project setup, notes model, migrations, repository, controller, swagger documentation, and testing with swagger UI and Postman.

Set up a new ASP.NET Core REST API project in Visual Studio, run the project to verify it works, and connect it to a big buckets repository for source control.

Review the Notley REST API requirements to create, load, and fetch notes, and to delete or update a note using standard get, post, delete, and put methods.

Create the note model for the asp.net core c# rest api, defining id, subject, detail, created date, last modified date, and a soft delete flag.

Connects your previously created model to a SQLite database by configuring Entity Framework, creating a local db context, and generating database migration files, then updating startup to register the database.

Install the latest entity framework packages and the dotnet ef tooling for the project. Prepare the db context and db sets, then run a database migration with dotnet ef.

Install and configure the dotnet ef packages, then create and apply a database migration to sync the model with the database. Implement migration file creation and perform the database update.

Create and register a notes repository using the repository pattern in ASP.NET Core, implementing find by id, get all, save, and delete operations with an in-memory database.

learn to implement a note repository with add, update, delete operations and explicit save changes to persist data, register services, and code to interfaces for decoupled, testable design.

Create a notes API controller in ASP.NET Core, inject a notes repository, and implement get notes, get note by id, create, update, and delete actions.

Install and register the Swagger package, configure services in startup, and run the app to view the API documentation in the browser via Swagger UI.

Explore how to test a REST API with Swagger UI by executing get, post, put, and delete operations on notes, handling empty databases, and validating responses.

Learn to test a rest api with postman by invoking get, post, put, patch, and delete on notes endpoints, validate responses, and understand request bodies, headers, and authorization.

Explore building a real world REST API with ASP.NET Core and C#, covering local setup, EF migrations, repository and controller creation, swagger documentation, and testing with Swagger UI and Postman.

We introduce the real-life project and the four lectures that move from understanding the business to defining the problem, specifying design criteria, and creating the solution.

Understand the building material business models, including B2C and B2B, and explore brick-and-mortar and online stores, along with core components like inventory management, accounting, logistics, and customer service.

Define the problem by analyzing Building Materials Inc.'s shift from brick-and-mortar to online services, addressing manual operations, data digitization, data protection, and the need for digital customer analytics.

Specifies design criteria to guide system design and judge success via the software requirements specification, including scalable, maintainable web API architecture for web, mobile, and desktop apps.

Design and implement a real-world ASP.NET core REST API solution meeting design criteria, using MVC, with product catalog, shopping cart, checkout, order management, user registration and authentication, and payment.

Recaps the four lectures in this section by covering business models and core components, defining the problem, specifying design criteria, and presenting a high level solution that meets them.

Define business requirements and set up the project by detailing feature specifications. Explore API specifications for product catalog, shopping cart, customer registration, authentication, payment, and administration to guide implementation.

Explore the product catalog API, including endpoints for products, brands, and categories. Learn how to save, retrieve, modify, filter, and softly delete items in a real-world rest API.

Explore the shopping cart API specification for a web API application, detailing endpoints to add items to the cart and remove items from the cart.

Explore the checkout API specifications, highlighting the single endpoint that processes a cart checkout and moves items from the cart toward checkout completion.

Define the customer registration specification for an ecommerce system, including name, date of birth, email, address, and payment information, and outline endpoints for customer management and admin auditing.

Explore the customer authentication specifications for an ASP.NET core REST API, enabling login, logout, and password reset for customers, employees, and third party suppliers.

Explains admin specifications for a central admin feature that manages inventory, orders, users, and suppliers, with QA tooling, messaging, and password management capabilities.

Set up the BMES ASP.NET core web API project, verify it runs, and connect to Bitbucket; install essential packages like entity framework design and swagger for a real-world REST API.

Review the section's API specifications for product catalog, shopping cart, checkout, customer registration, authentication, payment system, and admin, then recap setting up the project and source controller.

Set up the product catalog section by structuring the project and defining product, category, and brand models. Wire migrations, repositories, and data transfer models for the web API.

Structure the BMES project by organizing database, models, repositories, services, views, and data transfer objects for a practical ASP.NET Core REST API, including catalog features.

This lecture guides creating the product catalog models: product, category, and brand, setting up their database fields, and explores their relationships, including many-to-many and the chosen one-to-many approach.

Install the dotnet ef tools, create a migrations file for the products catalog, and apply the database update to implement the changes in the database.

Execute database migration for product catalogue models by installing dotnet ef tools, creating the database and order table, and inspecting the schema with a GUI tool.

Create product, category, and brand repositories with shared interfaces and implementations, register them as services, and implement CRUD operations to manage catalog data.

Implement update and delete repository methods with Entity Framework and call save changes to persist product catalog updates in the database. Register repositories as transient services in startup.

Explore the request response pattern for a rest api, create product catalog data transfer objects and request–response models, and map between dtos and domain models with a mapper and service.

Design and map catalogue data transfer objects for product, brand, and category in an ASP.NET Core REST API, including request and response models, security-minded naming, and source control practices.

Inherit the response base to standardize brand and fetch brand responses for the catalog api. Use a mapper to translate between brand data transfer objects and internal brand models.

Create and map data transfer objects for the product catalog, including brand, category, and product, using a message mapper. Refine mappings with null checks to ensure safe, controller-ready DTOs.

Builds the product catalog services in a real-world asp.net core rest api with products, brands, and categories. Implements data transfer objects, repositories, and mappings to support filtering and pagination.

Learn to flesh out catalogue interfaces, inject services via startup and constructor, and implement the create brand flow—dto to model to repository, then back to CreateBrandResponse with messaging.

Create the catalog service part 3 by validating the brand id, mapping brand data, and performing update, get, and delete operations via the repository.

Create the catalogue service in an ASP.NET core API by wiring the product repository, declaring the catalogue interface, and implementing a fetch products method with category, brand, and pagination.

Learn to implement the product catalog api by creating brand, category, and product controllers, wiring in services, and building get and post actions with model binding.

Implement the product catalogue controller part 2 by wiring client requests through model binding, updating and deleting brands, fetching paged products, and registering services for brand, category, and product controllers.

Connect and configure Swagger in an ASP.NET Core app to generate and expose OpenAPI documentation, test endpoints, and view API definitions through Swagger UI.

We install the swagger package, register it to our api via startup.cs, and review the generated documentation; in the next lecture we test the api.

Test the product, brand, and category endpoints of the ASP.NET Core and C# REST API using Postman and Swagger documentation, including create, fetch, modify, and delete operations.

Test the product, brand, and category endpoints using Postman and the supplied schema, validating creates, updates, and error handling with proper pagination notes.

Build and document a product catalog REST API with ASP.NET Core and C#: define product, brand, category, and catalog models, apply migrations, implement repository and controller, and test with Postman.

Prepare the section by wiping test data and loading real product catalog data into the database for the ASP.NET CORE and C# REST API project.

Delete the existing test database and migrations, create a fresh database, and load branch, brand, category, and product data into the product catalog tables.

Learn to load data into the product catalogue database tables, run queries, and manage constraints. Test the application with loaded data and verify the product catalogue updates.

Test loading and retrieving product catalog data via swagger and postman, fetch brands, categories, and products, verify pagination, and troubleshoot seeding and endpoint issues.

Load data into the product catalogue database tables, test the REST API, and fetch products by page to demonstrate data loading and retrieval.

We loaded our data into the database, achieving the main goal of this section, and then proceeded to the next section.

Implement the shopping cart feature in your ASP.NET Core and C# REST API project. Build cart models, repositories, data transfer models, and a cart controller, then test with Postman.

Structure the app with a focus on the shopping cart, review the model and data transfer steps, and perform housekeeping to prepare cart-related requests.

Develop the shopping cart and cart item models, define core properties (cart id, status, items, product id, quantity), and ensure Entity Framework tracking.

Create and apply a database migration to synchronize shopping cart models with the database, and register the models in the db context to generate the proper tables.

Implement the cart repository and cart item repository in part 1. Define interfaces and implement CRUD operations using the database context, including add, find, update, delete, and save changes.

Implement the cart repository in a real-world ASP.NET Core project, enabling retrieval of cart items by id, including related products, and registering and using the repository via services.

Create data transfer objects for cuts and cut items, and map them from domain models to DTOs. Build request and response models for cut controller actions and wire mappings.

Implement the cart service by creating a cart service class and public interface, injecting repositories, and managing a per-session cart using a unique kneecap id stored in a cookie.

Implement the cart service by retrieving or creating a cart with a unique id, updating item quantities, adding products, and persisting changes to the database.

Implement a real-world shopping cart service in ASP.NET Core, including remove item, fetch cart, and get cart items. Register the service in startup and wire it into the catalog controller.

Clarify the catalog data and remove incorrect information while finalizing the shopping cart service, since the catalog controller has not been implemented in this course.

Implement the cart controller in an ASP.NET Core and C# REST API, inject the cart service, and expose get cart, add to cart, and remove item actions.

Test the cart endpoints using Postman with guidance from Swagger documentation, ensure session is configured, and verify adding, deleting, and updating cart items.

Develop shopping cart models and the cost controller for a real-world ASP.NET Core and C# REST API, then test endpoints with Postman and prepare documentation.

Implement location and address modules in an ASP.NET Core and C# REST API to manage customer addresses, enable shipping, perform address data migration, repository work, and DTO mapping.

Learn how to structure the location section in an ASP.NET core REST API, including address models, DTOs, repositories, services, and controllers.

Create an address model for an ASP.NET Core REST API with real world projects by defining address fields, implementing base object inheritance, and registering the model in the database context.

Execute a database migration to synchronize the address model with the database using add migration and update database commands. Verify the new address table appears and reflects the updated model.

Implement the address repository and its interface for the address model, with methods to find by id, add, update, delete, and save changes, plus service registration.

Create the address data transfer object and implement address mapping in the message map, converting address models to address detail and handling lists of addresses.

Structure the project and build the address functionality for the api by creating the address model, running the database migration, and implementing the address repository and data transfer models.