Generics is a concept so ingrained into .NET that we can't do without it.
In this module we'll explain the simple and more advanced things of Generics.
- Using Generics
- Creating Generics
- Understanding Covariance and Contravariance
- LAB: Building a Generic Graph
Delegates and Events
Storing functions in variables, that is exactly what delegates allow us to do.
This concept is used in lots of locations, especially when using asynchronous programming.
Events are based on delegates, so whenever something interesting happens
in a UI (e.g., mouse click) and we want to react on it, we need delegates to handle it correctly.
- Creating Delegates
- Using Delegates
- Multicast Delegates
- Creating Events
- Using Events in a UI
- LAB: Applying Top-down Actions on a Hierarchy
LINQ Syntax Fundamentals
LINQ allows to write queries that are very familiar to SQL queries. This makes certain operations like filtering and sorting
data very easy. This concept is used in lots of locations, whether it is to connect to SQL databases of reading data
from Active Directory.
- What is LINQ?
- LINQ to Objects, SQL, Entity Framework and XML
- LINQ's Enumerable Class
- Func Delegate
- Query Syntax vs. Method Syntax
- Deferred Query Evaluation
- Querying Data using LINQ
- Group and Join Operators
- Don't Forget the Let Operator!
- LAB: Exploring LINQ Features
Tuples in C# open up a bunch of programming
techniques for writing better and comprehensible code.
- Introducing Tuples
- Writing Symmetric Functions
- Understanding Destructuring
- Pattern matching with tuples
- LAB: Using ValueTuples with LINQ
When you create an object in .NET, the framework takes care of memory management for you. What actually happens with objects
when .NET decides to remove them from memory? That's what Garbage Collection is all about and we'll have a look at why
it is important to understand it correctly.
- The Lifecycle of a Class Instance
- GC Class and Members
- Forcing a Garbage Collection
- Garbage Collection for Unmanaged Resources
- The Dispose Pattern
- Weak References
Reference Semantics with Value Types
Writing super-efficient code requires some special language features.
- Understanding Reference Semantics
- How Value Types allow you to write faster code
- Passing value types by reference with new access modifiers
- Understanding Span<T> and related classes
- Measuring using BenchmarkDotNet
- LAB: Boosting Performance by using Reference Semantics
In today's world where devices get more CPUs instead of the amount of Hz they produce, we need to be able to harvest this
power. In the modules about multi-threading, we'll discuss the advantages and problems you will encounter when using concurrency.
- What is Concurrency?
- Understanding Processes and Threads
- Different Kinds of Concurrency
- Scheduling Threads
Multithreading in .NET
Everyone starts by learning the fundamentals. The Thread class is the most basic implementation for creating concurrency.
It is important to have an understanding of this class so you can understand and appreciate the libraries that came afterwards.
- The Thread Class
- Exceptions and Threads
- Understanding Thread Pooling
- Debugging Multi-Threaded Code
Using variables in a multi-threaded environment can be very dangerous and/or confusing. In this module we'll explain what
can go wrong and how to avoid it.
- Race Conditions and Dead Locks
- Avoiding Race Conditions
- Synchronizing Threads: Locks, Monitors, Signals, ..
- Synchronization Guidelines
- Thread Safety in .NET
- LAB: Horse Race
Using threads directly is quite complicated, instead we can make use of tasks to do our bidding.
There are again advantages and disadvantages to using this library and we'll explore them in this module.
- What are Tasks?
- Waiting Asynchronously
- Dealing with Exceptions
- Task Cancellation
- Understanding ValueTask
The Async and Await Syntax Explained
Async and await are a language construct existing since .NET 4.5. This construct allows asynchronous programming in a newer
and refreshing way.
- What is Asynchronous Programming?
- Invoking any Method, Synchronous and Asynchronous
- Async Exception Handling
- LAB: using Async and Await
Asynchronous programming in .NET
Once you understand the async and await keywords, you can start worrying about all the other fluff like exception handling.
And what about cancellation or reporting progress of an async task? This is the subject of this module.
- A History of Asynchronous Programming in .NET
- Understanding SynchronizationContext
- Cancellation, Progress and Exception Handling
- Async Guidelines
- LAB: Async and Await in a Library
In a multi-core environment, being able to split data so every core is working on something is incredibly useful. This
module explores a library created to do just that.
- What is Parallel Programming?
- Concurrent Collections
- Parallel LINQ
- LAB: Parallel Calculations, Parallel API calls
Reactive Extensions, a feature a bit complex to understand, but very powerful and hard to get back from. It is sometimes
called LINQ to events, because we think of asynchronous operations or events as a stream of data. An observable collection
that will, from time to time, have a new interesting event pop up that we can react to.
- Push vs. Pull
- Understanding IObservable<T> and IObserver<T>
- Hot and Cold Observables
- Using LINQ with Rx
- Building your own Rx Extensions
- LAB: Search Spotify
Attributes and Reflection
In this module we'll talk about using attributes to add metadata to almost everything in .NET. Metadata is of course only
useful if we can actually interpret it and that's where reflection comes into play. Reflection is a powerful feature
used in lots of libraries and applications.
- What are Attributes?
- Applying Attributes
- Common Predefined Attributes
- Building Custom Attributes
- What is Reflection?
- Retrieving Attribute Values
- LAB: Task Scheduler
Expressions and Static Reflection
Making use of Expressions to dynamically create code that can be run when we want to, is very powerful. It is a feature
used by LINQ for example to translate queries for a database or other system.
- What are Expressions?
- How does LINQ to Database work?
- Using Static Reflection
- Dynamically Generating Code with Static Reflection
Using the Dynamic Language Runtime
.NET is a statically typed language, or is it? Microsoft has introduced a keyword allowing
us to use dynamically typed variables. In this module we'll explain the use cases for it and how powerful it actually
- Understanding the Dynamic Keyword
- Building your own Dynamic Types
- LAB: A Dynamic CSV Reader