Defensive C# Programming

C# is one of the languages designed for the Common Language Infrastructure. It was developed around 2000 by Microsoft but is now an approved standard language. Just like any other programming languages, it is essential to understand the underlying mechanisms in order to avoid making common mistakes.

This course is designed to impart the theory behind how some of the underlying mechanisms work by working through some C# examples. Attendees will finish the course with a working knowledge of common C# programming errors that can lead to software problems and effective mitigation strategies to avoid introducing these errors.

What You Will Learn:

• How to handle memory correctly.
• How to handle exceptions correctly.
• How to handle floating-point correctly.
• How to handle multi-threading correctly.

Course Structure:

• Day 1
• Expressions: value and references; comparing values for equality; ignoring return values; dereferencing null pointers.
• Exceptions: handling all exceptions; honouring exceptions; guaranteeing exception safety; Catch and rethrow; New exceptions; First-chance exception; Asynchronous exceptions; Exposing exception information; Dealing with unhandled exceptions; Tracking exception source; Selective exception processing.
• Day 2
• Floating-point: IEEE754 standards; division; rounding; overflow; underflow; Kahan summation; inherent errors; domain and range errors; rounding a floating-point value; choosing a rounding algorithm.
• Integers: integer overflow; divide-by-zero; integer precision; safe narrowing of numeric casting; enumeration validation; using enumerations; Determining enumeration flags.
• Strings: String concatenation; De/encoding Base64; Converting byte[] to string; Passing string as byte[]; Valid numeral string.
• Day 3
• Memory Management: stack vs heap; managed heap; large-object heap; creating objects on the heap; removing objects from the heap; garbage collection; implementing dispose; implementing finalize; unmanaged resources.
• Object-Oriented Programming: cloning classes; disposing objects; null checking; multiple disposal;
• Collections: Custom enumerators; Nested foreach; LINQ speed-up.
• Day 4
• Concurrency: semaphores; mutex; multiplex; barriers; race conditions; avoiding deadlocks; Per-thread static storage; Thread-safe access to classes; Silent thread termination; Asynchronous thread completion; Private thread data; Using semaphore; Using mutex; Using events; Atomic operations; In-order task execution.
• Input/Output: EOF; TOCTOU; reading and writing files; closing files; Wildcard searching; Directory tree; Path parsing; Using command-line utilities; Locking a file; Filesystem events.