Advanced C# Course Syllabus
Contact Us:
WhatsApp Number: 91 7021801173
Mobile Number: 91 7021801173
Email Id: [email protected]
Telegram: https://telegram.me/trainingcsharponline
Website: https://dotnettutorials.net/lesson/csharp-dot-net-online-training/
Registration Link: https://forms.gle/EWsiuNUGGoeFBV3f7
Duration: 4 Months
Course Fees: 10000 INR or 125 USD
Chapter 1: Introduction and Environment Setup
1. Introduction to .NET Core Framework
2. Introduction to C# Programming Language
3. .NET Core Environment Setup
4. Download and Install Visual Studio 2022
5. Download and Install .NET Core SDK
6. Download and Install SQL Server 2022
7. Download and Install SSMS
8. .NET Core vs .NET Framework Code Execution Process
9. Creating First Console Application using Visual Studio
Chapter 2: C#.NET Basics
1. Basic Structure of a C# Program
2. Methods and Properties of the Console Class in C#
3. Data Types, Variables, and Literals in C#
4. Type Casting in C#
5. Control Flow Statements: if-else, switch, while, for, do-while
6. Loop Controls: break, continue, goto
7. Functions and Methods in C# (user-defined functions, Call By Value & Call By
Reference)
8. Static vs Non-Static Members in C#
9. Command Line Arguments in C#
10. Boxing and Unboxing
11. Checked and Unchecked Keywords
12. Nullable Types in C#
13. Const and Read-Only Keywords
14. String Handling in C#
15. Properties in C#
16. Difference Between Convert.ToString and ToString()
17. Exception-Safe Coding Patterns
18. Stack and Heap Memory
19. Immutable Types in C#
20. Dynamic Memory Allocation (new)
21. Implicitly Typed Local Variables (var)
Chapter 3: Object-Oriented Programming (OOP) in C#
1. Object-Oriented Programming Principles (OOP)
2. Class and Objects in C#
3. Constructors (Types, Why Constructors, Static vs Non-Static, Private Constructors)
4. Destructors in C#
5. Garbage Collection in .NET
6. Finalize and Dispose Pattern
7. Access Specifiers in C#
8. Encapsulation, Abstraction, Inheritance (Types of Inheritance, IsA and HasA
Relationship)
9. Generalization and Specialization
10. Abstract Class and Interface
11. Multiple Inheritance (Via Interfaces)
12. Polymorphism (Method Overloading, Method Overriding, and Operator Overloading)
13. Method Hiding in C#
14. Sealed Class and Sealed Methods
15. Extension Methods in C#
16. Partial Classes and Partial Methods
17. Static Classes in C#
18. Covariance and Contravariance in C#
19. Object Initializers
20. Method Overriding vs Hiding (More emphasis)
21. Object Pooling
22. Indexers
Chapter 4: Real-Time Applications Using OOP Concepts
1. Real-time Examples of Encapsulation, Abstraction, Inheritance, Polymorphism,
Interfaces, Abstract Class
2. Real-Time Examples of Static Class and Sealed Class
3. Real-Time Examples of Partial Class and Extension Methods
Chapter 5: Exception Handling
1. Exception Handling in C#
2. Multiple Catch Blocks
3. Finally Block
4. Custom Exceptions
5. Inner Exceptions
6. throw vs throw ex
7. Best Practices for Exception Handling
8. Global Exception Handling
9. Custom Exception Hierarchy
Chapter 6: Delegates, Events, and Lambda Expressions
1. Introduction to Delegates, Events, and Lambda Expressions
2. Delegates (Multicast, Generic, and Anonymous Methods)
3. Func, Action, and Predicate Delegates (Common in functional-style C#)
4. Event Subscription/Unsubscription Best Practices
5. Event Handling in C# (with EventHandler<TEventArgs>)
6. Lambda Expressions in C#
7. Asynchronous Event Handling in C#
Chapter 7: Multithreading in C#
1. Introduction to Multithreading in C#
2. Thread Class, Thread Life Cycle, and Thread Priorities
3. Thread Synchronization: lock, Monitor, Mutex, Semaphore, SemaphoreSlim
4. AutoResetEvent and ManualResetEvent
5. Performance Testing of a Multithreaded Application
6. Thread Pool in C#
7. Foreground and Background Threads
8. Deadlock in Multithreaded Applications
9. Debugging Multithreaded Applications
10. Thread Safety Concepts
11. Thread.Join vs Thread.Sleep
12. Volatile Keyword
Chapter 8: Collections and Generics
1. Arrays (Single-Dimensional, Multidimensional)
2. Introduction to Collections (ArrayList, Stack, Queue, SortedList)
3. Generic Collections (List, Dictionary, Stack, Queue, HashSet, SortedSet)
4. Immutable Collections
5. Concurrent Collections (ConcurrentDictionary, ConcurrentQueue, ConcurrentStack,
ConcurrentBag, BlockingCollection)
6. Sorting Complex Types
7. Generics and Generic Constraints in C#
8. Comparison Delegate and Sorting
9. List vs Dictionary in C#
Chapter 9: File Handling in C#
1. Introduction to File Handling
2. FileStream Class
3. StreamReader and StreamWriter
4. BinaryWriter and BinaryReader
5. File and Directory Operations (FileInfo, DirectoryInfo)
6. StringWriter and StringReader
7. Export and Import Excel Data in C#
8. Working with JSON and XML Files
9. MemoryMappedFiles
10. Handling Large Files Efficiently (Stream handling, memory management)
11. Serialization Techniques (Binary and JSON Serialization)
Chapter 10: Asynchronous Programming
1. Introduction to Concurrency
2. Async and Await in C#
3. Task-based Asynchronous Programming (including Task Chaining)
4. Advanced Task Management (Task Factory, Task Schedulers)
5. Task Cancellation using CancellationToken
6. Exception Handling in Asynchronous Code
7. Asynchronous Streams (IAsyncEnumerable)
8. ValueTask and Synchronous Tasks
9. Asynchronous Event Patterns
10. Parallelizing Asynchronous Tasks
Chapter 11: Parallel Programming
Task Parallel Library (TPL)
Parallel For, Parallel Foreach, Parallel Invoke
Maximum Degree of Parallelism
Thread Synchronization (Interlocked vs lock)
Cooperative Cancellation Patterns
Data Partitioning Strategies
Chapter 12: AutoMapper in C#
1. Introduction to AutoMapper
2. Complex Mappings with AutoMapper
3. Mapping Complex Types to Primitive Types
4. Reverse and Conditional Mappings
5. Ignore Method in AutoMapper
6. Custom Resolvers in AutoMapper
7. Nested Object Mappings
8. Mapping Collections and Lists
Chapter 13: Optional Parameters, Indexers, and Enums
Optional Parameters in C#
Indexers in C# with Real-Time Examples
Enum Types and Real-Time Usage
Pattern Matching with Enums
Chapter 14: Var, Dynamic, and Reflection
Reflection in C# (Overview and Use Cases)
Dynamic Types in C#
var vs dynamic in C#
Dynamic vs Reflection
Reflection.Emit for Dynamic Code Generation
Loading Assemblies at Runtime
Anonymous Types
Late Binding with dynamic
Chapter 15: ADO.NET Core
Introduction to ADO.NET Core
Using ADO.NET with SQL Server
SqlConnection, SqlCommand, SqlDataReader and SqlDataAdapter
Using Stored Procedures with ADO.NET
DataTable and DataSet
Handling Multiple Result Sets
Parameterized Queries
ADO.NET Core Architecture
Transactions in ADO.NET (Implicit vs Explicit, Isolation Levels)
ADO.NET Core Transaction Isolation Level
ADO.NET Core Distributed Transactions
Bulk Operations in ADO.NET (SqlBulkCopy)
Pagination and Stored Procedures
Connected vs Disconnected Architecture in ADO.NET
Chapter 16: Expression Trees and Dynamic Programming
Introduction to Expression Trees in C#
Building and Compiling Expression Trees at Runtime
Real-Time Use Cases of Expression Trees
Building Custom Expression Trees
Dynamic Object Creation at Runtime
Chapter 17: Advanced Memory Management
Unsafe Code and Pointers in C#
Span<T> and Memory<T> for Efficient Memory Management
Working with Native Memory (Marshal and IntPtr)
Garbage Collection Tuning and Low Latency GC
Memory Profiling and Debugging Techniques
Memory Profiling Tools (Practical tools like dotMemory, Visual Studio Profiler)
Garbage Collection Events (GC Notifications)
Chapter 18: Reflection and Metadata Programming
Introduction to Reflection in C#
Accessing Metadata and Custom Attributes
Reflection.Emit for Dynamic Code Generation
Loading and Executing Assemblies at Runtime
Reflection Caching for Performance Optimization
Chapter 19: Language Integrated Query (LINQ) and Parallel LINQ (PLINQ)
Introduction and Architecture
Architecture of LINQ
Different Ways to Write LINQ Queries
IEnumerable vs IQueryable in C#
LINQ Execution: Deferred vs Immediate Execution
LINQ Basics and Operators
LINQ Extension Methods
Core LINQ Operators: Select, SelectMany, Where, OfType
Set Operators: Distinct, Except, Intersect, Union, Concat
Aggregation Operators: Sum, Max, Min, Average, Count, Aggregate
LINQ Sorting and Grouping
Ordering Operators: OrderBy, OrderByDescending, ThenBy, ThenByDescending,
Reverse
Grouping Operators: GroupBy, ToLookup, GroupBy with Multiple Keys
LINQ Joins and Element Operations
Join Operators: Inner Join, Group Join, Left Join, Cross Join
Element Operators: ElementAt, First, Last, Single, DefaultIfEmpty
Sequence Comparison: SequenceEqual
LINQ Partitioning and Paging
Partitioning Operators: Take, TakeWhile, Skip, SkipWhile
Paging using Skip and Take
LINQ Conversion Methods
Conversion Methods: ToList, ToArray, ToDictionary
Cast and OfType Operators: Differences and Use Cases
Advanced LINQ and Optimization
LINQ with Entity Framework Core
Expression Trees in LINQ
LINQ Query Optimization Techniques
Performance Tuning in LINQ
Custom LINQ Providers
LINQ Query Execution Plans
Introduction to Parallel LINQ (PLINQ)
Introduction to PLINQ and Parallel Computing
Basic PLINQ Operations: Parallel Queries and Custom Operators
Partitioning Strategies for Data Parallelism
Advanced PLINQ and Real-World Applications
Asynchronous Programming with PLINQ
PLINQ in Large-Scale Data Processing
PLINQ in Distributed Computing
Combining PLINQ with Asynchronous Operations
PLINQ Performance and Debugging
Performance Considerations and Best Practices in PLINQ
Debugging and Troubleshooting PLINQ Applications
Chapter 20: Entity Framework Core
Introduction to Entity Framework Core
Overview and Key Concepts of EF Core
Installing and Setting Up EF Core
DbContext and Database Connection String
CRUD Operations and Entity States
Performing CRUD Operations
Understanding and Managing Entity States
LINQ to Entities in EF Core
Database Design Approaches
Code First Approach to Database Design
Database First Approach and Migrations
Loading Strategies
Eager Loading
Lazy Loading
Explicit Loading
Configurations and Conventions
Default Conventions in EF Core
Data Annotations and Fluent API
Table, Column, Key, ForeignKey, and Index Attributes
Other Attributes: NotMapped, Required, MaxLength, MinLength, DatabaseGenerated,
TimeStamp, ConcurrencyCheck
Relationships: One-to-One, One-to-Many, Many-to-Many, Self-Referencing
Fluent API Configurations
Entity Configurations using Fluent API
Configuring Primary and Composite Keys
Property Configurations
Advanced Features
Transactions and Bulk Operations
Asynchronous Programming in EF Core
Disconnected Entities and Entity Graphs
Using Stored Procedures with EF Core
Inheritance Mapping in EF Core
Handling Schema Changes during Migrations
Additional EF Core Features
Seed Data and Data Initialization
Shadow Properties and Global Query Filters
Soft Deletes and Logical Deletion in EF Core
Migrations and Versioning
Database Migrations and Versioning
Performance Optimization
Bulk Operations using Extensions
Query Optimization and Caching
Chapter 21: Advanced Data Structures and Algorithms
Custom Data Structures: Linked Lists, Stacks, Queues
Graphs and Trees in C#
Advanced Sorting and Searching Algorithms
Implementing Hash Tables and HashSets
Performance Optimization for Data Structures
Thread-safe Data Structures
Complex Graph Algorithms
Chapter 22: Task-Based Asynchronous Programming
Advanced Task Scheduling and Continuations
Task Cancellation and Handling Non-Cancellable Tasks
Exception Handling in Task-based Programming
Asynchronous Streams (IAsyncEnumerable, yield async)
Asynchronous Iterators (Using yield with async)
Handling Aggregate Exceptions (Task Parallelism)
Chapter 23: Security and Cryptography
Symmetric and Asymmetric Encryption
Hashing and Salted Passwords
Data Integrity and Digital Signatures
Working with Secure Random Numbers
Encryption/Decryption of Data Streams
Cross-platform Cryptography in .NET Core
Chapter 24: Concurrency and Synchronization
Task Parallel Library (TPL) Advanced Concepts
Writing Lock-Free and Thread-Safe Code
Thread Synchronization Techniques (Monitors, Mutex, Semaphores)
Asynchronous Data Streams using IAsyncEnumerable
Lock-Free Programming Techniques
Optimizing Thread Synchronization
Chapter 25: Metaprogramming in C#
Code Generation using Reflection.Emit
Building Dynamic Proxies
Real-Time Code Injection Scenarios
T4 Templates (Useful for code generation)
Code DOM (Dynamic source code generation)
Chapter 26: Unit Testing and Mocking
Writing Unit Tests for Complex Algorithms
Using Moq for Mocking in Console Applications
Test-Driven Development (TDD)
Advanced Use of Assertions
Code Coverage (Tools like MSTest, xUnit, NUnit)
Parameterized Testing (Using attributes for test case generation)
Chapter 27: SOLID Design Principles
Single Responsibility Principle (SRP)
Open-Closed Principle (OCP)
Liskov Substitution Principle (LSP)
Interface Segregation Principle (ISP)
Dependency Inversion Principle (DIP)
Real-Time Case Studies for SOLID
Applying SOLID to Legacy Code
Chapter 29: Creational Design Patterns
Introduction to Creational Design Patterns
Factory Design Pattern
Factory Method Design Pattern
Abstract Factory Design Pattern
Builder Design Pattern
Singleton Design Pattern (Thread-safe Singleton, Lazy Loading)
Prototype Design Pattern (Shallow Copy, Deep Copy)
Chapter 30: Structural Design Patterns
Adapter Design Pattern
Decorator Design Pattern
Proxy Design Pattern
Facade Design Pattern
Bridge Design Pattern
Composite Design Pattern
Flyweight Design Pattern
Chapter 31: Behavioral Design Patterns
Iterator Design Pattern
Observer Design Pattern
Chain of Responsibility Design Pattern
State Design Pattern
Template Method Design Pattern
Command Design Pattern
Visitor Design Pattern
Strategy Design Pattern
Mediator Design Pattern
Memento Design Pattern
Chapter 32: Dependency Injection Design Pattern
Introduction to Dependency Injection
Property and Method Injection
Using Unity Container in C#
Scoped vs Transient Services
Chapter 33: Repository Design Pattern
Repository Design Pattern in C#
Generic Repository Pattern
Combining Generic and Non-Generic Repositories
Unit of Work Pattern
Chapter 34: New Features in C#
Enhancements in out Variables
Pattern Matching in C#
Digit Separators
Tuples and Tuple Decomposition
Local Functions
Ref Returns and Ref Locals
Generalized Async Return Types
Expression-Bodied Members
Async Main
ReadOnly Structs
Default Interface Methods
Nullable Reference Types in C# 8
Indices and Ranges
Stackalloc and Memory Management
Null-Coalescing Assignment Operator
Chapter 35: C# 12 New Features
Primary Constructors for Non-Record Types
Default Values for Lambda Expression Parameters
Collection Literals
Extended Nameof Operator
Relaxed Restrictions on Interpolated Strings
Default Type Parameters
Inline Arrays in Structs
Ref Fields in Records and Structs
Constant Interpolated Strings
Enhanced Switch Expression
Scoped ref Fields in Structs
File-Scoped Types
