Build an app with ASPNET Core and Angular from scratch
You’ll start by setting up the development environment, including Visual Studio Code and the .NET CLI.
The course dives into building the backend API with ASP.NET Core, covering essential concepts like entities, Entity Framework, database migrations, and asynchronous code.
You’ll learn to create API controllers, handle HTTP requests, and integrate source control using Git.
Moving to the frontend, you’ll build an Angular application, fetching data from the API and displaying it in the browser.
The course covers Angular fundamentals, including components, services, observables, and routing.
You’ll also learn to enhance the UI with Bootstrap and Font Awesome.
Authentication is a crucial aspect covered in-depth, including safe password storage, JSON Web Tokens (JWT), and authentication middleware.
You’ll build login and register functionality on both the client and server sides.
As you progress, you’ll explore advanced topics like reactive forms, client-side validation, paging, sorting, filtering, and error handling.
The course also covers photo upload functionality using Cloudinary, a cloud-based image management service.
The messaging feature introduces you to SignalR, a real-time communication library, enabling you to build a chat application with real-time updates.
You’ll also learn about identity and role management, allowing you to implement user roles and authorization policies.
Towards the end, the course covers performance optimization techniques, including the Unit of Work pattern and query optimization.
Finally, you’ll learn how to publish your application to various hosting platforms like Fly.io and Heroku, including containerization with Docker.
The course keeps up with the latest versions of the technologies, providing updates for .NET 6/7, Angular 12/14, and Bootstrap 5.
Build a Real-world App with ASP.NET Core and Angular 2 (4+)
The course starts by setting up the development environment, including installing SQL Server and creating a new ASP.NET Core project.
You’ll learn about the project structure, application startup, and working with Git for version control.
Next, you’ll dive into building APIs using ASP.NET Core.
You’ll create a domain model, add Entity Framework Core for database access, and learn how to seed the database.
The course covers building APIs, handling runtime errors, and using AutoMapper for object mapping.
Once the API is in place, you’ll move to the front-end and learn how to build forms with Angular and Bootstrap.
You’ll create Angular components, routes, and services, and work with various form elements like drop-down lists, checkboxes, radio buttons, and text boxes.
The course then focuses on implementing CRUD (Create, Read, Update, Delete) operations.
You’ll extend the domain model, deal with many-to-many relationships, and build APIs for creating, updating, deleting, and retrieving objects.
You’ll also learn about server-side validation and mapping API resources to domain classes.
To improve the code structure, the course covers refactoring towards the Clean Architecture.
You’ll separate API resources, decouple from Entity Framework, and implement the Repository and Unit of Work patterns.
The course also discusses the Dependency Inversion Principle and the differences between layers and tiers.
With the foundation in place, you’ll learn how to populate and submit forms in Angular.
You’ll bind form elements to the model, implement client-side validation, display notifications, handle errors, and implement editing, deleting, and parallel requests.
The course then covers filtering, sorting, and pagination on both the client and server sides.
You’ll learn how to pass filter and sort parameters to the server, render columns dynamically, and implement paging with a pagination component.
File uploading is also covered, where you’ll extend the domain model, build APIs for uploading files, and implement file upload on the client-side with progress tracking and error handling.
Authentication and authorization are crucial aspects of any real-world application, and the course covers setting up an Auth0 account, securing APIs and client apps, implementing login and logout, handling user profiles and roles, and restricting access based on roles.
Finally, the course includes additional improvements like adding charts, optimizing queries, fixing bugs, extracting a service layer, supporting multiple storages, and using the Secret Manager.
Throughout the course, you’ll work with modern technologies like ASP.NET Core, Entity Framework Core, Angular, Bootstrap, and Auth0.
The hands-on approach ensures you gain practical experience in building real-world applications from start to finish.
Build ASP.NET Core Web API - Scratch To Finish (.NET8 API)
This course provides a comprehensive guide to building ASP.NET Core Web APIs from scratch using .NET 8.
You’ll start by setting up your development environment, including installing Visual Studio 2022, .NET SDK, and SQL Server Management Studio.
The course begins by introducing you to the fundamentals of ASP.NET Core Web APIs, REST principles, and HTTP verbs.
You’ll learn how to create a new Web API project, understand its file structure, and run it locally.
Next, you’ll dive into domain modeling and create domain models using Entity Framework Core.
You’ll learn how to set up a database context, configure the connection string, and run EF Core migrations to create the database.
With the foundation in place, you’ll create your first controller and implement CRUD operations for regions.
You’ll explore Data Transfer Objects (DTOs) and use AutoMapper to map between domain models and DTOs.
The course then covers asynchronous programming and the repository pattern, teaching you how to implement these concepts in your Web API.
Moving forward, you’ll build functionality for managing walks, including creating, reading, updating, and deleting walks.
You’ll also learn about seeding data and handling navigation properties in Entity Framework Core.
Model validations are covered in detail, including built-in validations, custom validations, and using Fluent Validations for more complex scenarios.
The course then dives into filtering, sorting, and pagination, enabling you to build robust APIs that can handle large datasets efficiently.
Security is a crucial aspect of Web APIs, and you’ll learn how to secure your API using authentication and authorization with JWT tokens.
You’ll implement role-based authorization and secure your Swagger documentation.
Image upload functionality is also covered, allowing you to upload images to a local file storage and serve them through the API.
Advanced topics like logging, global exception handling, and versioning are explored, equipping you with the skills to build production-ready APIs.
Finally, you’ll learn how to consume your Web API from an ASP.NET MVC application, covering GET, POST, PUT, and DELETE operations.
The course concludes with a section on deploying your Web API to Azure.
Throughout the course, you’ll work with real-world examples and build a complete Web API project from scratch, solidifying your understanding of ASP.NET Core Web APIs and .NET 8.
Asp.Net Core 8 (.NET 8) | True Ultimate Guide
The course starts by introducing you to ASP.NET Core and its evolution from WebForms and MVC.
You’ll learn about the new features in .NET 8 and set up your development environment.
Next, you’ll dive into the fundamentals of HTTP, understanding responses, status codes, headers, and working with tools like Postman.
The course covers middleware in-depth, teaching you how to create custom middleware classes and extensions.
Routing is a crucial aspect, and you’ll learn about route parameters, constraints, and endpoint selection order.
The course then moves on to controllers and the different types of action results, like JsonResult and RedirectResult.
Model binding and validations are covered extensively, including form data handling, custom validations, and model binders.
You’ll also learn about Razor views, layout views, partial views, and view components, which are essential for building user interfaces.
Dependency injection is a core concept in ASP.NET Core, and the course teaches you about services, scopes, and best practices.
You’ll explore environments, configuration, and the options pattern for managing settings.
A significant portion of the course is dedicated to building a Contacts Manager application using xUnit for unit testing.
You’ll learn test-driven development, mocking with Moq, and the repository pattern.
The application covers CRUD operations, tag helpers, and integrating with Entity Framework Core.
The course also covers advanced topics like logging with Serilog, filters, error handling, SOLID principles, and clean architecture.
You’ll learn about identity, authorization, and security, including JWT authentication for Web APIs.
Additionally, you’ll work with Swagger/OpenAPI for documenting APIs, Angular for building client-side applications, and CORS configuration.
The course even introduces you to the new Minimal API feature in ASP.NET Core 8.
Throughout the course, you’ll work with modern C# features like extension methods, lambda expressions, LINQ, and nullable reference types.
The instructor provides cheat sheets and source code to reinforce your learning.
Rest Api’s in Asp.Net Core and C# 2024 Edition
The course starts by setting up the development environment, guiding you through installing essential tools like Visual Studio and Postman.
You’ll then understand the fundamentals of RESTful APIs, including what an API is, HTTP verbs, and how to create a basic REST API project in ASP.NET Core.
From there, you’ll learn to create models, controllers, and handle CRUD operations (Create, Read, Update, Delete) using ASP.NET Core.
This hands-on approach ensures you grasp the core concepts of building REST APIs.
The course dives deep into integrating your API with a Microsoft SQL database using Entity Framework Core.
You’ll explore code-first and database-first approaches, configure NuGet packages, work with DbContext, connection strings, and handle database operations like migrations and seeding data.
Error handling and HTTP status codes are crucial aspects covered in detail, ensuring you can build robust and reliable APIs.
You’ll also learn about asynchronous programming and why it’s essential for efficient API development.
As you progress, you’ll implement advanced features like content negotiation, file uploading with Azure Blob Storage, validations, and routing.
These real-world scenarios will prepare you for building production-ready APIs.
The course culminates with a comprehensive project where you’ll build a REST API for managing artists, albums, and songs.
You’ll implement pagination, search functionality, and explore deployment options like Microsoft Azure, IIS, and even integrate with PostgreSQL databases.
Throughout the course, you’ll work with modern tools and technologies like Visual Studio, Postman, NuGet packages, and Azure services.
The instructor’s clear explanations and hands-on approach ensure you gain practical experience and confidence in building REST APIs with ASP.NET Core and C#.
Asp.Net Core : The Complete Guide To Build RESTful Api’s
This course provides a comprehensive guide to building RESTful APIs using Asp.Net Core and Entity Framework.
You’ll start by learning the fundamentals of APIs, HTTP verbs, and the MVC architecture.
The course then dives into creating your first RESTful API, covering CRUD operations (Create, Read, Update, Delete) and working with data models.
You’ll integrate with an MS SQL database using Entity Framework Core, implementing code-first migrations and handling database operations.
As you progress, you’ll learn essential concepts like error handling, status codes, content negotiation, model validation, and routing.
The course covers implementing sorting, paging, and searching functionalities to enhance your APIs.
You’ll also explore caching techniques to improve performance and learn about authentication and authorization using Microsoft Identity and JSON Web Tokens (JWT).
The course guides you through deploying your APIs to Microsoft Azure and third-party hosting providers.
To solidify your learning, you’ll build a real-world project: a Coffee Shop REST API.
This hands-on experience will help you understand the relationships between entities and implement various controllers and methods.
Throughout the course, you’ll work with modern tools like Visual Studio, SQL Server, and Azure, ensuring you’re prepared for real-world development scenarios.
By the end, you’ll have the skills to build robust, secure, and scalable RESTful APIs using Asp.Net Core and Entity Framework.
Complete ASP.NET Core and Entity Framework Development
This course starts by helping you set up your development environment, including installing Visual Studio and creating a GitHub account for version control.
You’ll learn how to create an ASP.NET Core web application project and understand its structure.
The course covers database setup using Entity Framework Core, including creating tables and handling migrations.
It also teaches you how to fix common database connection errors.
One of the key modules is Leave Type Management, where you’ll learn to set up controllers, actions, and views using scaffolding.
You’ll explore view models, AutoMapper, and implement CRUD (Create, Read, Update, Delete) functionality with secure delete confirmation prompts.
The course also covers data tables and integrating Font Awesome icons.
The repository pattern is introduced, teaching you how to set up an asynchronous database repository and dependency injection.
This helps separate concerns and improves code organization.
User authentication and authorization are covered using Identity Core.
You’ll learn to customize the registration process, seed default roles and admin users, assign roles during registration, and control user access based on roles.
The course delves into the Employee Leave Allocation module, where you’ll perform database updates, set up index and edit views, and implement leave allocation functionality.
You’ll also learn to list employees and view their leave allocations.
The Employee Leave Requests module teaches you how to handle employee leave applications, including setting up views for employees and administrators.
You’ll learn to review leave requests as an admin and fix common issues that may arise.
The course also covers value-added enhancements, such as general code cleanup, implementing email services, automating auditing on database records, logging and exception handling, and separating concerns using admin layouts.
Finally, you’ll learn how to publish your application to production environments like IIS, SQL Server, Azure App Service, and Azure SQL.
Throughout the course, you’ll be using GitHub for version control, ensuring you can track changes and collaborate effectively.
Dependency Injection in .NET 8 and ASP.NET Core 8
The course starts by introducing the concept of Dependency Injection and demonstrating how it reduces coupling in C#.
You’ll learn about container classes like ServiceCollection and ServiceProvider, and how to use them to register types.
The course covers different ways of injecting types in .NET, including AddScoped vs. AddTransient.
You’ll work on a hands-on project called “The Personal Blog” to practice creating and injecting types, viewing posts, and injecting dependencies into ASP.NET Core MVC views.
You’ll also learn how to use Dependency Injection with attributes and action filters, as well as logging with ILogger in ASP.NET Core.
The course dives into more advanced topics like resolving dependencies conditionally, adding and resolving types with keys (in .NET 8 and above), and using Dependency Injection in WPF Core applications.
Interestingly, the course covers plugging in third-party IoC containers like AutoFac into .NET, and how to check if a service is registered (in .NET 6 and above).
It also includes interview questions related to Dependency Injection, which could be helpful for job preparation.
Programming in Blazor - ASP.NET Core 5
The course covers a wide range of topics related to Blazor, a modern web UI framework that allows you to build interactive web applications using C# and .NET.
You’ll start by learning the fundamentals of Blazor, including the differences between Blazor WebAssembly and Blazor Server-Side, and where you can use Blazor.
The course will guide you through setting up the development environment and introduce you to Razor, the syntax for building Blazor components.
From there, you’ll dive into the core concepts of Blazor components, including parameters, events, data binding, and life cycle methods.
You’ll also learn about dependency injection, services, layouts, and how to interact with JavaScript and CSS.
The course covers essential topics like routing, forms, and validations.
You’ll build components for various form elements, including input fields, selectors, and typeahead (autocomplete).
Additionally, you’ll learn how to reorder elements in a list and build a movie filtering component.
One of the key aspects of the course is communicating with the back-end using HTTP and Entity Framework Core.
You’ll create a database, work with genres, people, and movies, and even learn how to save images in Azure Storage or locally.
Security is a crucial aspect of web development, and the course dedicates a module to it.
You’ll explore the authentication state provider, learn about AuthorizeView and Authorize components, configure Identity in ASP.NET Core, and build components for registration, login, and logout.
The course also covers roles, JWT (JSON Web Tokens), background tasks, and automatic logout for inactive users.
Deployment is another important topic covered in the course.
You’ll learn how to deploy your Blazor applications to Azure App Service, Azure Storage, and IIS (Internet Information Services).
The course also covers continuous delivery with Azure DevOps.
Sharing code and creating Razor Class Libraries is another valuable skill you’ll acquire.
You’ll learn how to create shared components, access CSS and JavaScript files, and work with routable components and cascading parameters.
The course also explores Blazor Server and dual-architecture applications, allowing you to leverage the benefits of both Blazor WebAssembly and Blazor Server-Side.
Finally, you’ll learn about internationalization, including multi-language support, handling culture-dependent data like dates and numbers, and managing error messages in different languages.
ASP.NET Core - SOLID and Clean Architecture
This course guides you through the entire process of building a complete application using clean architecture principles and best practices.
You’ll start by reviewing the fundamental SOLID principles that form the foundation of good software design.
This includes concepts like the Single Responsibility Principle, the DRY (Don’t Repeat Yourself) principle, and Dependency Inversion.
With a solid grasp of these principles, you’ll be better equipped to write maintainable and extensible code.
The course then dives into the heart of clean architecture, explaining the rationale behind this approach and how it promotes separation of concerns and testability.
You’ll learn how to set up a solution structure that follows clean architecture principles, with separate projects for the application core, infrastructure, and presentation layers.
One of the key aspects covered is the implementation of CQRS (Command Query Responsibility Segregation) and the Mediator pattern, along with the use of AutoMapper for object-to-object mapping.
These patterns and tools will help you write more organized and decoupled code.
As you progress, you’ll build out the various components of the application, including the domain model, repositories, and API controllers.
The course covers the use of Entity Framework Core for data access, as well as third-party services like email and logging.
Importantly, the course emphasizes testing, with sections dedicated to unit testing the application code and integration testing with Entity Framework.
This will ensure that your application is robust and maintainable in the long run.
The course then shifts focus to the user interface, guiding you through the creation of a Blazor WebAssembly application and the consumption of the API using NSwag and NSwagStudio.
You’ll also learn how to secure the API and UI using Identity and JSON Web Tokens (JWT) for authentication.
With the core features in place, the course dives into implementing complete application features like leave allocation management, leave request management (from both employee and admin perspectives), request approval, and cancellation.
Finally, the course covers value-added features like third-party logging with Serilog, improved data auditing, and notifications.
These additional features will help you build a more robust and production-ready application.