Stepping up to CSharp (C# Accelerator)

NOTE: newer versions of C#/.NET do allow you to write executable code without a class.

Syntax and terminology is important.  Here we review some of the basics of C#.

A quick overview of these statements and how they operate.

There are seemingly endless classes in the .NET Framework.

Here's a list of some of the core collection classes that you may need in your next project.

In this deep-dive, we cover Enumerables and the concepts that make them work.

As a bonus topic, we also cover "Method Overloading" and how C# deals with specificity.

Write functional code for interfaces and classes without inheritance using extensions.

Using what we've learned so far, this walk-through demonstrates some more possibilities when leveraging extensions.

Delegates (sometimes called 'handlers') are a way of defining a complex function signature for reuse.  More generic function signatures can be easily declared by using the predefined Action delegate, Func delegate, or by simply writing a lambda expression (otherwise known as an 'arrow function').

This lecture also covers the topic of 'ref' and 'out' when defining parameter types.

The IDisposable interface is the foundation for C#'s disposable pattern.  Facilitating easy preemptive cleanup of resources.

This lecture reviews the handling of disposables and general best practices.

In this lecture we discuss the importance of error handling with exceptions and the balance of best practice when applying them to your own code.

There's always been a need to 'signal', 'trigger' or 'message pass' to some second or third party.  A class may be the sender of that signal, and others can be a receiver.  This can be done in a variety of ways:

• A one to one message pass, where only one instance of a message is sent to a single receiver.
• Or a broadcast where there can be many 'listeners'.

C# provides classes and patterns to handle this problem and this section will prime you for more exposure to them.

Events in C# are a flexible system where any class can define any number of named events.  Then any consumer of that class can 'listen' for these events by adding delegates (event handlers).  This pattern is useful since it's easy to define specific custom events and easy to implement event handlers since the pattern is built in to the language. 

The Observer pattern is useful like events where an observable can be "subscribed" to by an observer.

An observable can then push messages to its observers and subscriptions are disposable objects that make it easy to unsubscribe.

The Task Paralleling Dataflow Library is an incredibly powerful set of classes that makes asynchronous message passing robust, flexible and performant.

This topic could be a computer science course all by itself.  We will touch on the important lessons learned and discuss best practices when dealing with synchronization, concurrency and performance.

C# provides the async and await keywords to simplify writing asynchronous code.