Write Fast C# Code

Crafting efficient C# code not only enhances the user experience but also ensures your applications can handle demanding tasks with ease. This article delves into practical tips noted from Mark Farragher’s webinar, empowering you to write faster and more optimized C# code.

TL;DR:

• Exceptions slow things and must be used judiciously. And when used, be careful so as to not swallow exceptions.
• StringBuilder is faster when there are more than 3 string concatinations and an instantiated string builder is the fastest!
• 1-d array is faster
• for is faster than foreach
• structs are faster than classes
• Inbuilt extensions are faster
• Instantiation: Dynamic CIL is faster than Reflection but Compile time is fastest
• Property Access: Compile time is fastest, always!
• When using LinQ, foreach doesn’t matter

Core Performance Principles:

• Minimize Exceptions: Exception handling is crucial for robust code, but frequent exceptions can significantly impact performance. Employ exceptions judiciously, only when necessary. If an error condition is expected, consider alternative approaches like returning error codes or validation checks.
• String Concatenation: For building lengthy strings, leverage StringBuilder instead of string concatenation (+). StringBuilder avoids creating temporary string objects in memory, leading to significant performance gains, especially when dealing with more than three string concatenations.

Data Structures and Looping Constructs:

• One-Dimensional Arrays: When working with collections of similar data types, prioritize one-dimensional arrays (e.g., int[]) over more complex data structures like lists. Arrays offer faster access and lower memory overhead compared to their dynamic counterparts.
• For Loops: For simple iterations through a collection, the classic for loop generally surpasses foreach loops in terms of performance. For loops provide more granular control over the iteration process, potentially leading to slight optimizations.

Classes vs. Structs:

• Structs for Performance: When dealing with small data objects that don’t require inheritance, consider using structs instead of classes. Structs are typically stored on the stack, offering faster access compared to classes, which reside on the managed heap. However, structs cannot inherit from other types, so their usage might be limited in certain scenarios.

Leveraging Built-in Functionality:

• Inbuilt Extensions: C# offers a rich set of built-in extension methods. Utilizing these extensions for common operations can often be faster than implementing custom logic from scratch. The extension methods are likely highly optimized for the specific data types they operate on.

Instantiation and Property Access:

• Compile-Time is King: When accessing properties or methods, direct property access or method calls compiled directly into the code is the absolute fastest approach. This eliminates the overhead associated with reflection or dynamic invocation.
• CIL vs. Reflection: If dynamic code generation is unavoidable, utilizing System.Reflection.Emit (dynamic Common Intermediate Language - CIL) can be slightly faster than pure reflection through System.Reflection. However, both approaches introduce some performance overhead compared to compile-time access.

Additional Considerations:

• Benchmarking: Performance optimization should be a data-driven process. Utilize profiling tools to identify performance bottlenecks within your codebase. Benchmark different approaches to objectively measure performance gains and ensure your optimizations are truly effective.
• Tradeoffs and Context: Remember, optimization is often a balancing act. While certain techniques might improve raw performance, they might introduce code complexity or hinder readability. Make informed decisions based on the specific context and requirements of your application.

By incorporating these guidelines and adopting a performance-conscious mindset, you can elevate your C# coding skills and create applications that perform exceptionally well.