Advanced C# Programming
Advanced C# Programming is a course in the deeper mechanics of C# on .NET, covering advanced object-oriented design, value and reference types, pattern matching, reflection, delegates, generics, LINQ, extension members, async/await, multithreading and performance tuning. It suits developers who already write C# and those who learned Visual C# on the .NET Framework and want to bring their skills up to date.
- Duration18 hours · 3 days
- FormatOnsite / live online
- Next roundOn request
- CertificateIncluded
Course overview
Once you can write C# comfortably, what separates professional code from code that merely works is a deeper grasp of how the language behaves: flexible object-oriented design, memory management, generics, delegates and LINQ, and asynchronous and multithreaded work. C# 14 on .NET 10 (LTS) also adds new tools such as extension members, the field keyword and null-conditional assignment that make code shorter and safer.
This course takes you from C# fundamentals to advanced programming, from interfaces and abstract classes, value and reference types, boxing, pattern matching, operator overloading, indexers, attributes and reflection to delegates, events, lambdas, generics in depth, advanced LINQ and extension members, finishing with async/await, threads, parallel work, Span, debugging and unit testing. Every topic is practised in console apps and class libraries, independent of any web framework. (3 days, 6 hours per day, 18 hours in total, Advanced level.)
What you’ll gain
- Design advanced object-oriented code with interfaces, abstract classes and composition
- Understand value and reference types, the stack and heap, casting, boxing and unboxing
- Use pattern matching, operator overloading, indexers, attributes and reflection
- Use delegates, events, lambdas, generics and advanced LINQ correctly
- Use new C# 14 features such as extension members and the field keyword
- Write asynchronous and multithreaded code safely
- Improve performance with Span and measure before deciding
- Debug, diagnose problems and write unit tests for your own code
Who this course is for
- Developers who already write C# and want a deeper understanding of the language
- People who learned Visual C# on the .NET Framework and want to update to C# 14 on .NET 10
- Developers who maintain class libraries, services or background programs for their organisation
- IT managers and team leads who review their team's C# code
Prerequisites
- Able to program in C#, with a basic grasp of classes, methods, collections and exceptions
- Some experience creating and running .NET projects in Visual Studio or VS Code
- Completion of Basic C# Programming or equivalent experience
- A Windows, macOS or Linux laptop that can run the .NET 10 SDK, with rights to install software
Curriculum
Course Details
This course is the 2026 edition of Advanced Programming with Visual C# .NET, which originally taught C# on the .NET Framework. It has been rewritten for C# 14 on .NET 10 (LTS). It runs for 3 days, 6 hours per day (18 hours in total, 09:00-16:00), as lectures with labs. Advanced level. Day one covers advanced object-oriented programming and language mechanics: interfaces, abstract classes, memory, pattern matching, operator overloading, attributes
and reflection. Day two covers delegates, events, lambdas, generics, advanced LINQ, extension members and exception handling. Day three covers concurrency and code quality: async/await, threads, parallel work, channels, Span, debugging and unit testing, finishing with a team-grade class library workshop. The course focuses on the language through console apps and class libraries; building websites and APIs is covered in the ASP.NET Core courses. All tools are free on Windows, macOS and Linux.
Day 1 Advanced OOP and Language Mechanics
Section 1: Lab: .NET 10 Solutions and What's New in C# 14
- C# from the .NET Framework era to .NET 10 (LTS), and the release cycle
- Create a multi-project solution with the dotnet CLI and Visual Studio 2026
- Turn on nullable reference types and analysers across the solution
- An overview of C# 14: extension members, field and null-conditional assignment
- Lab: set up the class library and console app used throughout the course
Section 2: Lab: Advanced OOP with Interfaces and Abstract Classes
- Review inheritance, polymorphism, encapsulation and abstraction
- Interfaces, implementing several interfaces and default interface members
- Abstract classes, and choosing between an abstract class and an interface
- Static abstract members in interfaces, and composition over inheritance
- Lab: a shipping cost system that accepts new methods without changing existing code
Section 3: Value Types, Reference Types and Memory
- Memory allocation in .NET: the stack, the heap and the garbage collector
- How class, struct, record and record struct differ
- readonly struct, ref struct, and passing values with ref, in and out
- Boxing and unboxing and their effect on performance
- Lab: measure boxing in a loop and fix it with generics
Section 4: Lab: Casting, Pattern Matching and Operator Overloading
- Implicit and explicit conversions, and writing conversion operators
- Pattern matching: type, property, relational and list patterns
- Operator overloading and user-defined compound assignment in C# 14
- Indexers, and choosing between an indexer and a property
- Lab: a Money type that adds, subtracts and compares safely
Section 5: Lab: Attributes and Reflection
- Built-in attributes such as Obsolete and Conditional
- Create custom attributes with AttributeUsage
- Read metadata with reflection, and its performance caveats
- An overview of source generators, which replace reflection in many tasks
- Lab: a validator that reads its rules from attributes
Day 2 Delegates, Generics and LINQ in Depth
Section 6: Lab: Delegates, Events and Lambdas
- Delegates, multicast delegates, and Func and Action
- Events following the .NET pattern with EventHandler<T>
- Lambda expressions, closures and captured variables
- Modifiers on simple lambda parameters in C# 14
- Lab: a stock alert system that listeners can subscribe to and leave
Section 7: Lab: Generics in Depth
- Design your own generic classes, methods and interfaces
- Constraints: class, struct, new(), notnull and interfaces
- Covariance and contravariance with in and out
- Generic math with INumber<T> and static abstract members
- Lab: a generic repository and a calculation that works with any numeric type
Section 8: Lab: Collections and Advanced LINQ
- List, Dictionary, HashSet and Queue, and choosing the right one
- Immutable and frozen collections for data that does not change
- LINQ: Join, GroupBy, SelectMany, CountBy and AggregateBy
- Deferred execution and the trap of enumerating twice
- Lab: a multi-dimensional sales report from order data
Section 9: Lab: Extension Members in C# 14
- Classic extension methods and their limits
- Extension blocks for extension properties and extension methods
- Static extension members and operators added to existing types
- Naming and placement guidelines that keep code clear
- Lab: extend .NET types and your team's types with extension blocks
Section 10: Exceptions and Releasing Resources
- Design custom exceptions and exception filters with when
- When to throw and when to return a Result
- IDisposable, IAsyncDisposable, using and await using
- Null-conditional assignment and nullable annotations in your own APIs
- Lab: a data import class that handles errors and releases every resource
Day 3 Concurrency, Performance and Code Quality
Section 11: Lab: Async/Await in Depth
- Task, ValueTask and what happens at an await
- Cancel work with CancellationToken and set timeouts
- Wait for several tasks with Task.WhenAll and Task.WhenAny
- IAsyncEnumerable and await foreach
- Lab: download and process several files at once, with cancellation
Section 12: Lab: Threads, Parallel Work and Channels
- Thread concepts, Join and Sleep, and why Task is the better choice for most work
- Race conditions and preventing them with lock and the Lock type
- Parallel.ForEachAsync and concurrent collections
- Producers and consumers with System.Threading.Channels
- Lab: an order processing queue with several workers
Section 13: Span and Performance Tuning
- Span<T>, ReadOnlySpan<T> and Memory<T>
- Implicit span conversions in C# 14
- Cut allocations with ArrayPool and stackalloc
- Measure before tuning with BenchmarkDotNet
- Lab: speed up a CSV parser and compare the results
Section 14: Lab: Debugging, Diagnostics and Unit Testing
- Conditional breakpoints, tracepoints and the most useful debug windows
- Debug async and multithreaded code with Parallel Stacks
- Trace behaviour with logging and dotnet-counters
- Write unit tests with xUnit and run them with dotnet test
- Lab: write tests for the Money type and the order processing queue
Section 15: Workshop: A Team-Grade Class Library
- Design a class library with interfaces, generics and events
- Use dependency injection and configuration in a console app with the Generic Host
- Workshop: an asynchronous order processing system with a unit test suite
- Pack it as a NuGet package for internal use
- Present the result and review the code together
Schedule & training options
For individuals — public rounds
No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770
For organisations — in-house / private
- Tailor the content to your team’s tools and projects
- Your dates, at your office or live online
- Quotation with tax ID for procurement
Instructors
Frequently asked questions
What is the difference between an interface and an abstract class in C#?
An abstract class can contain fields, constructors and fully written methods, but a class can inherit from only one, so it suits a family of related classes that share code. An interface is a contract stating which members a class must provide, a class can implement several, and in modern C# interfaces can also carry default members and static abstract members, so they suit capabilities that unrelated classes share.
How do value types differ from reference types, and what is boxing?
Value types such as int, double, bool, structs and record structs hold their data directly, so assigning one to another variable makes a copy. Reference types such as classes, records, strings and arrays hold a reference to an object on the heap, so assignment points both variables at the same object. Boxing converts a value type to object, allocating new memory on the heap; done often it slows code down, so prefer generics and measure with a tool such as BenchmarkDotNet.
How do C# 14 extension members differ from classic extension methods?
Classic extension methods can only add methods to an existing type, written as static methods with this before the first parameter. C# 14 adds extension blocks, where you declare the target type once and then add extension properties, extension methods, static extension members and operators together in one group. Existing extension methods keep working, so you can move to the new style gradually.
Who is the Advanced C# Programming course for, and what should I know beforehand?
It suits developers who already write C# and want a deeper understanding of the language, people who learned Visual C# on the .NET Framework and want to move to C# 14 on .NET 10, developers who maintain class libraries or background programs, and team leads who review code. You should be able to program in C# with a basic grasp of classes, methods, collections and exceptions, or have completed Basic C# Programming.
What will I be able to do after the Advanced C# Programming course?
You will be able to design advanced object-oriented code with interfaces, abstract classes and composition, understand memory, value and reference types and boxing, use pattern matching, operator overloading, attributes and reflection, use delegates, events, generics, LINQ and C# 14 extension members, write async and multithreaded code safely, tune performance with Span and measure the result, and debug and unit test your code. Participants who complete the training receive a Certificate of Completion with its own number, which can be verified online.
Can the Advanced C# Programming course be run in-house for our team?
Yes. It can be run in-house for your team, with examples adapted to your own work, such as restructuring classes from code your team maintains or moving C# code from the .NET Framework to .NET 10. You can request a quotation from this page, or contact us on LINE @itgenius or by phone on 02-570-8449.