C# Training Course

Learn the fundamentals of the C# language and how to apply it

Duration

  • 5 Days

What do I need?

  • Webinar : A laptop, and a stable internet connection. The recommended minimum speed is around 10 Mbps.
  • Classroom Training : A laptop, please notify us if you are not bringing your own laptop. Please see the calendar below for the schedule

Certification

  • Attendance : If you have attended 80% of the sessions and completed all the class work, you qualify for the Attendance Certificate.
  • Competency : If you have also completed all the practical projects as described the Outcomes section, you qualify for the Competency Certificate.

Pre-requisites

Who will benefit

  • Not for beginners, this course teaches you the nuts and bolts of C#, such as generics, LINQ, and asynchronous programming features.
  • Get up to speed on .NET Core and the latest C# 8.0 additions, including asynchronous streams, nullable references, pattern matching, default interface implementation, ranges and new indexing syntax, and changes in the .NET tool chain.

What you will learn

  • How C# supports fundamental coding features, such as classes, other custom types, collections, and error handling
  • How to write high-performance memory-efficient code with .NET Core’s Span and Memory types
  • Query and process diverse data sources, such as in-memory object models, databases, data streams, and XML documents with LINQ
  • How to Use .NET’s multithreading features to exploit your computer’s parallel processing capabilities
  • Learn how asynchronous language features can help improve application responsiveness and scalability

Day One

  • 1. Why C#? C#’s Defining Features Managed Code and the CLR Prefer Generality to Specialization C# Standards and Implementations Many Microsoft .NETs (Temporarily) Targeting Multiple .NET Versions with .NET Standard Visual Studio and Visual Studio Code Anatomy of a Simple Program Adding a Project to an Existing Solution Referencing One Project from Another Referencing External Libraries Writing a Unit Test Namespaces Classes Program Entry Point Unit Test
  • 2. Basic Coding in C# Local Variables Scope Statements and Expressions Statements Expressions Comments and Whitespace Preprocessing Directives Compilation Symbols #error and #warning #line #pragma #nullable #region and #endregion Fundamental Data Types Numeric Types Booleans Strings and Characters Tuples Dynamic Object Operators Flow Control Boolean Decisions with if Statements Multiple Choice with switch Statements Loops: while and do C-Style for Loops Collection Iteration with foreach Loops Patterns Getting More Specific with when Patterns in Expressions
  • 3. Types Classes Static Members Static Classes Reference Types Structs When to Write a Value Type Guaranteeing Immutability Members Fields Constructors Deconstructors Methods Properties Indexers Initializer Syntax Operators Events Nested Types Interfaces Default Interface Implementation Enums Other Types Anonymous Types Partial Types and Methods
  • 4. Generics Generic Types Constraints Type Constraints Reference Type Constraints Value Type Constraints Value Types All the Way Down with Unmanaged Constraints Not Null Constraints Other Special Type Constraints Multiple Constraints Zero-Like Values Generic Methods Type Inference Generics and Tuples Inside Generics

Day Two

  • 5. Collections Arrays Array Initialization Searching and Sorting Multidimensional Arrays Copying and Resizing List List and Sequence Interfaces Implementing Lists and Sequences Implementing IEnumerable with Iterators Collection ReadOnlyCollection Addressing Elements with Index and Range Syntax System.Index System.Range Supporting Index and Range in Your Own Types Dictionaries Sorted Dictionaries Sets Queues and Stacks Linked Lists Concurrent Collections Immutable Collections ImmutableArray
  • 6. Inheritance Inheritance and Conversions Interface Inheritance Generics Covariance and Contravariance System.Object The Ubiquitous Methods of System.Object Accessibility and Inheritance Virtual Methods Abstract Methods Inheritance and Library Versioning Sealed Methods and Classes Accessing Base Members Inheritance and Construction Special Base Types
  • 7. Object Lifetime Garbage Collection Determining Reachability Accidentally Defeating the Garbage Collector Weak References Reclaiming Memory Garbage Collector Modes Temporarily Suspending Garbage Collections Accidentally Defeating Compaction Forcing Garbage Collections Destructors and Finalization IDisposable Optional Disposal Boxing Boxing Nullable
  • 8. Exceptions Exception Sources Exceptions from APIs Failures Detected by the Runtime Handling Exceptions Exception Objects Multiple catch Blocks Exception Filters Nested try Blocks finally Blocks Throwing Exceptions Rethrowing Exceptions Failing Fast Exception Types Custom Exceptions Unhandled Exceptions Summary

