Top 8 Recommended ASP.NET Self-Study Materials! [December 2023]

THE REAL ULTIMATE GUIDE TO ASP.NET CORE 7 DEVELOPMENT

This is the only course you need to learn the complete coding and testing skills that a professional Asp .Net Core developer needs.

This is the most-comprehensive course on Asp .Net Core ever available on Udemy, which starts you from beginner to mastery in Asp .Net Core development.

STUDENTS FEEDBACK - over 250 students - 5 star rated:

1. "This course is by far the best deal I've seen in a very long time. The instructor is not exaggerating when he describes it as the 'True Ultimate Guide'. Just about everything one needs to know as a developer is included, and then some: each one of the sections on Entity Framework, Unit Testing and Identity/Authorization could have been sold as separate courses but they're included here at no additional cost, truly amazing. Of course, none of that would be of any value if the content was not instructional, but that's not the case here: the instructor is quite knowledgeable, and all the explanations are concise and to the point. The pace is quick on easy topics but slower and very detailed on the more difficult ones." - Zamkam

2. "This course is beyond the expectation. As a person who has read Microsoft documentation, and watched a lot of videos, and also read so many books about ASP.NET, I am confident to tell you to join this course not only 100% but, 1500%. What I found awesome about this course: - The order, in which the concepts are thought is magical. - The detail and the information in the content of the course are unbelievably wonderful. - The course got updated with wonderful stuff. By using this course, we would not need more than 1 year in a company to become a senior developer I believe. Thank you very very much Harsha for this wonderful course. Please add as much as content you can in your C# and ASP.NET course, because the way you teach is a miracle." - Hamed Homaee

3. "Excellent explanation, good fonts, good pace, so - brilliant course! And yes, finally - it's COMPLETE guide! Not just 10 hours or even less. Thank you for that kind of work!" -- Valera Znak

4. "Highly Recommended! This course is well-organized, easy to follow and covers a wide range of topics. The instructor takes time to thoroughly explain each topic and provide examples to help illustrate their points, which is incredibly helpful in gaining a deeper understanding of ASP.NET Core." -- Nisarg Gami

5. "This course is pretty amazing. The concepts are been taught in such a way that it becomes easier for anyone to understand them clearly and quickly. Also, the assignments and interview questions help a lot in testing our knowledge and giving us good exposure to attending a real interview exam. The assignment question helps us in implementing our learning by solving the questions." -- Pushkar Sharad Kaswankar

6. "I was waiting for this type of course from a long years. I can say this is a best course for beginner to learn asp.net core also for experience people finally it's complete package of .net core course" - Dheeraj Ambippi

7. "Everything is meticulously prepared. It's nice to have cheat sheet." -- Ekrem Kangal

8. "The best course for ASP.NET CORE so far. Thanks for the pieces of information you put together in this course. He explained every concept in DotNet Core. Kudos to the author!" -- Johnbull Vitowanu

Top reasons - why should you opt this course over the other courses

• The course is facilitated (instructed) by the lead instructor - Mr. Harsha Vardhan, one of the most popular trainer for in-person training programs with top IT companies in India.

• This course is up-to-date with .NET 7 and promised to keep it up-to-date for future releases of .NET and Asp .Net Core.

• The course is constantly updated with new content on newer topics, new projects determined by the students - that's you!

• You will build your portfolio project (a Stocks Trading Platform) through guidance provided by the Instructor (also, source code is provided to help you to rescue you in case if you stuck somewhere and to check quality of your code).

• Many developers may feel challenged when they need to face technical interviews. To address this problem, we've included a comprehensive set of interview questions to test yourself before facing any technical interview on Asp .Net Core.

• Coding is not the game of listening and following someone. You will have proper understanding of the subject only when you apply it on a meaningful application. So essential coding exercises (assignments) are provided in each section. So you will try each of them - and get instructor's source code and help when you stuck somewhere or become clue-less at certain point.

• The definitions, best practices, diagrams presented in the course videos, are provided as 'Section cheat sheet' at the end of respective section. So you can use it as a moment of reference & revision, to recollect and apply what have you learnt from that section.

• Advanced concepts such as xUnit, Moq, Serilog, Fluent Assertions, Repository Pattern, Clean Architecture, SOLID Principles, Unit testing and Integration testing, Asp .Net Core Identity are presented in the course, along with a promise to keep it up to date. So it's a future-proof course.

• Professional developer best practices are included and explained in respective sections wherever necessary.

• All topics are explained from scratch. So you need not worry about your prior knowledge / experience in Asp .Net Core. The only main prerequisites of this course are - C# and HTML.

• Even, you need not much worry about advanced topics of C#; because brush-up lectures on the key concepts of C# such as Extension Methods, LINQ, Nullable reference types etc., are included as a extra section in this course.

• Teaching methodology: Picture first - visualize and define everything before jumping into a new topic.

• Lag-free and straight-to-the-point explanation

• English captions are available for all lectures.

Does this course include Web API (RESTful Services)?

Yes

What is the application are we going to build for my portfolio?

A "Stock Trading" App.

• With live chart and price updates on the selected stock.

• A search page to search for desired stock.

• Place buy or sell order

• A dashboard to see order history of buy orders and sell orders

• A login / register page where the new users can sign-up and existing users can sign-in.

  
  

What if I get stuck while learning?
You can drop a question in the Q&A, and the instructor or the teaching assistant will answer your questions within 24-hours - max within 48-hours.

What if I don’t like the course?
That will likely not happen. But, if it does, you are covered by the Udemy 30-day money-back guarantee, so you can quickly return the course. No questions asked.

