This document discusses new features in C# 6 that simplify and clarify code. It provides examples of features like auto property initialization, dictionary initialization, string interpolation using $, nameof method, exception filters, and async/await in error handling. The document also mentions how to configure builds for the C# 6 language version and debugging improvements in Visual Studio 2015 like PerfTips and live code analysis.

1. C# 6 Peek into the future
How to Simplify and Clarify your code
Tome Tomovski

2. Introduction
• Author
– Microsoft Certified Trainer, Engineer, Consultant
– Main fields: Banking, Telecommunication,
Oil & Gas and Industrial IT
•

3. Is it a revolution?
• C# 2.0 and 3.0 (.NET 2.0/3.5)
• Introduction to generics and way to program collections with LINQ
• C# 4.0 (.NET 4.0)
• Named and Optional Parameters, Dynamic support, COM Interop
• C# 5.0 (.NET 4.5)
• Simplification of asynchronous programming patterns
• C# 6.0 (.NET 4.6/5)
• Simply changes the way we write C# code

4. Peek into C# 6.0 Features

5. • Auto property initialization
• Dictionary initialization
• String interpolation ($ sign)
• Using Static syntax
• nameof method
• Exception filters
• Lambda expression debugging
• Async / await in error handling
• Null conditional operator
New Features

6. Configure Build for language version

7. Auto Property Initialization
• Before:
• If we had to provide default value for properties => initialize the
properties in the constructor of that class.
• Now:
– Auto property initializer
public class Student
{
///
/// Default constructor to initialize
/// properties
public Student1()
{
this.Id = 1;
this.Name = "John";
this.Grade = "A++";
this.JoiningDate = DateTime.Now.Date;
}
public int Id { get; set; }
public string Name { get; set; }
public string Grade { get; set; }
public DateTime JoiningDate { get; set; }
}

8. Dictionary Initialization
• Before:
• Initializing Dictionary collection with double curly braces
• Confusing for most C# developers
• Now:
– New format which is much easier to read

9. String Interpolation ($ sign)
• Before:
• Used placeholder {0}, {1}, and then replacing these placeholder values
with actual values
• Now:
– Directly user variable or even expression instead of using placeholders

10. Using static syntax
• Before:
• Had to put qualifying type name before accessing the static member
• Now:
– Import all static member of type (class)

11. nameof Method
• Before:
• … not existent
• Now:
– To return the name of any program element
– When we want to use the name of any programming element to raise
an event that uses name of some element.

12. Exception filter
• Now:
– Enable conditional execution of catch block
– Different catch block for each specific condition

13. Async / await in error handling
• Now:
– Await functionality in error handling
– If any operation performs operation
in try block then catch and finally
block wait for the operation to be
completed and then we may
perform asynchronous operation in
catch and finally block.
– Ex: Log exceptions in a DB without
blocking the current thread.

14. Lambda expression debugging
• Now:
– Still under development
– Expression debugging when working with LINQ and lambda
expressions
– Native functions as LINQ-to-SQL still not supported

15. Universal Windows apps

16. Debugging and Diagnostics
• PerfTips
• Display the execution time of methods during debugging
• Quickly spot bottlenecks
• Error List
– Supports filtering on any column
– Live view of errors, warnings and code analysis
• GPU Usage Tool
– Helps to troubleshoot whether performance bottlenecks are
originating in the CPU or GPU.

17. Live code analysis (light bulbs)
• New C# compiler
• Rich and customizable feedback and suggestions directly inside
the code editor as you type.

18. Blend in and rock
• Blend for Visual Studio 2015 comes with several enhancements:
•
•
•
•
•
•

19. Application Insights
•
•

20. Code understanding
•
•
•

21. Code understanding
•
•
•