Build a Real-world App with ASP.NET Core and Angular 2 (4+)

Build a Real-world App with ASP.NET Core and Angular 2 (4+)
Build a Real-world App with ASP.NET Core and Angular 2 (4+)

English | MP4 | AVC 1280×720 | AAC 48KHz 2ch | 10 Hours | 1.49 MB
eLearning | Skill level: All Levels


Build a full-stack web app with ASP.NET Core, Entity Framework Core and Angular 2 (Angular 4+)

[UPDATE, June 3]: Added a new section to the course: Implementing Authentication and Authorization.

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…
+ Table of Contents

1 – Introduction
2 – The Scope
3 – Prerequisites
4 – Application Requirements
5 – Setting Up the Development Environment
6 – Installing SQL Server on macOS Linux
7 – Creating a New Project
8 – Project Structure
9 – Application Startup
10 – Environments
11 – .NET Watch Tool
12 – Debugging in VSCode
13 – Working with Git
14 – Use Cases
15 – Introduction
16 – Implementation Options
17 – Building the Domain Model
18 – Adding Entity Framework Core
19 – Creating a DbContext
20 – Using Configuration
21 – Creating the Database
22 – Applying Constraints
23 – Seeding the Database
24 – Building an API
25 – Common Runtime Errors
26 – API Resources
27 – Using AutoMapper
28 – Introduction
29 – Adding a New Angular Component
30 – Creating a Route
31 – Using Bootstrap Forms
32 – Creating a Service
33 – Populating Drop-down Lists
34 – Implementing Cascading Drop-down Lists
35 – Rendering Dynamic Check Boxes
36 – Refactoring Merging Services
37 – Discussion Merging Controllers
38 – Adding Radio Buttons
39 – Adding Text Boxes
40 – Introduction
41 – Revisiting the Domain Model
42 – Extending the Domain Model
43 – Dealing with Many-to-many Relationships
44 – Building an API to Create Objects
45 – API Resources vs Domain Classes
46 – Creating an API Resource
47 – Mapping API Resources to Domain Classes
48 – Adding a Record to the Database
49 – Implementing Server-side Validation
50 – Building an API to Update Objects
51 – Mapping Collections
52 – Refactoring Using LINQ
53 – Building an API to Delete Objects
54 – Building an API to Get Objects
55 – Introduction
56 – Separating API Resources
57 – Refactoring Separating API Resources
58 – Refactoring Using KeyValuePairResource
59 – Changing the Return Type of APIs
60 – The Repository Pattern
61 – Dependency Injection
62 – Decoupling from Entity Framework
63 – The Unit of Work Pattern
64 – Fixing a Few Bugs
65 – False Argument 1 Repository over Repository
66 – False Argument 2 Increased Complexity
67 – False Argument 3 Simple or Complex Apps
68 – False Argument 4 Repository Coupled to Entity Framework
69 – False Argument 5 Persistence Model
70 – Dependency Inversion Principle
71 – Layers vs Tiers
72 – Introduction
73 – Binding the Drop-down Lists to the Model
74 – Binding the Checkboxes
75 – Binding the Textboxes
76 – Submitting the Form
77 – Client-side Validation
78 – Displaying Toast Notifications
79 – Global Error Handling
80 – Zones in Angular
81 – Logging Errors
82 – Development vs Production Environment
83 – Implementing Editing
84 – Sending Parallel Requests
85 – Creating Interfaces
86 – Populating the Form
87 – Implementing the Update
88 – Implementing the Delete
89 – Introduction
90 – Code Review Vehicles List
91 – Adding the Filters
92 – Filtering on the Client
93 – Filtering on the Server
94 – Passing the Filters to the Server
95 – Sorting on the Server
96 – Refactoring Using Dictionaries
97 – Refactoring Extract Method
98 – Refactoring Using Extension Methods and Generics
99 – Sending the Sort Parameters to the Server
100 – Adding the Sort Icon
101 – Rendering the Columns Dynamically
102 – Paging on the Server
103 – Adding a Pagination Component
104 – Calculating the Total
105 – Edge Cases
106 – Introduction
107 – The Approach
108 – Code Review
109 – Extending the Domain Model
110 – Building an API
111 – Testing the API
112 – Adding Validation
113 – Refactoring to Use Configuration
114 – Building the Client-side
115 – Rendering the Uploaded Photos
116 – Tracking the Upload Progress
117 – Adding a Bootstrap Progress Bar
118 – Fixing the Memory Leaks
119 – Handling the Errors
120 – Introduction
121 – Requirements
122 – Architecture
123 – Setting Up an Auth0 Account
124 – Securing APIs
125 – Inspecting a JSON Web Token (JWT)
126 – Securing Client Apps
127 – Login and Logout
128 – Using Hosted Login Pages
129 – Setting the Audience for the Token
130 – Exercise
131 – Getting the User’s Profile
132 – Adding Additional Signup Fields
133 – Using Rules
134 – Assigning Users to Roles
135 – Returning Custom Claims
136 – Showing Hiding Content Based on the User’s Role
137 – Refactoring
138 – Protecting Routes
139 – Calling Secured APIs
140 – Restricting API Access to Certain Roles
141 – Implementing the Authorization Requirements

Download from Turbobit

Download from DepositFiles