Day Three

  • 9. Delegates, Lambdas, and Events Delegate Types Creating a Delegate Multicast Delegates Invoking a Delegate Common Delegate Types Type Compatibility Behind the Syntax Anonymous Functions Captured Variables Lambdas and Expression Trees Events Standard Event Delegate Pattern Custom Add and Remove Methods Events and the Garbage Collector Events Versus Delegates Delegates Versus Interfaces
  • 10. LINQ Query Expressions How Query Expressions Expand Supporting Query Expressions Deferred Evaluation LINQ, Generics, and IQueryable Standard LINQ Operators Filtering Select SelectMany Ordering Containment Tests Specific Items and Subranges Aggregation Set Operations Whole-Sequence, Order-Preserving Operations Grouping Joins Conversion Sequence Generation Other LINQ Implementations Entity Framework Parallel LINQ (PLINQ) LINQ to XML Reactive Extensions Tx (LINQ to Logs and Traces)
  • 11. Reactive Extensions Fundamental Interfaces IObserver IObservable Publishing and Subscribing with Delegates Creating an Observable Source with Delegates Subscribing to an Observable Source with Delegates Sequence Builders Empty Never Return Throw Range Repeat Generate LINQ Queries Grouping Operators Join Operators SelectMany Operator Aggregation and Other Single-Value Operators Concat Operator Rx Query Operators Merge Windowing Operators The Scan Operator The Amb Operator DistinctUntilChanged Schedulers Specifying Schedulers Built-in Schedulers Subjects Subject BehaviorSubject ReplaySubject AsyncSubject Adaptation IEnumerable and IAsyncEnumerable .NET Events Asynchronous APIs Timed Operations Interval Timer Timestamp TimeInterval Throttle Sample Timeout Windowing Operators Delay DelaySubscription
  • 12. Assemblies Anatomy of an Assembly .NET Metadata Resources Multifile Assemblies Other PE Features Type Identity Loading Assemblies Assembly Resolution Explicit Loading Isolation and Plugins with AssemblyLoadContext Assembly Names Strong Names Version Culture Protection

Day Four

  • 13. Reflection Reflection Types Assembly Module MemberInfo Type and TypeInfo MethodBase, ConstructorInfo, and MethodInfo ParameterInfo FieldInfo PropertyInfo EventInfo Reflection Contexts Summary
  • 14. Attributes Applying Attributes Attribute Targets Compiler-Handled Attributes CLR-Handled Attributes Defining and Consuming Attributes Attribute Types Retrieving Attributes Summary
  • 15. Files and Streams The Stream Class Position and Seeking Flushing Copying Length Disposal Asynchronous Operation Concrete Stream Types One Type, Many Behaviors Text-Oriented Types TextReader and TextWriter Concrete Reader and Writer Types Encoding Files and Directories FileStream Class File Class Directory Class Path Class FileInfo, DirectoryInfo, and FileSystemInfo Known Folders Serialization BinaryReader, BinaryWriter, and BinaryPrimitives CLR Serialization JSON.NET

Day Five

  • 16. Multithreading Threads Threads, Variables, and Shared State The Thread Class The Thread Pool Thread Affinity and SynchronizationContext Synchronization Monitors and the lock Keyword SpinLock Reader/Writer Locks Event Objects Barrier CountdownEvent Semaphores Mutex Interlocked Lazy Initialization Other Class Library Concurrency Support Tasks The Task and Task Classes Continuations Schedulers Error Handling Custom Threadless Tasks Parent/Child Relationships Composite Tasks Other Asynchronous Patterns Cancellation Parallelism The Parallel Class Parallel LINQ TPL Dataflow
  • 17. Asynchronous Language Features Asynchronous Keywords: async and await Execution and Synchronization Contexts Multiple Operations and Loops Returning a Task Applying async to Nested Methods The await Pattern Error Handling Validating Arguments Singular and Multiple Exceptions Concurrent Operations and Missed Exceptions
  • 18. Memory Efficiency (Don’t) Copy That Representing Sequential Elements with Span Utility Methods Stack Only Representing Sequential Elements with Memory ReadOnlySequence Processing Data Streams with Pipelines Processing JSON in ASP.NET Core
Back to top