Building a RESTful API with ASP.NET Core

Building an API is one thing, but building a truly RESTful API is something different. In this course, you'll learn how to build one using ASP.NET Core 1 or 2.
Course info
Rating
(503)
Level
Intermediate
Updated
Nov 15, 2017
Duration
8h 9m
Table of contents
Course Overview
Introducing REST
Getting Resources
Creating and Deleting Resources
Updating Resources
Working with Validation and Logging
Implementing Paging, Filtering, and Searching
Implementing Sorting and Data Shaping
Getting Started with HATEOAS
Advanced HATEOAS, Media Types, and Versioning
Working with Caching and Concurrency
Protecting, Testing, and Documenting Our API
Description
Course info
Rating
(503)
Level
Intermediate
Updated
Nov 15, 2017
Duration
8h 9m
Description

Hello! My name is Kevin Dockx, and welcome to Building a RESTful API with ASP.NET Core. In this course, you will learn how to build a RESTful API with ASP.NET Core, which is quite different from a regular web API. You will get there by learning about major topics like how you can correctly interact with your API by using the correct HTTP methods & status codes, method safety and idempotency, validation, common features like paging, sorting, filtering and data shaping, and supporting HATEOAS, versioning, caching and concurrency. By the end of this course, you will be able to build an API with level 3 maturity, which is the highest possible level for APIs. Before you begin, make sure you are already familiar with C# and know a thing or two about building APIs with ASP.NET Core. I hope you’ll join me, and I look forward to helping you on your learning journey here at Pluralsight.

Course FAQ
Course FAQ
What is meant by REST API?

REST stands for "Representational State Transfer". To make an application program interface (API) RESTful means to use the correct HTTP methods and status codes for getting, updating, creating, and deleting resources.

What will I learn in this course?

You will learn:

  • Validation and logging
  • Creating or Updating
  • Paging, sorting, filtering, data shaping
  • To ensure our API is HATEOAS-enabled
  • How to correctly use media types
  • Versioning, caching, and handling concurrency
  • Protecting and documenting the API
  • And more
Why do we need REST API?

The biggest advantage of REST APIs is the amount of flexibility it provides in allowing us to take advantage of existing protocols, and it can be used for almost any protocol, especially HTTP.

How do I create a REST API in net core?

This is precisely what we will be talking about in this course, so you'll just want to jump into the tutorial to start learning how. 

What prerequisites are needed?

You don't need to know anything about REST yet, but you should have a good knowledge of C# and some knowledge of ASP.NET Core. If you're not familiar with ASP.NET Core then you should check out this course on ASP.NET Core fundamentals.

About the author
About the author

Kevin Dockx is a freelance solution architect (mobile/web), author & consultant, living in Antwerp (Belgium).

More from the author
Building an Async API with ASP.NET Core
Intermediate
2h 49m
Jun 2, 2020
More courses by Kevin Dockx
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi, I'm Kevin. Welcome to this Pluralsight course, Building a RESTful API with ASP. NET Core. I'm a solution architect focused on APIs and security and a Microsoft MVP. Building an API is one thing, building a RESTful API is something different. In this course you'll learn how to do that with ASP. NET Core. We'll look into how we can correctly interact with our API by using the correct HTTP methods and status codes, getting, updating, creating, and deleting resources. Learning about method safety and item potency will help us choose the correct approach for these different use cases. We'll also look into some less obvious cases and principals, like creating a list of resources in one go and upserting. We'll cover validation and logging as well, as when we're creating or updating something we want to ensure the input is valid, and if it isn't, we'll want to log that. We'll also cover common functionality RESTful APIs expose these days, like paging, sorting, filtering, data shaping, and so on. But we won't stop there. We're going to ensure our API is HATEOAS-enabled, so hypermedia will drive application state. It's one of those constraints RESTful architecture has that tends to separate truly RESTful APIs from run of the mill web APIs. We'll also learn how to correctly use media types and we'll look into versioning, caching, and handling concurrency. We'll end with a module on protecting and documenting the API. In the end, we'll have built an API with level 3 maturity, which is the highest possible level for APIs.