Can you share some strategies for enhancing the execution speed of C# programs?

Here are some strategies you can use to enhance the execution speed of your C# programs:

Use Value Types Over Reference Types When Possible: Value types (like structs) are allocated on the stack, which is faster compared to reference types (like classes) that are allocated on the heap. However, be cautious; large structs can actually be less efficient due to the copying involved when passing them around.

Minimize the Use of Boxing and Unboxing: Boxing occurs when a value type is converted to an object type, and unboxing is the reverse. This process is computationally expensive. To avoid boxing, use generic types, or keep data in its native value type form as much as possible.

Optimize Your Loops: If you can, reduce the number of iterations in a loop, or even better, avoid using loops when possible. Also, try to avoid doing expensive operations inside the loop body. For instance, calculate any constants outside the loop.

Avoid Unnecessary Object Creation: Creating objects is a resource-intensive operation. If you can reuse objects rather than creating new ones, it'll improve your program's performance. Consider using object pools or reusing objects in other ways.

Use StringBuilder for String Manipulations: When you concatenate strings repeatedly, using StringBuilder instead of regular string concatenation (+ or +=) can significantly boost performance, especially in scenarios involving a large number of string operations.

Profile and Benchmark: Profiling tools like Visual Studio's performance profiler can help you identify bottlenecks in your code. You can focus your optimization efforts on the areas that have the most impact on performance.

Leverage Parallelism and Asynchronous Programming: Utilize Task, async, and await for non-blocking operations, and consider Parallel.For or PLINQ (Parallel LINQ) for operations that can be parallelized. However, be mindful of thread contention and the potential overhead of context switching.

Use Efficient Data Structures: Choose the right data structures for the job. For instance, use a Dictionary for lookups instead of a List, or use HashSet when you need to ensure uniqueness and fast lookups.

Inline Methods: The JIT compiler automatically inlines small methods, but for methods that are frequently called and performance-critical, consider making them as small as possible to increase the likelihood of inlining.

Reduce Memory Allocation: Excessive memory allocation and garbage collection can slow down your program. Try to allocate memory in larger chunks and reduce the frequency of allocations.

Use the readonly Keyword: If you have a field that doesn't change after the object is constructed, mark it as readonly. This helps the JIT compiler optimize access to the field.

Use Array Pools: If you need to frequently create and destroy arrays, consider using ArrayPool<T>. It's a pool of arrays that can be reused, reducing the pressure on the garbage collector.

Optimize LINQ Queries: LINQ is convenient, but it can introduce overhead, especially if you're chaining multiple queries together. Consider writing more explicit loops for performance-critical sections or use ToList() to materialize results early if needed.

Consider Span<T> for Memory Manipulation: Span<T> allows you to work with slices of arrays or memory blocks efficiently, without additional allocations. It can be very useful for high-performance scenarios.

Try to speed up the specific scenario by adding benchmarks first. Whenever you have a lot of modifications to make, you should replace arrays and strings with Span or ReadOnlySpan. A little tweaking of the GC can help too, like completely disabling it during a critical operation. Overall, there are many options to play with in both JIT and GC—worth checking out as it's really interesting. Instead of small arrays, you might want to use Span along with stackalloc, which will allow you to dodge heap access more often. It may not seem obvious, but moving method parameters to local variables can often result in quicker code execution.

Not a trick exactly, but:
LINQ isn't known for being fast. But sometimes, attempts to optimize a LINQ query don't really boost performance at all. For example, two Where with simpler conditions are better than one complex Where statement. Also worth mentioning, always specify the exact type whenever you can. If you have the choice between an Interface and a Generic, the latter is preferable. Sealing your classes will help JIT compile more efficiently, so if speed matters, take a second to add it. Large structs should almost always be passed by reference rather than by value, for instance by using the in modifier. Even though goto is generally disliked, it can minimize the generated machine code size by replacing multiple returns with one goto return.

EXCEPTIONS SHOULD ONLY BE USED FOR EXCEPTIONAL SCENARIOS, or ideally not used at all.
One more note, not really a trick: C# has an unsafe mode, allowing you to work with raw pointers, and even write code similar to C, with all its pros and cons.

PS: It's quite possible to write C# code that can match the performance of C, though it may not look much like C# in the end.

One of the quickest ways to make C# or simmilar languages run faster is by writting the most important code sections in C++ and linking them through COM or p/invoke. That's what I do, and it works great.

You also need to be careful with memory allocation, use structures, and keep key data on the stack. Avoid unneccessary boxing, and utilize multithreading wisely. Manage threads rather than just tossing tasks wherever, and opt for ValueTask when needed. Also, don't serialize data you don't have to, and sometimes it's worth pausing the garbage collector—though that's getting into hardcore territory.

In higher-level languages, it's more crucial to avoid mistakes that can backfire. There's no magic solution, and trying to find one can lead to bad practices.
But, here's a trick I picked up at the DotNext conference: To skip array overflow checks, you can assign the last element first. But remember, if you're resorting to tricks like this, you might be using the wrong language for the job.