Comment on page
Roadmap for .NET developers
Mukhammadkarim Tukhtaboev
- Who is author?
- About course
- About programming and programming languages
- What is .NET?
- History of .NET
- Versions of .NET
- Why .NET?
- Major components of .NET
- Installing .NET
- Hello World in 5 minutes and .NET CLI
- Installing IDE (Visual Studio, Rider)
- Introducing project/solution structure
- Print data to console
- Date types and variables
- Input data to console
- String interpolation
- If/else operator
- Switch/case operator
- Goto operator
- Loops, break and continue
- Math functions
- Comments
- Methods and params
- Arrays
- Casting types
- Boxing and unboxing
- Managed code and unmanaged code
- Introduction to OOP (vs functional programing)
- Major components of OOP
- Classes and objects
- Constructor and Destructor
- Property and fields
- Incapsulation
- Inheritance and this/base keywords
- Polimorphism
- Abstraction
- Enum and struct
- Value type and reference type
- Ref and out
- String arguments in Main function
- Static, sealed, abstract classes
- String and StringBuilder
- Exception Handling
- Collections: IEnumerable, ICollection, IReadonlyList
- Collections: List, Stack, Queue, LinkedList, Dictionary, HashSet, ArrayList
- KeyValuePair, Tuple and ValueTuple
- Delegates
- Events
- Extension methods
- Stream I/O (StreamWriter, StreamReader)
- Stream I/O 2 (FileStream, MemoryStream)
- Using statement
- File and directories
- Multithreading
- Asynchronoues programming
- Reflection and attributes
- HttpClient and HTTP methods
- Introduction to LINQ
- 1.What is LINQ and why is it important?
- 2.Benefits of using LINQ for data querying.
- LINQ query syntax
- 1.Basic LINQ query structure.
- 2.Using
from
,where
,select
,orderby
, andgroupby
clauses. - 3.Filtering data using
where
clause.
- Projection and transformation
- 1.Projecting data using
select
clause. - 2.Working with anonymous types in projections.
- 3.Transforming data into different shapes.
- Sorting and grouping
- 1.Sorting data using the
orderby
clause. - 2.Grouping data using the
groupby
clause. - 3.Aggregating data within groups.
- Aggregation and aggregation methods
- 1.Understanding aggregation functions like
Sum
,Average
,Min
, andMax
. - 2.Using aggregation methods with LINQ queries.
- 3.Applying aggregations on grouped data.
- Additional data manipulation methods
- 1.Using methods like
All
,Any
,Contains
,Distinct
,Except
,Intersect
,Union
. - 2.Applying these methods in LINQ queries for specific scenarios.
- Paging and filtering methods
- 1.Using methods like
Take
,TakeWhile
,Skip
,SkipWhile
. - 2.Applying paging and filtering techniques to query subsets of data.
- Joining data
- 1.Using the
Join
method to combine data from multiple sources. - 2.Understanding different types of joins.
- Accessing specific elements
- 1.Using methods like
ElementAt
,FirstOrDefault
,Last
,LastOrDefault
,Single
,SingleOrDefault
. - 2.Retrieving specific elements from a sequence.
- LINQ method syntax
- 1.Introduction to LINQ method chaining.
- 2.Using methods like
Where
,Select
,OrderBy
,GroupBy
. - 3.Utilizing aggregation and other data manipulation methods.
- LINQ to objects
- 1.Querying in-memory collections using LINQ.
- 2.Performing various data manipulations using LINQ.
- 3.Practicing LINQ with arrays, lists, dictionaries, etc.
- LINQ to XML and JSON
- 1.Querying XML and JSON data using LINQ.
- 2.Loading and transforming XML/JSON data with LINQ queries.
- Advanced LINQ concepts
- 1.Understanding expression trees in LINQ.
- 2.Writing custom LINQ extension methods.
- 3.Utilizing LINQ for functional-style programming.
- Introduction to Version Control
- Setting up git and github
- Basic git commands
- Working with branches
- Remote repositories and Github
- Collaborative development with Pull Requests
- Resolving conflicts
- Advanced git commands
- Git Worklofw strategies
- Git hooks and customization
- What is MS SQL Server?
- Difference editions of SQL Server: Express, Standart, Enterprise
- Installing and setting up MS SQL Server
- Introduction to SQL
- Creating database and tables
- Data types in SQL
- Basic SQL queries: SELECT, INSERT, UPDATE, DELETE
- SELECT statement: Filtering and sorting data
- Working with NULL values
- Aggregation and grouping
- Joins
- Transactions
- Stored Procedure
- Understanding indexes, Clustered, non-clustered and filtered indexes
- Performance tuing: Identifying and improving slow queries
- Working with Views
- Working with Triggers
- Constraints
- Primary and foreign keys
- JSON support in SQL Server
- Backup, Restore and Security
- Users, roles and permissions
- Introduction to ORMs
- Dapper
- 1.Introduction to Dapper
- 2.Basic CRUD operations
- 3.Mapping Data to Objects
- 4.Handling Transactions and Stored Procedure
- 5.Asynchronous Data Access
- 6.Advanced Features and Performance
- Entity Framework Core
- 1.Introduction to Entity Framework Core
- 2.Setting up data context and entities
- 3.Basic CRUD operations with EF Core
- 4.Querying data with LINQ and Projections
- 5.Relationships and navigation properties
- 6.Working with Migrations
- 7.Seeding data and data annotations
- 8.Advanced querying and filtering
- 9.Working with transactions
- 10.Performance optimization and caching
- 11.Code First and Database First approaches
- Basic of web development, client-server architecture (HTTP, HTTPS)
- Setting up an ASP.NET Core project
- Building endpoints and handling requests
- Returning data from APIs
- Handling errors and status codes
- Versioning and documentation
- Working with Postman
- Content negotition and serialization
- Middlewares
- Dependency injection
- Introduction to authentication and authorization
- Implement token based authentication using JWT
- Role-based authorization and policies
- REST API development and resource naming
- REST vs GraphQL vs gRPC vs SOAP
- Logging
- Introduction to caching
- In-memory caching
- Distributed caching
- Introduction to design principles
- SOLID: Single Responsibility Principle
- SOLID: Open Closed Principle
- SOLID: Liskov Subsitition Principle
- SOLID: Interface Segregation Principle
- SOLID: Dependency Inversion Principle
- DRY, KISS, YAGNI principles
- Introduction to Software architecture
- N-Tier Architecture
- Unit of Work and Generic Repository Patterns
- Implementing N-tier architecture
- Introduction to Unit Testing
- Testing basics and testing frameworks
- Anatomy of a Unit Test
- Unit Testing REST APIs
- Testing Data Access Layer
- Parameterized tests and test data
- Test doubles and Mocking
- Test suites and test organization
- Test coverage and code analysis
- Advanced testing techniques
- Publishing ASP.NET Core applications
- Introduction to Deployment and CI/CD
- Setting up windows server for deployment
- Introduction to github actions
- Building and testing with github actions
- Deploying to windows server with github actions
- Handling environment-specific configurations
- Automanted versioning and release management
- Deployment strategies and rollbacks
- Docker and containerization in deployment
- Monitoring and alerts
- Integration testing and quality checks
- Introduction to advanced .NET technologies
- RabbitMQ and Messaging
- 1.Introduction to messaging and RabbitMQ
- 2.RabbitMQ architecture and components
- 3.Publish-subscribe model with RabbitMQ
- 4.Direct messaging and Rrouting
- 5.Topics and routing patterns
- 6.Request-reply communication
- 7.Message Acknowledgment and delivery guarantees
- 8.Dead letter exchanges and message handling
- 9.Message Serialization and best practices
- 10.Managing RabbitMQ instances
- 11.Monitoring and troubleshooting
- 12.Real-world use cases and examples
- Microservices Architecture
- 1.Introduction to Microservices architecture
- 2.Design principles for microservices
- 3.Decomposing monolitcs into microservices
- 4.Service communication and API gateways
- 5.Service discovery and load balancing
- 6.Data management in microservices
- 7.Event-Driven microservices
- 8.Microservices security and authentication
- 9.Testing and deployment strategies
- 10.Monitoring and observability
- 11.Scaling microservices
- 12.Real-world use cases and case studies
- Clean Architecture
- 1.Introduction to Clean Architecture
- 2.Implementing the presentation layer
- 3.Application services and use cases
- 4.The Domain Layer and Domain entities
- 5.Repository pattern and data persistence
- 6.Dependency injection and infrastructure
- 7.Decoupling with interfaces and Adapters
- 8.Handling cross-cutting concerns
- 9.Testing in Clean Architecture
- 10.Achieving separation of concerns
- 11.Real-world applications and case studies
- Docker and Containerization
- 1.Introduction to Docker and Containers
- 2.Docker fundamentals and concepts
- 3.Containerizing ASP.NET Core applications
- 4.Managing application dependencies
- 5.Configuration and environment variables
- 6.Networking and communication
- 7.Persistent Storage and data volumes
- 8.Docker compose for multi-container applications
- 9.Orchestration with Kubernetes
- 10.Docker and CI/CD
- 11.Security and best practices
- 12.Debugging and troubleshooting
- 13.Real-world use cases and case studies
- Event Sourcing and CQRS
- 1.Introduction to Event Sourcing and CQRS
- 2.Event Sourcing fundamentals
- 3.Implementing Event Sourcing in ASP.NET Core
- 4.CQRS overview
- 5.Implementing CQRS in ASP.NET Core
- 6.Building the write side of CQRS
- 7.Building the read side of CQRS
- 8.Event store and data storage
- 9.Scaling and eventual consistency
- 10.Applying Event Sourcing and CQRS in real-world scenarios
- 11.Pitfalls, challenges and best practices
- 12.Event sourcing and CQRS with Advanced technologies
- GraphQL and API Design
- 1.Introduction to GraphQL and Hot Chocolate
- 2.Defining GraphQL Schemas and Types
- 3.Building queries and resolvers
- 4.Mutations and Data modification
- 5.Fragments and reusability
- 6.Filtering and pagination
- 7.Authentication and authorization
- 8.Real-time communitcation with subscriptions
- 9.Error handling and resilience
- 10.Introspection and scheme stitching
- Real-time communication with SignalR
- 1.Introduction to real-time communication and SignalR
- 2.SingalR fundamentals and concepts
- 3.Building real-time applications with SignalR
- 4.SignalR hubs and communications
- 5.Real-time data visualization with SignalR
- 6.Handling connection state and reconnection
- 7.Scaling SignalR applications
- 8.Authentication and authorization with SignalR
- 9.Handling offline clients and state persistence
- 10.Extending SignalR for advanced scenarios
- 11.Real-world use cases and case studies
- 12.Pitfalls, challenges and best practices
- 13.Integrating SignalR with other technologies
- Introduction to Design Patterns
- Creational Patterns
- 1.Singleton Pattern
- 2.Factory Method Pattern
- 3.Abstract Factory Pattern
- 4.Builder Pattern
- 5.Prototype Pattern
- Structural Patterns
- 1.Adapter Pattern
- 2.Bridge Pattern
- 3.Composite Pattern
- 4.Decorator Pattern
- 5.Facade Pattern
- 6.Flyweight Pattern
- 7.Proxy Pattern
- Behavioral Patterns
- 1.Chain of Responsibility Pattern
- 2.Command Pattern
- 3.Interpreter Pattern
- 4.Iterator Pattern
- 5.Mediator Pattern
- 6.Memento Pattern
- 7.Observer Pattern
- 8.State Pattern
- 9.Template Method Pattern
- 10.Visitor Pattern
- Introduction to WPF
- 1.Overview of Windows Presentation Foundation.
- 2.XAML (eXtensible Application Markup Language) basics.
- 3.Key differences between WPF and Windows Forms.
- XAML and UI layout
- 1.Understanding XAML syntax and structure.
- 2.Creating UI layouts with panels (StackPanel, Grid, DockPanel).
- 3.Styling and theming using XAML.
- Data binding in WPF
- 1.Implementing data binding using XAML.
- 2.Two-way data binding and updates.
- 3.Data templates for visualizing data.
- WPF controls and user interface
- 1.Exploring built-in controls (TextBox, Button, ListBox, etc.).
- 2.Customizing control appearance using styles and templates.
- 3.Creating responsive and adaptive user interfaces.
- Command binding and MVVM pattern
- 1.Implementing command binding for user interactions.
- 2.Introduction to the MVVM (Model-View-ViewModel) architectural pattern.
- 3.Separation of concerns with data binding and view-models.
- Animations and visual effects
- 1.Adding animations to elements (transitions, storyboards).
- 2.Using Visual States for complex UI behaviors.
- 3.Enhancing user experience with visual effects.
- Navigation and page management
- 1.Navigating between different views or pages.
- 2.Passing data between views during navigation.
- 3.Implementing a navigation framework.
- Advanced styling and control templates
- 1.Creating custom control templates.
- 2.Styling controls using triggers and setters.
- 3.Incorporating vector graphics and icons.
- Data validation and error handling
- 1.Implementing data validation using validation rules.
- 2.Displaying validation errors to users.
- 3.Handling exceptions gracefully.
- Localization and globalization
- 1.Designing applications for internationalization.
- 2.Localizing user interface elements.
- 3.Handling different cultures and languages.
- Printing and reporting
- 1.Generating and printing reports in WPF.
- 2.Configuring print settings and page layout.
- 3.Exporting content to various formats.
- Advanced topics in WPF
- 1.Working with 3D graphics and animations.
- 2.Integrating multimedia (audio, video) into applications.
- 3.Data visualization using charts and graphs.
- Deployment and distribution
- 1.Packaging WPF applications for deployment.
- 2.Creating installer packages.
- 3.Ensuring updates and maintenance.
- Introduction to .NET MAUI
- 1.Introduction to .NET MAUI and cross-platform development.
- 2.Advantages and use cases of .NET MAUI.
- Setting up the development environment
- 1.Installing .NET MAUI workload and tools.
- 2.Creating a new .NET MAUI project.
- Introduction XAML for .NET MAUI
- 1.XAML basics: UI elements, attributes, namespaces.
- 2.Building user interfaces using XAML.
- UI components and controls
- 1.Using common controls: Button, Label, Entry, etc.
- 2.Layouts and containers: StackLayout, Grid, FlexLayout.
- Component-based development
- 1.Adding and styling toggle buttons.
- 2.Implementing checkboxes and radio buttons.
- 3.Creating and customizing switches.
- Data binding in .NET MAUI
- 1.Data binding basics using XAML.
- 2.Binding to properties in view models.
- 3.Handling data updates and synchronization.
- Navigation and routing
- 1.Implementing navigation between pages/views.
- 2.Passing parameters between pages.
- 3.Handling navigation events and patterns.
- Platform-specific customization
- 1.Leveraging platform-specific APIs and features.
- 2.Using Dependency Injection for platform-specific code.
- Styling and theming
- 1.Applying styles using XAML resources.
- 2.Theming for consistent UI across platforms.
- Handling device features
- 1.Accessing device capabilities through APIs.
- 2.Using Essentials library for common device features.
- MVVM pattern with .NET MAUI
- 1.Understanding MVVM architecture.
- 2.Binding view models to views.
- 3.Commands and view model interactions.
- Localization and globalization
- 1.Designing apps for multiple languages.
- 2.Localizing user interface elements.
- 3.Handling date, time, and number formats.
- Working with media and multimedia
- 1.Displaying images and icons.
- 2.Integrating audio and video content.
- Advanced .NET MAUI concepts
- 1.Adaptive UI for different screen sizes and orientations.
- 2.Custom controls and renderers.
- 3.Integrating third-party libraries using NuGet.
- Debugging and testing
- 1.Debugging .NET MAUI applications.
- 2.Writing unit tests for view models and logic.
- Deployment and distribution
- 1.Preparing apps for deployment.
- 2.Deploying to app stores: iOS, Android, Windows.
- Introduction to Blazor
- 1.What is Blazor and its core concepts.
- 2.Advantages of using Blazor for frontend development.
- 3.Comparison between server-side Blazor and WebAssembly Blazor.
- Setting up the development environment
- 1.Installing .NET SDK and Blazor tools.
- 2.Creating a new Blazor project.
- Blazor components and pages
- 1.Understanding Blazor components and Razor syntax.
- 2.Creating and structuring Blazor pages.
- 3.Layouts, partial views, and reusable components.
- Data binding and events
- 1.Two-way data binding using
@bind
directive. - 2.Handling user interactions with events.
- 3.Using form controls and input validation.
- Routing and navigation
- 1.Configuring routing in Blazor applications.
- 2.Navigating between different pages and views.
- 3.Passing parameters in routes.
- State management
- 1.Managing component state with
@state
. - 2.Sharing state between components.
- 3.Using Cascading Parameters.
- Forms and validation
- 1.Building forms with Blazor components.
- 2.Client-side and server-side form validation.
- 3.Displaying validation errors to users.
- Layouts and UI styling
- 1.Creating consistent layouts using shared components
- 2.Styling components with CSS and Bootstrap.
- 3.Customizing UI using themes and templates.
- Dependency injection in Blazor
- 1.Understanding DI in Blazor applications.
- 2.Registering services and injecting dependencies.
- 3.Implementing services for data access.
- Working with APIs and HTTP requests
- 1.Making HTTP requests using HttpClient.
- 2.Consuming RESTful APIs and handling responses.
- 3.Authentication and authorization with APIs.
- Client-side interactivity
- 1.Adding JavaScript interop for client-side functionality.
- 2.Incorporating third-party JavaScript libraries.
- Component lifecycle and hooks
- 1.Understanding the lifecycle of a Blazor component.
- 2.Using lifecycle methods (
OnInitialized
,OnParametersSet
, etc.). - 3.Performing actions during component lifecycle.
- WebAssembly Blazor (Experimental)
- 1.Introduction to WebAssembly Blazor.
- 2.Setting up and building WebAssembly applications.
- 3.Comparing WebAssembly and server-side Blazor.
- Testing and debugging
- 1.Writing unit tests for Blazor components and logic.
- 2.Debugging Blazor applications in the browser.
- Deployment and hosting
- 1.Publishing Blazor applications for deployment.
- 2.Hosting options (Azure, AWS, GitHub Pages, etc.).
- Advanced topics and best practices
- 1.Advanced state management with Flux/Redux patterns.
- 2.Using Blazor with Progressive Web Apps (PWAs).
- 3.Real-time communication with SignalR and Blazor.
- 4.Performance optimization and lazy loading.
- 5.Integrating Blazor with authentication providers.
- Delivering system (BARQ, Talabat)
- Producing real-world package for Nuget
- Contribution in real-world exist open-source projects
Last modified 3mo ago