1. Introduction
2. Introduction to Asp.Net Core
3. WebForms [vs] Asp.Net Mvc [vs] Asp.Net Core
4. Section Cheat Sheet (PPT)
5. Section 1 Interview Questions
6. Where to download the Source Code
7. New features of Asp.Net Core 7
8. What if I'm interested in Web API only?
9. How to watch videos effectively (Best study method)?
10. Getting Started
11. Setup Environment
12. Create First Asp.Net Core App
13. Kestrel and Other Servers
14. launchSettings.json
15. Section Cheat Sheet (PPT)
16. Section 2 Interview Questions
17. HTTP
18. Introduction to HTTP
19. HTTP Response
20. HTTP Status Codes
21. HTTP Response Headers
22. HTTP Request
23. Query String
24. HTTP Request Headers
25. Postman
26. HTTP Get vs Post - Part 1
27. HTTP Get vs Post - Part 2
28. Section Cheat Sheet (PPT)
29. Section 3 Interview Questions
30. Math app though HTTP GET
31. Middleware
32. Intro to Middleware
33. Run
34. Middleware Chain
35. Custom Middleware Class
36. Custom Middleware Extensions
37. Custom Conventional Middleware Class
38. The Right Order of Middleware
39. UseWhen
40. Section Cheat Sheet (PPT)
41. Section 4 Interview Questions
42. Login using Middleware
43. Routing
44. Intro to Routing
45. Map, MapGet, MapPost
46. GetEndPoint
47. Route Parameters
48. Default Parameters
49. Optional Parameters
50. Route Constraints - Part 1
51. Route Constraints - Part 2
52. Route Constraints - Part 3
53. Custom Route Constraint Class
54. EndPoint Selection Order
55. WebRoot and UseStaticFiles
56. Section Cheat Sheet (PPT)
57. Section 5 Interview Questions
58. Countries app using Routing
59. Controllers & IActionResult
60. Creating Controllers
61. Multiple Action Methods
62. Takeouts about Controllers
63. ContentResult
64. JsonResult
65. File Results
66. IActionResult
67. Status Code Results
68. Redirect Results - Part 1
69. Redirect Results - Part 2
70. Section Cheat Sheet (PPT)
71. Section 6 Interview Questions
72. Bank app using Controllers
73. Model Binding and Validations
74. Overview of Model Binding
75. Query String vs Route Data
76. FromQuery and FromRoute
77. Model Class
78. form-urlencoded and form-data
79. Introduction to Model Validations
80. Model State
81. All Model Validations - Part 1
82. All Model Validations - Part 2
83. Custom Validation
84. Custom Validation with Multiple Properties
85. IValidatableObject
86. Bind and BindNever
87. FromBody
88. Input Formatters
89. Custom Model Binders
90. Model Binder Providers
91. Collection Binding
92. FromHeader
93. Section Cheat Sheet (PPT)
94. Section 7 Interview Questions
95. e-Commerce Orders App
96. Razor Views
97. MVC Architecture Pattern
98. Views
99. Code Blocks and Expressions
100. If
101. Switch
102. Foreach
103. for
104. Literal
105. Local Functions
106. Html.Raw
107. ViewData - Part 1
108. ViewData - Part 2
109. ViewBag
110. Strongly Typed Views - Part 1
111. Strongly Typed Views - Part 2
112. Strongly Typed Views with Multiple Models
113. _ViewImports.cshtml
114. Shared Views
115. Section Cheat Sheet (PPT)
116. Section 8 Interview Questions
117. Weather App
118. Layout Views
119. Creating Layout Views - Part 1
120. Creating Layout Views - Part 2
121. Layout View for Multiple Views
122. ViewData in Layout Views
123. _ViewStart.cshtml
124. Dynamic Layout Views
125. Layout Views Sections
126. Nested Layout Views
127. Section Cheat Sheet (PPT)
128. Section 9 Interview Questions
129. Weather App with Layout Views
130. Partial Views
131. Creating Partial Views
132. Partial Views with ViewData
133. Strongly Typed Partial Views
134. PartialViewResult
135. Section Cheat Sheet (PPT)
136. Section 10 Interview Questions
137. Weather App with Partial Views
138. View Components
139. Creating View Components - Part 1
140. Creating View Components - Part 2
141. View Components with ViewData
142. Strongly Typed View Components
143. View Components with Parameters
144. ViewComponentResult
145. Section Cheat Sheet (PPT)
146. Section 11 Interview Questions
147. Weather App with View Components
148. Dependency Injection
149. Services - Part 1
150. Services - Part 2
151. Dependency Inversion Principle
152. Inversion of Control
153. Dependency Injection
154. Method Injection - FromService
155. Transient, Scoped, Singleton - Part 1
156. Transient, Scoped, Singleton - Part 2
157. Service Scope
158. AddTransient(), AddScoped(), AddSingleton()
159. View Injection
160. Best Practices for DI
161. Autofac
162. Section Cheat Sheet (PPT)
163. Section 12 Interview Questions
164. Weather App with Dependency Injection
165. Environments
166. Introduction to Environments
167. Environment in Launch Settings
168. Environment in Controller
169. Environment Tag Helper
170. Process Level Environment
171. Section Cheat Sheet (PPT)
172. Configuration
173. Configuration Basics
174. IConfiguration in Controller
175. Hierarchical Configuration
176. Options Pattern
177. Configuration as Service
178. Environment Specific Configuration
179. Secrets Manager
180. Environment Variables Configuration
181. Custom Json Configuration
182. Http Client - Part 1
183. Http Client - Part 2
184. Http Client - Part 3
185. Section Cheat Sheet (PPT)
186. Section 14 Interview Questions
187. Social Media Links
188. Stocks App with Configuration
189. xUnit
190. Project Overview | Contacts Manager
191. xUnit Basics
192. Add Country - xUnit Test - Part 1
193. Add Country - xUnit Test - Part 2
194. Add Country - xUnit Test - Part 3
195. Add Country - Implementation
196. Get All Countries - xUnit Test
197. Get All Countries - Implementation
198. Get Country by Country ID - xUnit Test
199. Get Country by Country ID - Implementation
200. Add Person - Creating Models - Part 1

*****

THIS COURSE HAS BEEN COMPLETELY RE-RECORDED AND UPDATED TO THE LATEST VERSION .NET 7
The course is compatible with both versions: .NET6 & .NET7

*****

This is a complete guide to creating ASP.NET Core Web API  using  .NET 7, Entity Framework Core (EF Core), and SQL Server database.

With over 6000 student enrolments and more than 1100 5-Star reviews, this course has helped students from all backgrounds to learn and implement ASP.NET core Web API.

This course is for all skill levels and best suits beginners and intermediate developers who have gained knowledge in C# and ASP.NET Web MVC and want to use their skills to learn ASP.NET Core and specifically ASP.NET Core Web API.

