A package of C# life savers

• The bad news
  • High performance doesn't just happen!
  • We have to design them that way!
  • Thus most performance is lost very early
  • Most designs consider performance too late in dev
• The good news
  • Most (~95%) of our application is not performance critical
  • Generally it is easy to identify the critical sections

1. Cherry: Lambda expressions
2. Raspberry: Asynchronous patterns
3. Orange: Potential optimizations
4. Pineapple: Best practices
5. Watermelon: Some tricks

• With LINQ they are everywhere (very comfortable)
• They improve code maintenance and reliability
• More possibilities than anonymous methods (Expression)
• Also shorter to write than anonymous methods:

  Func<double, double> g = delegate (double x) { return x * x; };
  Func<double, double> f = x => x * x;
  

• Another good usage: closure (compiler generates a class for us)

• Scenario: map user input to a function
• Usually this is done by using a switch statement
• Sometimes a Dictionary gives us more flexibility:

  var functions = new Dictionary<string, Func<double, double>>();
  void Init() {
  	functions.Add("sin", Math.Sin); 
  	functions.Add("cos", Math.Cos); /* and others */
  }
  public double Evaluate(string f, double x) {
  	//Let's just assume that the specified function exists
  	return functions[f](x);
  }
  

• Communication with the SynchronizationContext
• The closure handles everything for us:

  var ctx = SynchronizationContext.Current ?? new SynchronizationContext();
  public event EventHandler<MyEventArgs> Event;
  public void RaiseEvent() {
  	if(Event != null)
  		ctx.Post(o => Event(this, new MyEventArgs(a1, ..., an)), null);
  }
  

• No casts and no parameter (passed null) required

• Callback pattern (e.g. events, ...)
• Returning functions (e.g. closures, ...)
• Init-time branching (e.g. handlers, ...)
• Self-defining functions (e.g. state-machine, ...)

class Greeter {
	public Greeter() {
		SayHello = () => {
			SayHello = () => {
				SayHello = () => {
					return "Stop it for God's sake!"
				};
				return "I already said hello!";
			};
			return "Hello";
		};
	}
	public Func<string> SayHello { get; private set; }
}

• Using async. APIs is the key for responsive apps
• Key question: CPU or IO bound?
• IO bound tasks are attacked by callbacks
• CPU bound tasks are attacked by multi-threading
• The TPL covers both scenarios with Task
• C# 5 introduces async / await

// A usual (non-async) method
int ComputeNumber() {
	return 42;
}
// Decorate method as being async - will be wrapped automatically
async Task<int> ComputeNumberAsync() {
	return 42;
}
// Can be used as always
var answer = ComputeNumberAsync().Result;
// Or with await
var answer = await ComputeNumberAsync();
// Important: No new thread or similar has been created previously
var answer = await Task.Run(ComputeNumber);

• Always prefer using async Methods if available
• Always return Task or Task<T>
• Only return void in case of event handlers
• Do not use Task.Run in case of memory bound methods
• Use ConfigureAwait(false) for creating APIs
• Build async. methods using the TaskCompletionSource

// Creating extension methods like this
public static async Task WhenClicked(this Button button) {
	var tcs = new TaskCompletionSource<bool>();
	RoutedEventHandler ev = (sender, evt) => tcs.TrySetResult(true);
	//This is a perfect async. code, no other thread required
	try {
		button.Click += ev;
		await tcs.Task;
	} finally {
		button.Click -= ev;
	}
}
// Using them
await button.WhenClicked();

• Detect the code's hot path
• Don't optimize unimportant aspects
• Maintain readability where possible
• Use a good profiler for analysis
• Look at MSIL for details
• Use micro-benchmarks for comparisons
• Build caches only with discard policy

• CPU, managed memory and blocked time investigation
• Investigate performance hotspots
• Can be used to make an analysis of any process
• Logs data and presents the data
• Is able to show potential bottlenecks
• Uses ETW (Event-Tracing for Windows) kernel routine
• Additionally we could also use tools like VMMap

