This project aims to help me learn MVC (Model-View-Controller) framework in .NET.
- TagHelpers: Explanation of TagHelpers and their usage in MVC views.
- Dummy MVC Controllers: Implementation and usage of dummy MVC controllers for testing purposes.
- Dummy Middlewares: Introduction to dummy middlewares and their role in MVC pipeline.
- Attribute Routing: Explanation and usage of attribute routing for defining routes in MVC.
- Tag Helper: Further exploration of TagHelpers and their practical applications.
- Model Binding: Understanding and implementation of model binding in MVC.
- Layout: Usage and customization of layout pages for consistent UI across views.
- View Import: Explanation and usage of view import for reusing view components.
- Exception Handling: Strategies and best practices for handling exceptions in MVC applications.
- Dummy Filter: Implementation and usage of dummy filters for request/response filtering.
- Custom Status Code: Handling and returning custom status codes in MVC applications.
- ViewComponent: Explanation and usage of view components for rendering reusable UI components.
Project_1.mp4
This project is dedicated to learning Entity Framework Core and its various features in .NET. It covers a wide range of topics including database creation, entity configuration, relationships, inheritance strategies, and dependency injection.
- Entity Framework Core: Introduction to Entity Framework Core and its role in database interaction.
- Database Creation: Setting up and configuring a database using Entity Framework Core migrations.
- Dummy Methods Testing: Writing and testing dummy methods to understand Entity Framework Core functionality.
- MsSqlServer: Exploring Entity Framework Core's support for Microsoft SQL Server and its features.
- Category Creation and Persistence: Creating and persisting categories in the database using Entity Framework Core.
- Data Annotations: Understanding and utilizing data annotations for entity validation and metadata definition.
- Fluent API Testing: Testing Entity Framework Core's Fluent API for configuring entities and relationships.
- Snake Case Naming Convention: Implementing snake_case naming convention for database entities.
- Fluent API Annotations: Using Fluent API annotations for advanced entity configuration.
- One-to-Many Relationship: Adding one-to-many relationship between entities using Fluent API.
- One-to-One Relationship: Implementing one-to-one relationship between entities using Fluent API.
- Many-to-Many Relationship: Configuring many-to-many relationship between entities using Fluent API.
- Table Per Hierarchy Inheritance: Creating table per hierarchy inheritance structure for entities.
- Table Per Type Inheritance: Implementing table per type inheritance strategy for entities.
- Category Configuration Base: Creating a base class for category configuration to remove redundancy in DbContext code.
- IEnumerable and IQueryable Testing: Understanding and testing the differences between IEnumerable and IQueryable in Entity Framework Core.
- Tracking and No Tracking: Exploring tracking and no tracking behaviors in Entity Framework Core.
- Lazy, Eager, and Explicit Loading: Testing different loading strategies for related entities.
- Dependency Injection Testing: Creating and testing a dummy ProductManager class for dependency injection.
- AddScoped, AddSingleton, and AddTransient: Understanding and testing different service lifetimes in dependency injection.
Project_3 is designed to provide users with the ability to manage multiple accounts within a system and facilitate fund transfers between accounts belonging to different users. Additionally, the project serves as an educational tool for individuals aiming to gain proficiency in software development concepts like the Repository Pattern, Mapper, and Unit of Work.
- Repository Pattern: Comprehensive exploration and implementation of the repository pattern for data access abstraction and separation of concerns.
- Generic Repository: Understanding and utilizing generic repository to provide a common interface for data access operations across different entity types.
- Mapper: Introduction to mapping techniques for transferring data between different layers of an application, improving maintainability and reducing coupling.
- Unit of Work Pattern: Implementing unit of work pattern to manage transactions and ensure data consistency across multiple repository operations.
- Creating Models: Designing and creating models to represent domain entities and define the structure of data within the application.
Project_3.mp4
This project is a simple Todo List application developed using an N-tier architecture. The application is divided into several layers, including Domain, Business, UI, DTO, Common, and Entities.
- N-tier layered architecture: Separates the application into different layers to promote modularity and scalability.
- Fluent Validation: Validates data using a fluent API for better readability and maintainability.
- Custom Extensions: Adds custom methods to existing classes to extend their functionality.
- Mapping techniques: Converts data between different layers using mappers to ensure proper data flow.
Project_4.mp4
This project focuses on implementing user authentication and authorization features, including user sign-up, sign-in, and preventing unauthorized access. Additionally, it explores the concept of admin roles and permissions.
- What is ASP.NET Core Identity and how to use it?
- Sign up, sign in, and sign out operations for users.
- Add role remove roles for admins.
- Add user remove user for admins.
Project_5.mp4
This project is not finished.
This project include dummy web api with jwt. Testing on swagger and postman.
- How to create web api for asp net core.
- CORS & SOP
- How to use JWT in api.
This project include CQRS design on api.
This project include 2 project. Backend,and front project. Auth with jwt. Sign-in, login, add, remove and list products and categories. With api. Front end using mvc design.