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