In this ASP.NET Core WEB API course, we will use .NET 7 and create a REST WEB API.

During this course, you will gain so much experience creating ASP.NET Core APIs and endpoints and by the end, I am confident that you will gain enough practical knowledge to create your own ASP.NET Web APIs.

We will create a very engaging Web API in which we will create the regions and walks of New Zealand and we will create an ASP.NET Core Web API so that clients of this API are able to consume this data.

We will start with learning what are the principles of REST and understand the files that ASP.NET Core creates as part of a new project.

Then we will create and understand our domain and domain models.

Then we will go ahead and install Entity framework core and using EF Core migrations we will create our SQL Server Database.

We will then create controllers for our API and test them using Swagger UI.

We will also understand and implement the concepts of Domain and Data models and use clean coding techniques to build our ASP.NET CORE Web API.

We will use a famous third-party library called Automapper to map objects inside our API.

With all of this, we will go on and create CRUD operations for our Web API. We will perform Create, Read, Update, and Delete operations on our API using the Repository Pattern in ASP.NET Core API.

Then we will understand and implement Authentication and Authorization in ASP.NET CORE Web APIS using JWT tokens and see how we can generate JWT tokens using our API (Server) so that we can Authenticate and Authorize the clients of our application.

We will learn more advanced level stuff by implementing Filtering, Sorting, and Pagination in our ASP.NET Core Web API.

We will use Postman and Swagger to test our Authentication and Authorization.

We will also use ASP.NET Core Identity to our API where we Register users and assign roles to them.

In this course ASP.NET Core Web API course, you will learn and implement:

• Understand REST APIs by creating a Web API using ASP.NET Core and .NET 7

• Understand REST Principles

• Understand Dependency Injection and Benefits

• Creating New ASP.NET Core Web API Project

• Understand .NET 7 WEB API Project In .NET 7 and C#

• Learn And Install Entity Framework Core (EF Core) In ASP.NET Core Web API Project

• Learn Entity Framework Core Migrations

• Understand the difference between Domain models and DTOs

• Understand Domain Models and Repository Pattern

• Use Swagger To Test ASPNET Core WEB API project

• Learn How To Map Models To One Another Using Automapper

• Learn Asynchronous Programming (Async Await)

• Validate ASP.NET Core WEB API

• Secure your ASP.NET Core Web API using Microsoft Identity by adding Authentication and Role-Based Authorization to your REST API.

• Add JWT Authentication to ASP.NET Core Web API by creating JWT Tokens to API Clients.

• Understand and Add Authentication and Authorization To ASP.NET Core API and Create Read and Write Users To Test this Via Postman

• Incorporate ASP.NET JWT Authentication Into SwaggerUI

• Add advanced functionality like Filtering, Sorting, and Pagination to your ASP.NET Core Web API.

Know me more

I am Sameer, a professional software developer with over 15 years of industry experience. I love to educate myself and others and that's why I started with my youtube channel where I have a loving audience. I create content for software developers like you so that I can share my knowledge.

Statistics

Over 11000 students on Udemy

Over 2000  Reviews on Udemy

Over 1.4 Million Views on Youtube

Some of the reviews

==> Hands down the best way to learn this technology stack. Sameer really did a good job here and I hope he will be blessing us with more interesting Angular projects in the future! Maybe a sample e-commerce or Hotel Booking app :)

==> Although I didn't have any prior experience with C# OR .Net Core MVC, I was still able to grasp a lot from this course, all thanks to the instructor!
==> A very detailed and extensive course! clear voice and great detail to topics.
... and1000s of more reviews on my courses.

Money Back Guarantee

I Guarantee you that after finishing this course, you will be confident enough to create REST APIs in ASP.NET Core  and .NET 7 on your own.

You will feel confident at work or creating your own projects.

If you want to create functional, generic, clean, and usable websites using ASP.NET, then this is the course for you.

If still, you are unable to get benefit from this course (we will be sad to see you go!), there is a "30-day money back guaranteed by Udemy".

Why do you need this course?

By buying this course, you will make a fantastic choice as this course will help you gain the confidence you need to create ASP.NET Core Web APIs

I assure you that by the end of this course, you will have the confidence to create scalable ASP.NET Core Web APIs from scratch.

