C# Optimization

Apply low-level optimizations to speed up C# programs. Tune program performance.

Optimization. Deep in the ocean an octopus hides from predators. It disguises itself on the ocean floor. When attacked, it releases dark ink.

For an octopus, survival depends on escape. It optimizes to avoid being eaten. A C# program too can be optimized for performance, to work better and faster.

Benchmark. We must take measurements. Use Stopwatch and your mission will become easier. Keep track of the numbers in a text file (the octopus lacks this advantage).Benchmark Benchmark: memory hierarchy Benchmark: ProfileOptimization Benchmark: use Stopwatch

Methods. Now consider your methods. Once your figure out the important ones, begin to apply optimizations. Attack excess allocations first. The ocean is deep and dangerous.Methods: fast return Methods: reduce call depth Methods: reduce method size Methods: reduce parameters Methods: reduce recursion Methods: reduce variable usage Methods: reorder parameters Methods: return multiple values fast Methods: store field in variable Methods: use AggressiveInlining Methods: use async Methods: use const values Methods: use pasted inline code Methods: use precomputed bit counts Methods: view IL

List optimizations. The List is a beautiful thing. But if you use it foolishly, your program ends up in bad shape. A predator (like a shark) may eat it before it finishes.Lists: avoid lookups Lists: count fast Lists: prefer for-loop Lists: remove fast Lists: use capacity Lists: use Clear

Dictionary optimizations. A giant squid signals danger. In a similar way the Dictionary signals a program that is fast. Use a dictionary if lookups are needed.Dictionary: avoid loops Dictionary: change add order Dictionary: increase memory Dictionary: measure memory Dictionary: reduce data Dictionary: shorten keys Dictionary: test before adding Dictionary: use array if possible Dictionary: use IEqualityComparer Dictionary: use memoization Dictionary: use StringComparer Dictionary: use TryGetValue

Memory optimizations. Memory is a physical thing. It has shape and size (like an atom). In our performance quest we should conserve memory—use as little as possible.Memory: locality of reference Memory: measure class size Memory: temporal locality Memory: use arrays Memory: use bit masks Memory: use BitArray

Array optimizations. Arrays store elements in a fast way. As the octopus hides, it could store its location in a compact array. This would help it escape faster.Array: cache Array: count fast Array: flatten 2D array Array: use Buffer.BlockCopy Array: use byte array Array: use jagged array Array: use lookup table Array: use sentinel element Array: use separate arrays

String optimizations. Strings are immutable. Often we must create new strings as a program runs. These excess allocations are slow. We remove them if possible.Strings: avoid Replace Strings: avoid ToUpper, ToLower Strings: combine format strings Strings: fast for-loop Strings: fast int parse Strings: lowercase characters fast Strings: memory size Strings: path optimization Strings: split on chars Strings: ToString int optimization Strings: use lastIndexOf Strings: use short strings

Regex optimizations. In the deepest part of the ocean, we find regular expressions. But even Regex can be optimized. Often we optimize a Regex by removing it.Regex: optimize Regex: prefer string loop Regex: use Compiled

StringBuilder optimizations. The StringBuilder is like a List. It grows as needed. After each operation, no allocation happens—and this speeds up programs.StringBuilder: append ranges StringBuilder: consider strings StringBuilder: data types StringBuilder: fast int append StringBuilder: reduce appends StringBuilder: store data efficiently StringBuilder: use cache StringBuilder: use capacity StringBuilder: use Equals

Class optimizations. Prefer classes to structs. When we pass a class to a method, only a reference is copied. With classes we avoid moving things in memory.Classes: avoid structs Classes: cache DateTime Classes: cache typeof Classes: use static fields Classes: use structs Classes: use tree Classes: use Tuple

Branch optimizations. For survival the octopus does not spend its time evaluating slow logic. It moves quickly. For C# we speed up our branches with switches or for-loops.Statements: avoid LINQ Statements: avoid yield Statements: hoist try, catch Statements: reorder if Statements: unwinding, jamming, decrement Statements: use complex expressions Statements: use switch

Some research. You can find many optimization tips in Code Complete. I recommend this book for some tips. Some strategies may not be useful in C#. Many are still relevant.

Quote: Use a high-quality design. Make the program right. Make it modular and easily modifiable so that it's easy to work on later.

Quote: When it's complete and correct, check the performance. If the program lumbers, make it fast and small. Don't optimize until you know you need to (Code Complete).

A final note. As an octopus, hiding on the ocean floor is something to optimize for. In C# programs, optimizations to reduce allocations and reduce logical tests are more effective.

Home

The Dev Codes

.Net

.NET Array Dictionary List String 2D Async DataTable Dates DateTime Enum File For Foreach Format IEnumerable If IndexOf Lambda LINQ Parse Path Process Property Regex Replace Sort Split Static StringBuilder Substring Switch Tuple

Java

Core Array ArrayList HashMap String 2D Cast Character Console Deque Duplicates File For Format HashSet If IndexOf Lambda Math ParseInt Process Random Regex Replace Sort Split StringBuilder Substring Switch Vector While

TheDeveloperBlog.com

C# Optimization

Related Links:

.Net

Java

Related Links