This document discusses performance tuning of .NET applications. It begins by defining performance tuning as improving system performance. It then discusses identifying bottlenecks through profiling, such as by using dotTrace and dotMemory tools. Various ways to optimize performance are covered, such as choosing appropriate collections, making applications parallel as needed, and managing memory efficiently by reducing allocation and using value types and IDisposable patterns. The document aims to provide guidance on optimizing .NET applications through measurement and profiling.

1. Performance Tuning of
.NET application
Md. Mainul Islam
Software Engineer, SELISE
mainul098@mail.com

2. ✓ What is Performance Tuning?
✓ How to profile performance?
✓ Identify hotspot bottlenecks
✓ Ways to optimize .NET Application.
Why Are We Here?

3. Lets Explore

4. “Performance tuning is the improvement of
system performance”

5. Your app
Reality of Performance
You

6. Where is the Bottleneck?
for (int n = 2; n < 10000; ++n)
{
bool prime = true;
for (int d = 2; d < n; ++d)
{
if (n % d == 0)
{
prime = false;
break;
}
}
if (prime) Console.WriteLine(n);
}

7. “Premature optimization is the root
of all evil”
- Donald Knuth

8. Mistakes of Performance Tuning
✓ Optimize without a reliable measurement
✓ Optimize without verifying the results
✓ Relying on gut feeling

9. Performance Matrices
CPU
Execution time,
queuing
Memory
Utilization, load %
Disk
Utilization, I/O Operation
Network
Bandwidth, queueing

10. How does it work?
1. Select Application to Profile
2. Start Profiling
3. Collect Data and Detect Bottlenecks
4. Optimize Performance
5. Compare Profiling Results
6. Repeat Until Desired Results (Or
Possible)

11. dotTrace
+
dotMemory

12. Choosing a Collection

13. Dozens of Builtin Collections
✓ List<T>
✓ ArrayList<T>
✓ Dictionary<K,V>
✓ HashSet<T>
✓ Queue<T>
✓ SortedList<K,V>
✓ SortedDictionary<K,V>
✓ SortedSet<T>
✓ Stack<T>
… and more

14. Choose Proper Collection
■ Stop using List<T> for everything
■ Ask yourself:
Do you need to access each element by index?
For zero-based index: Use ArrayList and StringCollection classes and
the List<T> generic class.
For key based index: The Hashtable, SortedList, ListDictionary, and
StringDictionary classes, and the Dictionary<TKey, TValue> and
SortedDictionary<TKey, TValue> generic classes.
Do you need to sort your collection?
The Hashtable class sorts its elements by their hash codes.
The SortedDictionary<TKey, TValue> and SortedList<TKey, TValue> generic
classes sort their elements by the key.

15. Collection - (Contd.)
Do you need to search your collection?
ListDictionary is faster than Hashtable for small collections
(10 items or fewer).
The Dictionary<TKey, TValue> generic class provides faster
lookup than the SortedDictionary<TKey, TValue> generic class.
The multi-threaded implementation is
ConcurrentDictionary<TKey, TValue>. ConcurrentBag<T>
provides fast multi-threaded insertion for unordered data.
Do you need collections that accept only strings?
StringCollection (based on IList) and StringDictionary
(based on IDictionary).

16. Collection Ordering
Direct
Access?
Lookup
Efficiency
Manipulate
Efficiency
Notes
Dictionary Unordered Via Key Key: O(1) O(1) Best for high performance lookups.
SortedDictionary Sorted Via Key Key: O(log n) O(log n)
Compromise of Dictionary speed and
ordering, uses binary search tree.
List Unordered Via Index
Index: O(1)
Value: O(n)
O(n)
Best for smaller lists where direct
access required and no sorting.
SortedList Sorted Via Key Key: O(log n) O(n)
Faster lookup on preloaded data, but
slower loads.
LinkedList Unordered No Key: O(n) O(1)
Best for lists where inserting/deleting in
middle is common and no direct access
required.
HashSet Unordered Via Key Key: O(1) O(1)
Unique unordered collection, like a
Dictionary except key and value are
same object.

17. Make your Application as Parallel as
Necessary, But not More

18. Kind of Parallelism
Parallelism
✓ Running multiple threads in parallel
✓ .NET 4.0 provide “Task Parallel Library(TPL)” to
simplify parallelism
✓ But, Threads are expensive - context switch, lock
Asynchrony
✓ Without blocking the caller’s thread
✓ .NET 4.5 introduce async programming

19. Demo

20. Manage Memory Efficiently

21. GC as a Performance Problem
■ The .NET GC is non-deterministic
✓ Contributes unexpecteds, potentially very
long delays that destroy responsiveness.
✓ No way to anticipate the delay or react to
it.

22. There’s no GC if you don’t allocate.
Reducing allocation is key to
reducing GC costs.

23. Reducing Allocation
✓ Use value types
✓ Pool large objects (such as buffers)
✓ Avoid allocation large temporary objects

24. Use IDisposable
✓ Finalize is expensive.
✓ Dispose the object that is not needed.
✓ GC does not call Dispose() for you. It’s
your duty to call it.

25. Demo

26. Going Further
✓ Making .NET Application Faster
✓ Making .NET Application Even Faster
✓ IDisposable Best Practices for C# Developers
✓ Entity Framework Database Performance Anti-Pattern
✓ Measuring .NET Performance
✓ .NET Performance Optimization and Profiling with JetBrains
dotTrace
✓ http://geekswithblogs.
net/BlackRabbitCoder/archive/2011/06/16/c.net-
fundamentals-choosing-the-right-collection-class.aspx
✓ https://msdn.microsoft.com/en-us/library/dd460717(v=vs.
100).aspx

27. THANKS
Any questions?
You can find me at
✓ @mainul098
✓ mainul098@mail.com