1. Introduction to building ASP.NET Core Web APIs using .NET6
2. Introduction to building ASP.NET Core Web APIs using .NET6
3. Prerequisites
4. Setting up development environment
5. Download and Install Visual Studio 2022
6. Install .NET SDK and .NET Runtime
7. Install SQL Server Management Studio
8. Getting help
9. Complete Source Code & GITHUB Repository Link
10. [OLD Content] Complete Source Code and GITHUB Repository
11. Create New ASP.NET Core Web API & Domain Models
12. Introduction
13. Create New ASPNET Core Web API
14. Understand ASP.NET Core Web API and File Structure
15. Understand REST and HTTP Verbs
16. Routing In ASP.NET Core Web API
17. Running and Calling ASP.NET Core Web API
18. Understanding Our Domain (Domain Driven Development)
19. Create Domain Models
20. Adding Entity Framework Core Packages
21. Creating the DBContext Class
22. Adding ConnectionString To The Database In Appsettings.Json
23. Understanding Dependency Injection & Injecting DbContext Into Our Application
24. Run EF Core Migrations
25. Quiz For Section 2
26. Create New Controller - Regions Controller and CRUD Operations / Action Methods
27. Introduction
28. Create New Controller (Regions Controller)
29. Get All Regions Action Method
30. Get Region By Id Action Method
31. DTOs and Domain Models
32. Change Methods To Use DTOs
33. Create Region Action Method
34. Update Region Action Method
35. Delete Region Action Method
36. Asynchronous Programming, Repository Pattern and Automapper
37. Introduction
38. Asynchronous Programming and Implement Async Await In our Methods
39. Repository Pattern and Benefits
40. Implement Repository Pattern In ASP.NET Core Web APIs
41. Add Other Methods To Repository
42. Automapper Introduction
43. Implement Automapper
44. Functionality For Walks - Create, Read, Update, Delete For Walks
45. Introduction
46. Seeding Data Using Entity Framework Core
47. Creating Walks Controller and Create New Walk Action Method
48. Get All Walks Action Method
49. Navigation Properties In Entity Framework Core
50. Get Walk By Id Action Method
51. Update Walk Action Method
52. Delete Walk Action Method
53. Validations in ASP.NET Core Web API
54. Introduction To Model Validations
55. Adding Model Validations To Endpoints
56. Custom Validate Model Attribute
57. Filtering, Sorting, Pagination in ASP.NET Core Web API
58. Introduction
59. Seeding Data in SQL Server
60. Filtering
61. Sorting
62. Pagination
63. Securing our ASP.NET Core API - Authentication and Authorization - JWT Tokens
64. Introduction
65. Authentication Flow
66. Setting Up Authentication - Install Nuget Packages
67. Testing Authentication Without JWT Token
68. Setting Up Identity DbContext
69. Seeding Roles
70. Run EF Core Migrations To Create Identity Database
71. Setting Up Identity
72. Create Auth Controller and Register Action Method
73. Create Login Action Method
74. Create JWT Token in ASP.NET Core Web API
75. Inject TokenRepository and Create Token
76. Role Based Authorization
77. Add Authorization To Swagger
78. Image Upload In ASP.NET Core Web API
79. Introduction
80. Create Domain Model For Image Upload
81. DbContext changes and Migrations For Image Upload
82. New Controller and Action Method for Image Upload
83. Image Upload Repository Implementaion
84. Serving Static Files Through ASPNET Core Web API
85. Advanced Functionality in ASP.NET Core Web APIs
86. Introduction To Logging
87. Add Logging to Console in ASP.NET Core Web API
88. Add Logging to Text File In ASP.NET Core Web APIs
89. Global Exception Handling In ASP.NET Core Web APIs
90. Versioning In ASP.NET Core Web API
91. What is Versioning and How To Implement Versioning in ASP.NET Web API
92. Implement Versioning in ASP.NET Core Web API By Folder Structure
93. Implement Versioning By Nuget Package - Proffered Approach
94. Fix Versioning In Swagger
95. Consuming our Web API
96. Consuming REST Web APIs
97. Creating ASP.NET MVC Web Application
98. GET - Consume Web API
99. POST - Consume Web API
100. GET single Region - Edit Region Prerequisite
101. PUT - Updating Using Web API
102. DELETE - Deleting a Resource using Web API
103. Deploying ASP.NET Web API To Azure
104. Deploying ASP.NET Web API To Azure
105. BONUS Section
106. BONUS Lecture
107. Old .NET 6 Content Below
108. [OLD Content .NET6] Create New ASP.NET Core Web API
109. Introduction
110. Install GIT and Create New GIT Repository
111. Create New ASP.NET Web API
112. Pushing New API to GIT
113. Understanding Our New .NET Web API
114. Understanding REST and HTTP Verbs
115. Running The Project And Using Swagger
116. Understanding Our Domain
117. Creating Domain Models In Our ASP.NET Web API
118. Install Entity Framework Core Nuget Packages
119. Create DBContext
120. Create Connection String To Database
121. Understanding Dependency Injection
122. Injecting DbContext Class
123. Running EF Core Migrations
124. Seeding Data Into Database
125. Saving Our Changes To GIT
126. [OLD Content .NET6] Create New Controller - Regions Controller
127. Introduction
128. Create Regions Controller
129. Testing Get All Regions Method
130. Understanding The Repository Pattern
131. Create Region Repository
132. Test API in Swagger
133. Adding DTOs or Contracts
134. Install and Use Automapper
135. Understand Synchronous vs ASynchronous Code
136. Making Our Code Asynchronous
137. Saving Our Changes To GIT
138. [OLD Content .NET6] Creating CRUD on Region Controller
139. Introduction
140. Creating Repository Method Get Region By Id
141. Creating Controller Method For GetRegionById
142. Testing GetRegionById method using Swagger
143. Creating Repository Method for AddRegion
144. Creating Controller Method For AddRegion
145. Testing AddRegion Method using Swagger
146. Creating Repository method for DeleteRegion
147. Creating Controller Method For DeleteRegion
148. Testing DeleteRegion method using Swagger
149. Creating Repository method for UpdateRegion
150. Creating Controller Method For UpdateRegion
151. Testing UpdateRegion method using Swagger
152. Saving Our Changes To GIT
153. Assignment For Next Section - Walks API
154. [OLD Content .NET6] Creating Walks Controller and Implementing Walks CRUD
155. Introduction
156. Create Repositories For Walks And Add To Services
157. New repository method for GetAllWalks
158. New Controller and method for GetAllWalks
159. Testing GetAllWalks method using Swagger
160. Adding Navigation Properties For WalkDifficulty and Region
161. Creating Repository Method for GetWalkById
162. Creating Controller Method For GetWalkById
163. Testing GetWalkById method using Swagger
164. New repository method and Controller Method for AddWalk
165. Testing AddWalk method using Swagger
166. New repository method and Controller Method for UpdateWalk
167. Testing UpdateWalk method using Swagger
168. New Repository Method and Controller Method for DeleteWalk
169. Testing DeleteWalk method using Swagger
170. Saving Our Changes To GIT
171. [OLD Content .NET6] Creating WalkDifficulty Controller And WalkDifficulty CRUD
172. Introduction
173. Create Repositories For WalkDifficulty And Add To Services
174. New Method For GetAllWalkDifficulties and Swagger Testing
175. New Method For GetWalkDiffultyById and Swagger Testing
176. New Method For AddWalkDifficulty and Testing In Swagger
177. New Method For UpdateWalkDifficulty and Testing In Swagger
178. New Method For DeleteWalkDifficulty and Testing In Swagger
179. Saving Our Changes To GIT
180. [OLD Content .NET6] Validations In ASP.NET CORE WEB API
181. Introduction
182. Validating Region Controller - AddRegionRequest Model
183. Testing AddRegionRequest Validation
184. Validating Region Controller - UpdateRegionRequest Model
185. Validating Walks Controller - AddWalkRequest Model
186. Validating Walks Controller - UpdateWalkRequest Model
187. Validating WalkDifficulty Controller
188. Saving Our Changes to GIT
189. Introduction To Fluent Validations
190. Setting Up Fluent Validations
191. Adding AddRegion Validations Using Fluent Validations
192. Adding UpdateRegion Validations Using Fluent Validations
193. Adding Validations For WalkDifficulties API Using Fluent Validations
194. Adding Validations For Walks API Using Fluent Validations
195. [OLD Content .NET6] Authentication & Authorization In ASP.NET CORE WEB API
196. Introduction
197. Authentication Flow
198. Setting Up Authentication
199. Testing Authentication Without Token
200. Creating Users and Static User Repository

