C# 6.0 introduces several new features including auto-properties with initializers that allow properties to be initialized without requiring a backing field, string interpolation for easier string formatting, a null conditional operator that short-circuits null checks, expression-bodied functions for more concise single-line methods, index initializers for initializing dictionaries during construction, exception filters for filtering exceptions based on their content, and the ability to await in catch and finally blocks. These features aim to reduce code verbosity and make C# code more readable and maintainable.

1. C# 6.0
The new stuff
Chris Skardon
@cskardon | chris@tournr.com

2. The haps
• Auto-properties
• String Interpolation
• Null Conditional Operator
• Expression-bodied functions
• using static
• nameof
• Index Initializers
• Exception filters
• await in catch/finally

3. Auto properties

4. Auto Properties
• Woah! That’s C# 3.0, bad start Chris, bad start
public int AutoProperty { get; set; }
• Auto properties++
• Added Initializers
• Backing fields are actually readonly

5. public class AutoProperties
{
public int SetInConstructorNoNeedForSet { get; }
public AutoProperties(int value)
{
SetInConstructorNoNeedForSet = value;
}
}
public string ReadonlyProperty { get; } = "I'm Readonly!";
Examples!
public DateTime NotJustConsts { get; } = DateTime.Now;
public int UsingLambda => 1 + 2;

6. Why?
• To save code
• To get actual readonly Properties
• Without the need to use backing fields

7. String Interpolation

8. String Interpolation
• Inline string expression handling
$"{X}"

9. Examples!
const string name = "Chris";
string oldWay = string.Format("Hello {0}", name);
string newWay = $"Hello {name}";

10. Why?
• Again – save code
• Easier to read
• Helps with the introduction of new content in a
string
• Don’t have to re-order string.Format arguments

11. Null Conditional Operator

12. Null Conditional Operator
• Looks for Null before continuing execution
• Short-Circuit behaviour
?.

13. Examples!
public static int GetLength(string value)
{
if(value == null)
return -1;
return value.Length;
}
public static int GetLength(string value)
{
return ?? -1;
}
value?.Length

14. Why?
• Remove cumbersome null checks
• Multiple null checks in one line
if (user != null)
{
if (user.FirstName != null)
{
return user.FirstName.Length;
}
}
user?.FirstName?.Length

15. Expression-bodied functions

16. Expression-bodied functions
• Single line methods don’t need all the gubbins

17. Examples!
public static int GetLength(string value)
{
return value?.Length ?? -1;
}
public int GetLength(string value) => value?.Length ?? -1;

18. Why?
• Code size
• Simplifies ‘one-liners’

19. using static

20. using static
• Are you fed up of typing ‘Math.’?
• Of course you are!

21. Examples!
using static System.Math;
Console.WriteLine(Abs(10-12));
WriteLine(Abs(10-12));
using static System.Console;
Console.WriteLine(Math.Abs(10-12));

22. Why?
• If you’re doing a lot of ‘Console.’ or ‘Math.’
it can make the code nicer

23. nameof

24. nameof
• Gets the name of a given
field/property/argument

25. Examples!
public void ThrowIf(string value)
{
if(string.IsNullOrWhiteSpace(value))
throw new ArgumentException("Value can't be empty or null!", nameof(value));
}
public static class Config
{
public static class Email
{
public static string To => $"{nameof(Email)}.{nameof(To)}";
}
}
ConfigurationManager.AppSettings[Config.Email.To].Value;
ConfigurationManager.AppSettings["Email.To"].Value;

26. Why?
• Refactoring argument names / class names
• Messages no longer out of sync
• Particularly good for ArgumentException instances
• Config using strong types

27. Index Initializers

28. Index Initializers
• Allow you to set the values in the construction
of a Dictionary by key.

29. Examples!
var x = new Dictionary<object, object>
{
[1] = "one",
["ten"] = 10
};
var x = new Dictionary<int, string>
{
[1] = "one",
[10] = "ten"
};

30. Exception Filters

31. Exception Filters
• We’ve been able to filter on Exception types
forever
• Now we can filter by the content of those
exceptions

32. Examples!
try
{
throw new ArgumentNullException("arg1");
}
catch (ArgumentNullException e) when (e.ParamName == "arg1")
{
Console.WriteLine("Caught Arg1");
}
catch (ArgumentNullException e)
{
Console.WriteLine($"Caught {e.ParamName}");
}

33. Why?
• To filter out conditions you can safely retry
with
• To abuse and do logging with exceptions:
catch (ArgumentNullException e) when (Log(e))
{
Console.WriteLine("Caught Arg1");
}

34. await in catch/finally

35. await in catch/finally
• Pretty self explanatory
• In C#5.0 you couldn’t use ‘await’ in a
catch/finally block
• Now you can!

36. Examples!
try
{
throw new ArgumentNullException("arg1");
}
catch (ArgumentNullException e)
{
await LogAsync(e);
}

37. Why?
• So you don’t have non-async code in your fully
async work!

38. The End.
Questions?
@cskardon | chris@tournr.com