ASP.NET CORE and C# REST API With 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 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 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.

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.

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

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.

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.

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.

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.

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.

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.