Mô tả


[UPDATE, June 19]: Added a new section to the course.

With over 3,000 students and 300+ positive reviews, this course is Udemy's most popular course for learning ASP.NET Core in the context of a real project! 


ASP.NET Core is the next generation of ASP.NET MVC. It's a complete re-write of this framework but in a modular, cloud-optimized and cross-platform way. So it can run on Windows, Linux and Mac. If you're on Mac or Linux and want to build ASP.NET applications without running Windows in a virtual machine, you're going to love ASP.NET Core! You can use Visual Studio Code (VSCode) or your favorite code editor to build ASP.NET Core applications with C#. Say goodbye to VMWare, Parallels, and other virtualization software. 


Many companies have already started building their new applications with ASP.NET Core. And they're asking their new interviewees if they are familiar with .NET Core. So, whether you want to stay in the marketplace and get a better job with better pay, or you just love to work with the latest technology, it's time to learn about ASP.NET Core and Entity Framework Core. 


In this course, Mosh, author of several highly rated courses on Udemy, teaches you how to build a real-world application with ASP.NET Core, Entity Framework Core and Angular. If you're familiar with ASP.NET MVC 5 and Entity Framework 6 and are looking for a course to quickly get up to speed with .NET core, this is the course for you. Not only will you learn about the changes and the new tooling in ASP.NET Core, you'll also learn how to properly integrate it with Angular to build real-world single page applications (SPAs). 



A REAL-WORLD APP

The app you build in this course is for an imaginary vehicle dealer. The features in this app are carefully designed by Mosh to help you master the core skills you need to build real-world apps with ASP.NET Core and Angular. 

By the end of watching this course, you'll be able to:

  • Build APIs with ASP.NET Core

  • Test APIs with PostMan

  • Integrate Angular and ASP.NET Core 

  • Implement a clean and decoupled architecture 

  • Understand and apply the Dependency Inversion Principle (DIP)

  • Properly implement the repository and unit of work patterns 

  • Use the new dependency injection feature in ASP.NET Core 

  • Troubleshoot common runtime errors 

  • Store and retrieve data with Entity Framework Core (code-first workflow)

  • Use AutoMapper 

  • Implement CRUD operations (including one-to-many and many-to-many relationships)

  • Implement filtering, sorting and paging data

  • Handle and logging errors 

  • Display toast notifications 

  • Implement cascading drop-down lists

  • Implement photo upload with progress bars

  • Add authentication and authorization with Auth0 (including roles with different privileges)

  • Display charts 

  • And more...





On top of all these, you'll learn how to write quality code, not just how to build apps. There are a lot of developers out there who can build apps but they write poor quality code. Mosh shows you how to refactor bad code into clean, maintainable and quality code. He also shares his knowledge and 15 years of experience about software design and architecture. So this course is more than just technology. It teaches you how to think like a software engineer. 


These are the essential skills that you take with you to nearly every real-world project. Whether you want to get prepared for a job interview or simply want to take your coding skills to the next level, this course is the means to the destination. 




TOOLING

There are two ways to build ASP.NET Core applications. You can use Visual Studio 2017 or Visual Studio Code, a light-weight cross-platform code editor. In this course, Mosh uses VSCode and the command-line to build an app, but what you learn can be applied in Visual Studio 2017 as well. 



WHO THIS COURSE IS FOR 

In order to take this course, you should have at least 3 months experience with ASP.NET MVC 5, Entity Framework 6 and Angular 2 (or higher)

If you need to strengthen your understanding of these frameworks, you can watch Mosh's related courses prior to or in parallel with this course: 

  • Angular 2 with TypeScript for Beginners

  • The Complete ASP.NET MVC 5 Course

  • Entity Framework 6 in Depth 


60 DAY CHALLENGE PROGRAM 

Depending on your level of experience, there are different ways to take this course. You can watch it, section by section, just like other courses. You may prefer to code along with the videos or watch a section first and then code. 

But if you like to get out of your comfort zone and take your coding skills to the next level, you should take advantage of the 60 day challenge program that comes with this course. 

Imagine you and Mosh are team mates and are working on a real-world project. Every week Mosh gives you a challenge or a task to complete. You have one week to complete this task. The following week he publishes a new section and shows you how he completes that task himself. This is a fantastic learning opportunity for you. You can compare your code with his and find areas for improvement. 