• Use (and read!) integrated help
• Select right process(es) with at least 2000 stack dumps
• Always look at right data (e.g. Metric/msec ≥ 0.5)
• Look at significant time range
• The call-tree gives us a nice top-down approach
• For bottom-up we would use the by-name tab

• Boxing
• Strings and string manipulation
• Iterators
• Delegates and lambdas
• Collections (Dictionary, ConcurrentDictionary, etc.)
• IDisposable guard objects
• EventHandler

public class Logger {
	public static void WriteLine(string s) { /*...*/ }
}
public class BoxingExample {
	public void Log(int id, int size) {
		var s = string.Format("{0}:{1}", id, size);
		Logger.WriteLine(s);
	}
}

Compiler selects string.Format(string, object, object).

public class BoxingExample {
	public void Log(int id, int size) {
		var s = string.Format("{0}:{1}", id.ToString(), size.ToString());
		Logger.WriteLine(s);
	}
}

public class Logger {
	public static void WriteLine(string s) { /*...*/ }
}
public class BoxingExample {
	public void Log(int id, int size) {
		var s = id.ToString() + ':' + size.ToString();
		Logger.WriteLine(s);
	}
}

Compiled to string.Concat(object, object, object).

public class BoxingExample {
	public void Log(int id, int size) {
		var s = id.ToString() + ":" + size.ToString();
		Logger.WriteLine(s);
	}
}

public enum Color {
	Red, Green, Blue
}
public class BoxingExample {
	string name;
	Color color;
	public override int GetHashCode() {
		return name.GetHashCode() ^ color.GetHashCode();
	}
}

The enum value is boxed - use (int)color before calling GetHashCode.

class Symbol {
	public string Name { get; private set; }
	/*...*/
}
class Compiler {
	List<Symbol> symbols;
	public Symbol FindMatchingSymbol(string name) {
		return symbols.FirstOrDefault(s => s.Name == name);
	}
}

class Compiler {
	List<Symbol> symbols;
	public Symbol FindMatchingSymbol(string name) {
		Func<Symbol, bool> predicate = s => s.Name == name;
		IEnumerable<Symbol> enumerable = symbols;
		IEnumerator<Symbol> enumerator = enumerable.GetEnumerator();
		while(enumerator.MoveNext()) {
			if (predicate(enumerator.Current))
				return enumerator.Current;
		}
		return default(Symbol);
	}
}

class Compiler {
	List<Symbol> symbols;
	public Symbol FindMatchingSymbol(string name) {
		foreach (Symbol s in symbols) {
			if (s.Name == name)
				return s;
		}
		return null;
	}
}

• Try to minimize creation of new instances
• Use structures for small temp. objects
• Prefer static methods where possible
• The same applies to fields
• Create permanent objects before temporary ones

• Class allocations put pressure on the GC
• They also require memory and computing time
• Use same principle as with StringBuilder
• Try to minimize (re-) allocations
• For really small objects prefer struct

string[] lines = text.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
int numLines = lines.Length; bool skipSpace = true;
if (lines[0].TrimStart().StartsWith("///")) {
	for (int i = 0; i < numLines; i++) {
		string trimmed = lines[i].TrimStart();
		if (trimmed.Length < 4 || !char.IsWhiteSpace(trimmed[3])) {
			skipSpace = false;
			break;
		}
	}
	int substringStart = skipSpace ? 4 : 3;
	for (int i = 0; i < numLines; i++)
		WriteLine(lines[i].TrimStart().Substring(substringStart));
} else { /* ... */ }

int IndexOfFirstNonWhiteSpaceChar(string text, int start) {
	while (start < text.Length && char.IsWhiteSpace(text[start]))
		start++;
	return start;
}
bool TrimmedStringStartsWith(string text, int start, string prefix) {
	start = IndexOfFirstNonWhiteSpaceChar(text, start);
	int len = text.Length - start;
	if (len < prefix.Length) return false;
	for (int i = 0; i < len; i++) {
		if (prefix[i] != text[start + i]) return false;
	}
	return true;
}
// etc...

• Any class needs at least 12 bytes (x86)
• Classes smaller than 16 bytes are more efficiently handled as struct
• Structures should not contain more than 64 bytes in data
• Watch out for repeated calls to property getters that return a struct
• Try to avoid boxing (will be put on the heap then)