This course has been refreshed and completely updated for .Net 7.0 and Angular 14.

Have you learnt the basics of ASP.NET Core and Angular?  Not sure where to go next?  This course should be able to help with that.  In this course we start from nothing and incrementally build up our API and Angular front end until we have a fully functional Web Application that we then publish to IIS and a Linux server.

These are 2 of the hottest frameworks right now for the 'back-end' (Microsoft's ASP.NET Core) and the 'front-end' (Google's Angular) and are well worth spending the time to learn.

In this course we build a complete application from start to finish and every line of code is demonstrated and explained.

This course is right up to date as at November 2022 using .Net 7.0 and Angular v14 and as these frameworks evolve, this course will evolve with it.  

Read some of the great reviews of the course:

Jim says "The absolute best course for building an API in .Net core and working with Angular!"

Daniyal says: "This is a complete project based course from start to finish with real world experience using technologies that are currently in demand in the market. People interested in learning latest technologies should consider this course."

Here are some of the things you will learn about in this course:

• Setting up the developer environment

• Creating the ASP.NET Core WebAPI and the Angular app using the DotNet CLI and the Angular CLI

• Adding a Client side login and register function to our Angular application

• Adding 3rd party components to add some pizzazz to the app

• Adding routing to the Angular application and securing routes.

• Using Automapper in ASP.NET Core

• Building a great looking UI using Bootstrap

• Adding Photo Upload functionality as well as a cool looking gallery in Angular

• Angular Template forms and Reactive forms and validation

• Paging, Sorting and Filtering

• Adding a Private Messaging system to the app

• Publishing the application to Heroku free of charge

• Using SignalR for real time presence and live messaging between users

• Many more things as well

Tools you need for this course

In this course all the lessons are demonstrated using Visual Studio Code, a free (and fantastic) cross platform code editor.   You can of course use any code editor you like and any Operating system you like... as long as it's Windows, Linux or Mac

Is this course for you?

This course is very practical, about 90%+ of the lessons will involve you coding along with me on this project.  If you are the type of person who gets the most out of learning by doing, then this course is definitely for you.  

On this course we will build an example Dating Application, completely from scratch using the DotNet CLI and the Angular CLI to help us get started.  All you will need to get started is a computer with your favourite operating system, and a passion for learning how to build an application using ASP.NET Core and Angular.  

1. Introduction
2. Introduction to the course
3. Setting up the developer environment
4. Getting help
5. Course assets and source code
6. Building a walking skeleton Part One - API
7. Introduction
8. Creating the .Net API Project using the dotnet CLI
9. Setting up VS code to work with C#
10. VS Code tips and troubleshooting
11. Getting to know the API project files
12. Creating our first Entity
13. Introduction to Entity Framework
14. Adding Entity Framework to our project
15. Adding a DbContext class
16. Creating the Connection string
17. Creating the database using Entity Framework Code first migrations
18. Adding a new API Controller
19. Making our code Asynchronous
20. Saving our code into Source control
21. Section 2 Summary
22. Building a walking skeleton Part Two - Angular
23. Introduction
24. Creating the Angular application
25. Running the angular project and reviewing the bootstrap of the app
26. Adding VS Code extensions to work with Angular
27. Making HTTP requests in Angular
28. Adding CORS support in the API
29. Displaying the fetched users in the browser
30. Adding bootstrap and font-awesome
31. Adding HTTPS to Angular using mkcert
32. LEGACY (will be removed Nov 23) Using HTTPS in angular - MAC
33. LEGACY (will be removed Nov 23) Using HTTPS in angular - WINDOWS
34. Saving into source control
35. Section 3 summary
36. Authentication basics
37. Introduction
38. Safe storage of passwords
39. Updating the user entity
40. Creating a base API controller
41. Creating an Account Controller with a register endpoint
42. Using the debugger
43. Using DTOs
44. Adding validation
45. Adding a login endpoint
46. JSON web tokens
47. Adding a token service
48. Adding the create token logic
49. Creating a User DTO and returning the token
50. Adding the authentication middleware
51. Adding extension methods
52. Section 4 summary
53. Client login and register
54. Introduction
55. Creating a nav bar
56. Introduction to Angular template forms
57. Introduction to Angular services
58. Injecting services into components
59. Using conditionals to show and remove content
60. Using the angular bootstrap components - dropdown
61. Introduction to observables
62. Persisting the login
63. Using the async pipe
64. Adding a home page
65. Adding a register form
66. Parent to child communication
67. Child to parent communication
68. Hooking up the register method to the service
69. Section 5 summary
70. Routing in Angular
71. Introduction
72. Creating some more components
73. Adding the nav links
74. Routing in code
75. Adding a toast service for notifications
76. Adding an Angular route guard
77. Adding a dummy route
78. Adding a new theme
79. Tidying up the app module by using a shared module
80. Section 6 summary
81. Error handling
82. Introduction
83. Creating an error controller for testing errors
84. Handling server errors
85. Exception handling middleware
86. Testing errors in the client
87. Adding an error interceptor
88. Validation errors
89. Handling not found
90. Adding a server error page
91. Section 7 summary
92. Extending the API
93. Introduction
94. Extending the user entity
95. Adding a DateTime extension to calculate age
96. Entity Framework relationships
97. Generating seed data
98. Seeding data part one
99. Seeding data part two
100. The repository pattern
101. Creating a repository
102. Updating the users controller
103. Adding a DTO for Members
104. Adding AutoMapper
105. Using AutoMapper
106. Configuring AutoMapper
107. Using AutoMapper queryable extensions
108. Section 8 summary
109. Building the User Interface
110. Introduction
111. Using TypeScript
112. Creating the member interface
113. Adding a member service
114. Retrieving the list of members
115. Creating member cards
116. Adding some style to the cards
117. Adding animated buttons
118. Using an interceptor to send the token
119. Routing to the detailed page
120. Styling the member detailed page
121. Styling the member detailed page part two
122. Adding a photo gallery (Angular 16+)
123. LEGACY (will be removed Nov 23) Adding a photo gallery (Angular 13 and below)
124. Section 9 summary
125. Updating resources
126. Introduction
127. Creating a member edit component
128. Creating the edit template form
129. Adding the update functionality
130. Adding a Can Deactivate route guard
131. Persisting the changes in the API
132. Updating the user in the client app
133. Adding loading indicators
134. Using the service to store state
135. Section 10 summary
136. Adding photo upload functionality
137. Introduction
138. Cloudinary Account
139. Configuring cloudinary in the API
140. Adding a photo service
141. Updating the users controller
142. Testing the photo upload
143. Using the Created At Route method
144. Adding a photo editor component
145. Adding a photo uploader
146. Adding a photo uploader part two
147. Setting the main photo in the API
148. Adding the main photo image to the nav bar
149. Setting the main photo in the client
150. Deleting photos - API
151. Deleting photos - Client
152. Section 11 summary
153. Reactive forms
154. Introduction
155. Reactive forms introduction
156. Client side validation
157. Adding custom validators
158. Validation feedback
159. Creating a reusable text input
160. Using the form builder service
161. Expanding the register form
162. Adding a reusable date input
163. Updating the API register method
164. Client side registration
165. Section 12 summary
166. Paging, Sorting and Filtering
167. Introduction
168. Adding a paged list class
169. Adding helper classes for pagination
170. Using the pagination classes
171. Setting up client pagination
172. Using the angular bootstrap pagination component
173. Adding filtering to the API
174. Adding additional filters
175. Cleaning up the member service
176. Adding filter buttons to the client
177. Adding sorting functionality
178. Adding an action filter
179. Making the Last Active action filter more optimal
180. Sorting on the client
181. Formatting dates
182. Restoring the caching for members
183. Restoring caching for member detailed
184. Remembering the filters for a user in the service
185. Section 13 summary
186. Adding the Like User feature
187. Introduction
188. Adding a likes entity
189. Adding a likes repository
190. Implementing the likes repository
191. Controller methods for the likes feature
192. Setting up the likes functions in the Angular app
193. Adding the likes component
194. Adding pagination for the likes
195. Paginating the likes on the client
196. Section 14 summary
197. Adding the messaging feature
198. Introduction
199. Setting up the entities for messaging
200. Setting up the message repository