WHAT THIS COURSE IS NOT 

While you use ASP.NET Core and Entity Framework to build an app, the focus of this course is on application building skills and not a deep overview of ASP.NET Core and Entity Framework. Because in any real-world applications, you use only a subset of the features in any frameworks. So, it's impossible to cover everything about ASP.NET Core and Entity Framework in one app. But you'll learn about the key things that you need to know in order to get the job done. 

Also, the following topics are outside the scope of this course: 

  • Complex domains and domain-driven design (DDD)

  • Design patterns

  • Continuous integration and deployment

  • Automated testing

Finally, the application you'll build in this course has a very simple user interface since the focus of this course is on coding not building visually engaging user interfaces. 



TAKE YOUR CODING SKILLS TO THE NEXT LEVEL 

So, do you want to transition from ASP.NET MVC 5 and learn about the latest stuff happening in .NET Core? Do you want to learn how to build a real-world application with ASP.NET Core and Angular? Then take this course and get started. 


This course comes with a 30-day money back guarantee. If you're not satisfied, you can contact Udemy for a full refund. No questions asked. 


Join the other 3,000 happy students who have taken this course and start building this app in under 10 minutes! 






Bạn sẽ học được gì

Build real-world applications with ASP.NET Core and Angular 2

Integrate ASP.NET MVC / Core with Angular 2

Implement a clean and decoupled architecture

Understand and apply the Dependency Inversion Principle (DIP)

Properly implement the repository and unit of work patterns

Use the new dependency injection feature in ASP.NET Core

Troubleshoot common runtime errors

Build APIs with ASP.NET Core

Test APIs using PostMan

Use AutoMapper

Store and retrieve data using Entity Framework Core (Code-first approach)

Implement CRUD operations (including one-to-many and many-to-many relationships)

Implement filtering, sorting and pagination

Handle and log errors

Display toast notifications

Implement photo upload with progress bar

Add authentication and authorization using Auth0 and JWTs

Write clean, maintainable and reliable code

Refactor bad code into good code

Better understand software development lifecycle

Yêu cầu

  • At least 3 months experience with ASP.NET MVC 5, Entity Framework 6 and Angular 2

Nội dung khoá học

10 sections

Getting Started

18 lectures
Introduction
01:45
The Scope
05:30
Prerequisites
01:13
Application Requirements
02:20
An Important Note
01:10
Setting Up the Development Environment
05:44
Installing SQL Server on macOS / Linux
09:26
Creating a New Project
04:11
Project Structure
04:53
Application Startup
07:02
Environments
04:55
.NET Watch Tool
02:47
Debugging in VSCode
02:12
Working with Git
01:05
Use Cases
05:20
Social Talk
00:15
Downloading the Source Code
00:14
Asking Questions
00:33

Building APIs Using ASP.NET Core

14 lectures
Introduction
00:58
Implementation Options
01:59
Building the Domain Model
04:59
Adding Entity Framework Core
04:39
Creating a DbContext
04:14
Using Configuration
04:06
Creating the Database
08:30
Applying Constraints
05:28
Seeding the Database
07:16
Building an API
03:51
Common Runtime Errors
02:44
API Resources
03:32
Using AutoMapper
06:08
Challenge 2
00:00

Building Forms with Angular and Bootstrap

13 lectures
Introduction
00:47
Adding a New Angular Component
04:13
Creating a Route
01:42
Using Bootstrap Forms
03:49
Creating a Service
03:10
Populating Drop-down Lists
03:30
Implementing Cascading Drop-down Lists
07:25
Rendering Dynamic Check Boxes
04:42
Refactoring: Merging Services
06:04
Discussion: Merging Controllers
03:46
Adding Radio Buttons
02:51
Adding Text Boxes
02:12
Challenge 3
00:00

Implementing CRUD Operations

16 lectures
Introduction
00:34
Revisiting the Domain Model
01:31
Extending the Domain Model
03:15
Dealing with Many-to-many Relationships
06:08
Building an API to Create Objects
02:55
API Resources vs Domain Classes
06:00
Creating an API Resource
02:12
Mapping API Resources to Domain Classes
05:14
Adding a Record to the Database
05:26
Implementing Server-side Validation
09:55
Building an API to Update Objects
04:09
Mapping Collections
06:15
Refactoring: Using LINQ
05:12
Building an API to Delete Objects
02:40
Building an API to Get Objects
02:02
Challenge 4
00:00