• Generics reduce casts
• They also improve type safety
• Less casts is less boxing / unboxing
• The hidden cost is the type transportation
• But: e.g. List<string> is faster than StringCollection
• In most cases using the generic version is better

BitmapImage m_bmp;
protected override async void OnNavigatedTo(NavigationEventArgs e) {
	base.OnNavigatedTo(e);
	await PlayIntroSoundAsync();
	image1.Source = m_bmp;
	Canvas.SetLeft(image1, Window.Current.Bounds.Width - m_bmp.PixelWidth);
}
protected override async void LoadState(Object nav, Dictionary<String, Object> pageState) {
	m_bmp = new BitmapImage();
	var file = await StorageFile.GetFileFromApplicationUriAsync("...");
	using (var stream = await file.OpenReadAsync())
		await m_bmp.SetSourceAsync(stream);
}

Task<BitmapImage> m_bmpTask;
protected override async void OnNavigatedTo(NavigationEventArgs e) {
	base.OnNavigatedTo(e);
	await PlayIntroSoundAsync();
	var bmp = await m_bmpTask;
	image1.Source = bmp;
	Canvas.SetLeft(image1, Window.Current.Bounds.Width - bmp.PixelWidth);
}
protected override void LoadState(/* ... */) {
	m_bmpTask = LoadBitmapAsync();
}
async Task<BitmapImage> LoadBitmapAsync() {
	var bmp = new BitmapImage(); /* ... */ return bmp;
}

try {
	await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
	{
		await LoadAsync();
		m_Result = "done";
		throw new Exception();
	});
} catch (Exception) {
	/* will not be entered */
} finally {
	DebugPrint(m_Result);
}

• Everything seems alright
• LoadAsync is invoked
• But we skip the catch block
• Reason: No async overload
• Therefore the rest is fire-and-forget
• Fire-and-forget does not throw exceptions

[StructLayout(LayoutKind.Explicit, Pack = 1)]
struct Number {
	[FieldOffset(0)]
	public int Value;
	[FieldOffset(0)]
	public byte First;
	[FieldOffset(1)]
	public byte Second;
	[FieldOffset(2)]
	public byte Third;
	[FieldOffset(3)]
	public byte Fourth;
}

• Sealing classes stops inheritance chain
• Sealing only (single) methods or properties also possible

abstract class Mother {
	public abstract void DoSomething();
}
class Daughter {
	public sealed override void DoSomething() { }
}

• Still callvirt instead of call
• However, possibility to stop overriding

WeakEvent<EventHandler> _event = new WeakEvent<EventHandler>();
//Let public event appear normally
public event EventHandler Event {
	add { _event.Add(value); }
	remove { _event.Remove(value); }
}
//Fire over a special method (good practice anyway)
public void RaiseEvent() {
	_event.Raise(this, EventArgs.Empty);
}
//Using it is straight forward:
someClassInstance.Event += MyEventHandler;

• Usually readonly should be preferred
• const has the advantage of allowing switch
• Advantage of readonly: Changes affect external code
• Marking PI as a constant is valid
• Marking some connection string / url as a constant is bad
• Changing the value requires re-compilation of ref. assemblies

[Flags]
enum MyBitFlag { /* ... */ }
[DebuggerStepThrough]
void MyShortHelper() { /* ... */ }
[Conditional("DEBUG")]
void MyDebuggingHelper() { /* ... */ }
[DebuggerDisplay("FirstName={FirstName}, LastName={LastName}")]
class MyClass { /* ... */ }
[ThreadStatic]
static StringBuilder cachedStringBuilder;

• Never pass in strings as property names
• Use the CallerMemberName attribute
• Alternatively use an Expression
• First one is shorter to write
• Second one is more flexible

static string GetName([CallerMemberName] string name = null) {
	return name ?? string.Empty;
}

Contact me any time ...

• Web: florian-rappl.de
• eMail: mail@florian-rappl.de
• Google+: gplus.to/FlorianRappl

• Find the presentation at talks.florian-rappl.de/LifeSavers.