A Comprehensive Course on ASP.NET MVC (.NET 7 MVC ) where you will learn and master your ASP.NET Core skills and be excellent at making websites using the ASP.NET MVC Framework.

Use C# and .NET 7 to develop web applications using ASP.NET MVC Framework.

Why do you need this course?

If you are trying to learn ASP.NET Core and specifically build websites with ASP.NET Core MVC and Entity Framework Core (EF Core), then you have come to the right course.

This course helps you understand ASP.NET MVC as you have never thought of.

Concentrating on the practical aspect of web development, You will learn and master ASP.NET Core MVC and with the help of this course and the knowledge you will acquire in this course, you will be able to implement that in your projects and your organization as well.

What is special about this particular  ASP.NET Core MVC course?

• In this course, we will build a Real-World Web Application as we learn the core concepts of ASP.NET MVC.

• Building a real application will make you confident and will boost your morale as you will be seeing actual stuff being built as you understand the concepts of ASP.NET Core MVC and Entity Framework Core (EF Core).

• This is a complete guide to Learning and Building scalable and data-driven websites using ASP.NET, ASP.NET Core [.NET 7], and MVC Framework.

• This course is built on the latest ASP.NET Core version. Through this course, you will get to know about the new features of ASP.NET Core and stay up to date with this technology.

• This course is for all skill levels and is best suited for beginners and intermediate developers who have gained knowledge in C# and ASP.NET framework and want to use their skills to build websites using ASP.NET Core MVC.

Know me more

I am Sameer, a professional software developer with over 15 years of industry experience. I love to educate myself and others and that's why I started with my youtube channel where I have a loving audience. I create content for software developers like you so that I can share my knowledge.

Statistics

Over 11000 students on Udemy

Over 2000  Reviews on Udemy

Over 1.4 Million Views on Youtube

Some of the reviews

Hands down the best way to learn this technology stack. Sameer really did a good job here and I hope he will be blessing us with more interesting Angular projects in the future! Maybe a sample e-commerce or Hotel Booking app :)

- Although I didn't have any prior experience with C# OR .Net Core MVC, I was still able to grasp a lot from this course, all thanks to the instructor!
- A very detailed and extensive course! clear voice and great detail to topics.
... and1000s of more reviews on my courses.

Money Back Guarantee

I Guarantee you that after finishing this course, you will be confident enough to create web applications using .NET Core MVC on your own.

You will feel confident at work or creating your own projects.

If you want to create functional, generic, clean, and usable websites using ASP.NET, then this is the course for you.

If still, you are unable to get benefit from this course (we will be sad to see you go!), there is a "30-day money back guaranteed by Udemy".

In this course, you will learn and implement:

• Learn And Create Your First ASP.NET MVC Application

• Create a fully functional, highly scalable blog application

• Repository Pattern in ASP.NET Core

• If you come from an ASP.NET background, then this will be a good step forward in learning the latest Web technology that Microsoft gives us to build websites and that is ASP.NET MVC.

• Understand and learn the concepts of .NET 7 and apply them using the ASPNET MVC Framework

• Domain Modelling

• Entity Framework Code First Approach

• SQL Server

• Seeding the Database

• CRUD operations using ASP.NET MVC

• Showing Notifications (ViewData, TempData, etc)

• Routing in ASP NET MVC

• Domain Models vs View Models

• Authentication and Authorization

• Multi-Role Authorization

• Full User and Admin Support in the Blog Application

• Rich Text Editor

