Join to our VIP plans and download all products FREE of charge! Click to get up to 60% Discount / Ends in 00h 00m 00s
Product Info

Building Minimal APIs with ASP.NET Core 8 and Dapper (Learn Build Web APIs with .NET Core and Dapper)

Building Minimal APIs with ASP.NET Core 8 and Dapper (Learn Build Web APIs with .NET Core and Dapper)

Join us in this hands-on course to learn how to build Minimal APIs with ASP.NET Core 8. Starting from scratch, you'll explore the entire process of developing a Web API, from creating the project and developing endpoints to managing resources and deploying your API on Azure and IIS. This course will guide you through a practical project that you can add to your portfolio, showcasing your new skills.

"Minimal APIs in ASP.NET provide a lightweight and fast way to create HTTP services with minimal configuration, making them perfect for microservices and small, focused applications." Microsoft Docs

Throughout the course "Building Minimal APIs with ASP.NET Core 8 and DapperN Web Tokens (JWT). We'll cover creating a secure user system, applying claims-based authorization, and optimizing your application with caching strategies, including using Redis for distributed caching. Additionally, you'll learn to configure a Continuous Integration and Continuous Delivery (CI/CD) pipeline using Azure DevOps, ensuring smooth deployment from your Git repository.

"With minimal APIs, ASP.NET Core allows developers to create and deploy HTTP endpoints quickly and efficiently, making it an ideal choice for building lightweight microservices and serverless applications." TechRepublic

tutlibrary

Web APIs are crucial in modern development, serving as the backbone for mobile apps, web applications, and more by centralizing and protecting your logic. By the end of this course, "Building Minimal APIs with ASP.NET Core 8 and Dapper", you'll have a solid understanding of building and deploying robust APIs, equipped with practical skills to enhance your backend development projects. Join us to take your API development to the next level!