Refactoring Towards the Clean Architecture

18 lectures
Introduction
01:00
Separating API Resources
06:03
Refactoring: Separating API Resources
06:19
Refactoring: Using KeyValuePairResource
04:37
Changing the Return Type of APIs
04:40
The Repository Pattern
02:33
Dependency Injection
05:15
Decoupling from Entity Framework
08:54
The Unit of Work Pattern
06:55
Fixing a Few Bugs
03:32
False Argument 1: Repository over Repository
03:57
False Argument 2: Increased Complexity
00:36
False Argument 3: Simple or Complex Apps
01:27
False Argument 4: Repository Coupled to Entity Framework
04:44
False Argument 5: Persistence Model
02:49
Dependency Inversion Principle
06:32
Layers vs Tiers
02:57
Challenge 5
00:00

Populating and Submitting Forms

18 lectures
Introduction
00:35
Binding the Drop-down Lists to the Model
03:51
Binding the Checkboxes
02:45
Binding the Textboxes
01:22
Submitting the Form
02:00
Client-side Validation
03:53
Displaying Toast Notifications
07:25
Global Error Handling
05:00
Zones in Angular
07:58
Logging Errors
05:41
Development vs Production Environment
03:04
Implementing Editing
05:32
Sending Parallel Requests
04:59
Creating Interfaces
06:26
Populating the Form
02:39
Implementing the Update
02:12
Implementing the Delete
02:46
Challenge
00:00

Filtering, Sorting and Pagination

19 lectures
Introduction
00:29
Code Review: Vehicles List
03:11
Adding the Filters
04:38
Filtering on the Client
03:36
Filtering on the Server
04:33
Passing the Filters to the Server
06:22
Sorting on the Server
04:32
Refactoring: Using Dictionaries
04:49
Refactoring: Extract Method
02:19
Refactoring: Using Extension Methods and Generics
07:46
Sending the Sort Parameters to the Server
02:23
Adding the Sort Icon
03:26
Rendering the Columns Dynamically
02:58
Paging on the Server
05:22
Adding a Pagination Component
02:58
Calculating the Total
05:52
Edge Cases
03:27
Challenge 7
00:00
Additional Reading
00:33

Uploading Files

15 lectures
Introduction
00:21
The Approach
03:12
Code Review
04:56
Extending the Domain Model
02:15
Building an API
10:44
Testing the API
01:26
Adding Validation
03:04
Refactoring to Use Configuration
05:33
Building the Client-side
06:40
Rendering the Uploaded Photos
04:47
Tracking the Upload Progress
07:32
Adding a Bootstrap Progress Bar
04:47
Fixing the Memory Leaks
07:48
Handling the Errors
03:10
Challenge 8
00:00

Authentication and Authorization

24 lectures
Introduction
00:57
Requirements
00:57
Architecture
04:55
Setting Up an Auth0 Account
02:20
Securing APIs
04:37
Inspecting a JSON Web Token (JWT)
00:48
Securing Client Apps
07:29
Login and Logout
06:40
Using Hosted Login Pages
04:30
Setting the Audience for the Token
08:09
Exercise
00:43
Getting the User's Profile
05:29
Clarifying the Scope
00:37
Adding Additional Signup Fields
04:44
Using Rules
03:32
Assigning Users to Roles
02:18
Returning Custom Claims
02:52
Showing/Hiding Content Based on the User's Role
06:57
Refactoring
06:12
Protecting Routes
06:47
Calling Secured APIs
05:40
Restricting API Access to Certain Roles
03:34
Implementing the Authorization Requirements
02:28
CSRF Attacks
01:10

Final Improvements

7 lectures
Adding Charts
04:37
Optimizing Queries
03:56
Fixing a Bug
01:59
Extracting a Service Layer
12:28
Supporting Multiple Storages
06:41
Using the Secret Manager
08:17
Coupon to My Other Courses
00:20

Đánh giá của học viên

Chưa có đánh giá
Course Rating
5
0%
4
0%
3
0%
2
0%
1
0%

Bình luận khách hàng

Viết Bình Luận

Bạn đánh giá khoá học này thế nào?

image

Đăng ký get khoá học Udemy - Unica - Gitiho giá chỉ 50k!

Get khoá học giá rẻ ngay trước khi bị fix.