• Uploading Images To A 3rd Party Image Hosting Provider

• Creating APIs within our ASP NET Core MVC Application and Call Them using Javascript

• Server-Side and Client-Side Validations.

• Create, Read, Update, and Delete using Entity Framework Core and SQL Server

• Web Development Using MVC in ASP.NET Core

• Write Clean, Re-Usable Code

1. Introduction to ASP.NET Core MVC Web Development
2. Introduction
3. Application Demo
4. Setting Up Development Environment
5. Install .NET SDK and .NET Runtime
6. Download and Install Visual Studio 2022
7. Download and Install SQL Server (Local Instance) & SQL Server Management Studio
8. Getting Help
9. Complete Source Code On GIT
10. What is ASP.NET Core - An Overview to ASP.NET Core and it's benefits
11. Create ASP.NET MVC Web Application From Scratch
12. Create New ASP.NET MVC Web Application
13. Understand Our ASP.NET MVC Web Application and File Structure
14. Create Domain Models (Blog Post and Tag)
15. Adding Entity Framework Core Packages
16. Creating the DBContext Class
17. Adding ConnectionString To The Database In Appsettings.Json
18. Injecting DbContext Into Our Application
19. Run EF Core Migrations
20. Create Tag CRUD Operations in ASP.NET MVC
21. Introduction to ASP.NET MVC Architecture
22. Changes to UI For our Application
23. Create New Controller (AdminTags), Add Action Method (GET) and Create New View
24. Create New HTML Form to Add new Tags
25. Form Submission and Data Binding in ASP.NET MVC
26. Saving Data To Database using DbContext
27. Display All Tags (Get all Tags)
28. Edit or Update Tag Functionality
29. Delete Tag Functionality
30. Asynchronous Programming and Repository Pattern
31. Introduction
32. Asynchronous Programming and making our methods Asynchronous
33. Understanding Repository Pattern and Implementation in ASP.NET
34. BlogPost CRUD Operations - Dropdowns, Checkbox, DatePickers etc
35. Introduction
36. Create New Controller (AdminBlogs), Add Action Method (GET) and Create New View
37. Create New HTML Form to Add new Blog
38. Saving BlogPost Entity With Tags To The Database
39. Display All Blogs (Get all Blogs)
40. Display Edit Blog Functionality
41. Edit or Update Blog Functionality
42. Delete Blog Functionality
43. Adding WYSIWYG Editor and Image Upload In ASP.NET Core MVC
44. Introduction
45. Add WYSIWYG Editor on Add and Edit BlogPost Page
46. Image Upload Introduction
47. Create Image API
48. Create POST Method and Image Repository
49. Register To Cloudinary
50. Inject Image Repository and Test
51. Call Image Upload From View
52. Add FeaturedImageUpload To Edit Page
53. Add Image Upload To Froala WYSIWYG Editor
54. Displaying Blogs and Tags To Users
55. Introduction
56. Seeding Blog and Tag Data
57. Displaying Blogs and Hero Section
58. Display Single Blog Post and Blog Details
59. Displaying Tags On Home Page
60. Authentication and Authorization in ASP.NET MVC ( ASP.NET Core Identity)
61. Introduction
62. Install Identity Packages
63. Add ConnectionString and Inject AuthDbContext in Program
64. Run Entity Framework Core Migrations
65. Register User Functionality
66. Login User Functionality
67. Logout User Functionality
68. Authorization In our Application
69. Adding Role Based Authorization
70. Adding ReturnUrl After Authorization
71. Adding Like and Comment Functionality In Our Blog
72. Introduction
73. Domain Models For Like Functionality and Migrations
74. Display Total Likes - Likes Repository
75. Implement Like Functionality
76. Updates To Like Functionality
77. Domain Models For Comment Functionality and Migration
78. Add Comment Functionality
79. Display Comments
80. Manage Users - Create Read Delete
81. Introduction
82. Display Users
83. Create New User
84. Delete User
85. Validations - Server Side and Client Side Validations
86. Introduction
87. Client Side VS Server Side Validations
88. Register Page - Server Side Validations
89. Register Page - Client Side Validations
90. Login Page - Server and Client Side Validations
91. Add New Tag Page - Server and Client Side Validation
92. Custom Validations
93. BONUS Section
94. BONUS Lecture

The course is updated to use .NET 8 in 2023.

Authentication and Authorization are vital components of modern web app and web API development. ASP.NET Core Identity provides a complete solution to achieve this purpose. While it may seem easy to scaffold a solution with a few clicks, truly adapting it to your specific project requirements demands a deep understanding of how ASP.NET Core Identity works from the inside out.

With 5 sections and about 7 hours of high-quality content created by Frank Liu - a senior software developer with over 20 years of experience in .NET development - this course will empower you with comprehensive knowledge and practical skills.

Why Choose This Course:

• Clear and logical explanations with diagrams: Gain a solid theoretical understanding of authentication and authorization through visually engaging diagrams, providing you with a deeper comprehension of the subject matter.

• In-depth exploration: Secure your web app and web APIs without relying solely on ASP.NET Identity, understanding what lies beneath the surface.

• ASP.NET Core Identity mastery: Learn not only how to code with ASP.NET Core Identity but also comprehend the reasons behind its workings.

• Multi-Factor Authentication (MFA): Master MFA essentials, starting with Email MFA and progressing to the use of the Authenticator App.

• External Authentication Providers: Discover how to integrate social media login with Facebook as an external authentication provider.

You will learn the following topics in depth:

1. Section #1: Authentication and Authorization UNDER the HOOD.

You will start with a solid understanding of the theory of authentication and authorization first and then you will be learning to secure your web app without using ASP.NET Identity, so that you know what is under the hood. This builds a strong foundation for you.

2. Section #2: Securing Web APIs

Same idea with the previous section, but here we are securing Web APIs.

3. Section #3: ASP.NET Core Identity In Depth

Now we are getting into ASP.NET Core Identity. Here you will not only learn how to code with ASP.NET Core Identity, but you will learn all the reasons behind the working of Identity with the knowledge you have just learned in the previous sections.

4. Section #4: MFA in ASP.NET Identity