Building Minimal APIs with ASP.NET Core 8 and Dapper Table of Contents:

  1. Introduction - 00:26
  2. Web APIs - 02:39
  3. Nullables and Implicit Usings - 04:05
  4. The LaunchSettings File - 03:03
  5. Configuration Providers - AppSettings - 05:04
  6. The Program Class - 02:57
  7. List of Genres - 05:38
  8. Summary - 00:35
  9. Introduction - 00:22
  10. Client-Server Separation - CORS - 03:08
  11. Visualizing the CORS Error - 02:38
  12. Enabling CORS Configuration in ASP.NET Core - 04:49
  13. Configuring CORS in Endpoints - 03:48
  14. Not Using State - 01:22
  15. Introduction to Cache - 01:23
  16. Implementing OutputCache - 05:37
  17. Layered-System - 00:42
  18. Documenting the Web API with Swagger - 04:23
  19. Summary - 00:29
  20. Introduction - 00:18
  21. What is a Database? - 02:09
  22. Creating a Database - 00:58
  23. Creating the Genres Table - 04:35
  24. Query For Inserting Data - 07:14
  25. What is ADO.NET? - 01:31
  26. What is Dapper? - 01:47
  27. Communicating with the Database - The Connection String - 04:27
  28. Installing Dapper - 10:19
  29. Inserting Genres - 05:34
  30. Selecting Genres - 10:14
  31. Cleaning Up the Cache - 02:25
  32. Ordering Records - 01:44
  33. Updating Genres - 08:53
  34. Deleting Genres - 04:31
  35. MapGroup - 02:57
  36. Going From Lambda Expressions to Named Methods - 06:06
  37. Group of Endpoints per Class - 03:17
  38. DTOs - 09:02
  39. AutoMapper - 07:05
  40. Introduction to Stored Procedures - 05:21
  41. Stored Procedures with Parameters - 09:52
  42. Summary - 00:26
  43. Introduction - 00:17
  44. Creating the Actor Entity - 03:24
  45. Actors CRUD - 11:18
  46. Endpoint for Inserting Actors - 08:31
  47. Preparing the App to Store Images - 04:22
  48. Azure Storage - 09:10
  49. Saving Files Locally - 08:31
  50. Getting Actors - 03:41
  51. Filters - 06:15
  52. Pagination - 03:47
  53. Implementing Pagination - 07:17
  54. Updating Actors - 06:03
  55. Deleting Actors - 03:06
  56. Creating the Movie Entity - 02:00
  57. Movies CRUD - 12:46
  58. Endpoint for Inserting Movies - 06:53
  59. Selecting Movies - 05:14
  60. Updating Movies - 04:05
  61. Deleting Movies - 02:43
  62. Creating the Comment Entity - 04:37
  63. Comments CRUD - 09:01
  64. Endpoint for Inserting Comments - 05:48
  65. Getting the Comments of a Movie - 04:42
  66. Updating and Deleting Comments - 07:08
  67. Getting a Movie and its Comments - 05:16
  68. Configuring a Many-to-Many Relationship between Genres and Movies - 03:59
  69. Assigning Genres to a Movie - 09:35
  70. Creating an Endpoint to Assign Genres - 05:41
  71. Configuring a Many-to-Many Relationship between Actors and Movies - 02:47
  72. Assigning Actors to a Movie - 08:19
  73. Creating an Endpoint to Assign Actors - 05:44
  74. Getting a Movie and its Genres and Actors - 10:41
  75. Summary - 00:19
  76. Introduction - 00:24
  77. Validations - FluentValidation - 02:02
  78. Validating That a Field is Not Empty - 05:29
  79. Customizing Validation Errors - 01:02
  80. Multiple Validations on a Single Property - 01:52
  81. Customized Validation - 02:36
  82. Asynchronous Validation - 06:40
  83. Getting a Route Parameter - 03:50
  84. Multiple Validations on Multiple Properties - 04:13
  85. Reusing Validation's Settings - 03:54
  86. Introduction to Filters - 04:06
  87. Getting Arguments in Filters - 03:54
  88. Using Filters to Centralize Validations - 04:55
  89. Using a Generic Filter - 02:43
  90. Validating Comments - 01:25
  91. Validating Movies - 01:41
  92. Error Handling - Validating the Data Type - 04:04
  93. Modifying the Error Message - 02:25
  94. Saving the Error Message in a Database - 09:32
  95. Summary - 00:17
  96. Introduction - 00:28
  97. Authentication and Authorization - 02:49
  98. Protecting Endpoints - 03:15
  99. Creating a Test JWT - 05:53
  100. Creating the Identity Tables - 04:15
  101. Creating the User Repository - 07:50
  102. Implementing the User Store - 04:55
  103. Configuring JWTs - 08:16
  104. Registering Users - 12:24
  105. Login Users - 04:45
  106. Completing the Comment Entity - 03:07
  107. Creating the User Service - 08:14
  108. Updating and Deleting Comments - 05:11
  109. Configuring Claim-Based Authorization - 04:47
  110. Modifying the User Store to Work With Claims - 08:43
  111. Using the Admin's Claim - 08:22
  112. Renewing Tokens - 03:46
  113. Summary - 00:42
  114. Introduction - 00:13
  115. Logging - 08:08
  116. Model Binding - 05:53
  117. AsParameters - 03:51
  118. Bind Async - 06:07
  119. Using IParsable for Saving Code - 02:38
  120. Documenting the Web API - Adding Parameters - 05:11
  121. General Modifications to the Swagger Page - 01:40
  122. Adding Descriptions to Endpoints - 01:58
  123. Swagger and FromForm - 01:16
  124. Swagger and JWT - 03:48
  125. IParameterFilter to Personalize the Metadata of the Endpoints - 04:04
  126. Filtering and Ordering Movies - 09:49
  127. Dynamic Filters - 13:14
  128. Ordering the Results of a Query Dynamically - 03:35
  129. Delimiting Options in the Ordering Field - 01:32
  130. Introduction to Distributed Cache - 02:59
  131. Installing Redis - 00:48
  132. Using Redis in ASP.NET Core - 04:23
  133. Summary - 00:24
  134. Introduction - 00:25
  135. Deploying to Azure App Service - 08:30
  136. Fixing an App that Won't Start - 03:13
  137. Fixing an Error in Production - Application Insights - 06:23
  138. Deploying to IIS - 06:17
  139. Introduction to Continuous Integration and Continuous Delivery - 02:18
  140. Continuous Integration in Azure DevOps - 11:58
  141. Continuous Delivery in Azure DevOps - 08:51
  142. Summary - 00:42
  143. Congratulations - 00:06

Who is this course for?

  1. .NET developers who want to learn how to build Web APIs

Click on the links below to Download Building Minimal APIs with ASP.NET Core 8 and Dapper!

Similar cases

Best Selling Products

See More