MFA is a must when you work with a public facing website. Hence, this section is very important. After the in-depth explanation of the concept, you will start with a simpler Email MFA scenario, then moving on to the Authenticator App MFA case.

5. Section #5: External Authentication Providers

Lots of applications (public facing or not) want to use external social media to manage the user login, so that the applications can focus on the business logic. This section takes Facebook Login as an example and walks you through the steps of using an external authentication provider.

You will master the following technical skills:

• What are Identities, Claims, and Principal (Security Context).

• Cookie Authentication for Web App.

• Authentication and Authorization handlers

• Policy based Authorization

• Create Custom Policies

• JWT Token Authentication for Web APIs / REST APIs.

• ASP.NET Core Identity Configuration

• Use Identity to implement all typical scenarios including: User Registration, User Login, Logout, Email confirmation, Roles vs Claims and User Profile page.

• MFA with Email.

• MFA with Authentication App.

• Social Media login with Facebook.

  
  

What you will need:

• Intermediate Level of C# or at least 6 months of experience.

• Intermediate Level of ASP.NET Core or at least 6 months of experience.

• Basic HTML.

• You should know OOP and the concept of interface in C#.

• You are interested in learning this topic.

• You are eager to learn.

  
  

Who this course is for:

• ASP .NET Core Developers

• API Developers

• Mobile Application Developers

• C# or VB NET Developers

  
  

Last but Not least:

Enjoy this course and don't forget to check out my other courses:

• Complete guide to Web API in .NET 8

• Learn Blazor while creating an Inventory Management system

• Clean Architecture course

• Learn .NET MAUI while creating a Contacts App

Enroll now to become an expert in authentication, authorization, and ASP.NET Core Identity, and take your web API development skills to the next level! Experience the power of clear explanations complemented by visually engaging diagrams, ensuring you gain a comprehensive understanding of the subject matter. Don't miss the opportunity to learn from an experienced instructor and excel in your career development.

1. Web Security Under the Hood for Web Applications
2. Lecture 1: Security Overview
3. Authentication & Authorization Flow
4. ASP.NET Core Basics
5. Security Context in ASP.NET Core
6. Anonymous Identity
7. Source Code
8. Create Login Page
9. Generate Cookie with Cookie Authentication Handler
10. Read Cookie with Authentication Middleware
11. Authorization Architecture & Flow
12. Simple Policy based Authorization
13. Login & Logout Partial View
14. Custom Policy based Authorization
15. Cookie Lifetime & Browser Session
16. Secure Web APIs
17. Cookie vs Token and Our Use Case
18. Create & Consume a Web API Endpoint
19. What is JWT Token
20. The Typical JWT Flow
21. Generate JWT Token with JWT Token Handler
22. Read JWT Token with Authentication Handler & Middleware
23. Consume the Endpoint protected by JWT Token
24. Store & Reuse Token in Session
25. Apply Policy to WebAPI Endpoint
26. ASP.NET Core Identity
27. The Three Essential Parts of Identity
28. Install Nuget Packages for Working with Identity
29. Create the Database for Identity
30. Configure Web App to Use Identity
31. Core Classes of Identity
32. User Registration Workflow
33. User Registration
34. User Login
35. Email Confirmation Flow
36. Email Confirmation Dry Run
37. Confirm Email Page
38. Send Email
39. Refactor Email Sending Code
40. Sign Out
41. Collecting More User Info with IdentityUser schema change
42. Collecting More User Info with Claims
43. Roles
44. Create a User Profile page
45. ASP.NET Core Identity MFA
46. What is MFA
47. How 2FA works through email
48. Implement Email 2FA
49. How 2FA with Authenticator App works
50. Implement Authenticator MFA Setup (manual)
51. Implement Authenticator MFA Code Checking
52. Use QR Code for MFA Setup
53. External Authentication Providers
54. Overview of Login with Social Media Accounts
55. Setup App Account in Facebook
56. Extra: How OAuth Really works
57. Delegate Login to Facebook
58. Implement Callback Controller
59. Thank you and Next Steps
60. Thank you and Next Steps
61. (OLD COURSE) Web Security Under the Hood for Web Applications
62. Security Overview
63. Authentication & Authorization Flow
64. ASP.NET Core Basics
65. Security Context in ASP.NET Core
66. Anonymous Identity
67. .Net 6 Update
68. Create a Login Page
69. Generate Cookie with Cookie Authentication Handler
70. Read Cookie with Authentication Middleware
71. Authorization Architecture & Flow
72. Simple Policy based Authorization
73. Login & Logout Partial View
74. Custom Policy based Authorization
75. Cookie Lifetime & Browser Session
76. (OLD COURSE) Secure Web APIs
77. Cookie vs Token and Our Use Case
78. Create & Consume a Web API Endpoint
79. What is JWT Token
80. The Typical JWT Flow
81. Generate JWT Token with JWT Token Handler
82. Read JWT Token with Authentication Handler & Middleware
83. Consume the Endpoint protected by JWT Token
84. Store & Reuse Token in Session
85. Apply Policy to WebAPI Endpoint
86. (OLD COURSE) ASP.NET Core Identity
87. The Three Essential Parts of Identity
88. Create a Web App
89. Install Nuget Packages for Working with Identity
90. Create the Database for Identity
91. Configure Web App to Use Identity
92. Core Classes of Identity
93. User Registration Workflow
94. User Registration
95. User Login
96. Email Confirmation Flow
97. Email Confirmation Dry Run
98. Confirm Email Page
99. Send Email
100. Refactor Email Sending Code
101. Sign Out
102. Collecting More User Info with IdentityUser schema change
103. Collecting More User Info with Claims
104. Roles
105. Create a User Profile page
106. (OLD COURSE) ASPNET Core Identity MFA
107. What is MFA
108. How 2FA works through email
109. Implement Email 2FA
110. How 2FA with Authenticator App works
111. Implement Authenticator MFA Setup (Manual)
112. Implement Authenticator MFA Code Checking
113. Use QR Code for MFA Setup
114. (OLD COURSE) External Authentication Providers
115. Overview of Login with Social Media Accounts
116. Setup App Account in Facebook
117. Extra: How OAuth Really works
118. Delegate Login to Facebook
119. Implement Callback Controller