Changes presented in C# 6.0 are not particularly exceptional, however, the main goal in this version was to simplify your code, so most of the new features are intended to provide more intuitive syntax.<\/p>\n\n\n\n
All new features of C# 6 require the C# 6.0 compiler but it\u2019s important to notice that all of them don\u2019t require any specific version .NET Framework \u2013 because all features are implemented in the compiler and don\u2019t depend on .NET Framework.<\/p>\n\n\n\n
Prior to C# 6 for initializing immutable properties we had to use private readonly fields. This solution ensures proper access to those properties but with many properties there is lot of irrelevant code lines. The other way was to create properties with private setter however it makes properties mutable for methods within the class. C# 6 introduce new feature to solve that issue in a simple way \u2013 we can declare a property with only getter and initialize it in the constructor.
Furthermore C# 6 allows to initialize properties directly within their declaration, the same way as fields. Initializers can be any expression (but not using this).<\/p>\n\n\n\n
Example:<\/p>\n\n\n
\npublic class A\n{\npublic string X { get; } = \"valueOfX\";\npublic DateTime StartDay { get; } = DateTime.Today;\n}\n<\/pre><\/div>\n\n\nNull-Conditional Operator<\/h2>\n\n\n\n
Every .NET developer knows the NullReferenceException which is usually result of not sufficient null checking before invoking a member on that object. Let\u2019s consider this example:<\/p>\n\n\n
\nif (personList != null)\n{\nPerson first = personList[0];\nint count = personList.Count;\n}\n<\/pre><\/div>\n\n\nThe null checking is required, otherwise the NullReferenceException would be thrown. C# 6 allows to write it much more simple with new feature.<\/p>\n\n\n
\nPerson first = personList?[0]; \/\/ null if customers is null\nint? nullableCount = personList?.Count; \/\/ null if customers is null\nint count = personList?.Count ?? 0; \/\/ 0 if customers is null\n<\/pre><\/div>\n\n\nThe null-conditional operator returns null for null-value.
But what happens when the null-conditional operator appears within a call chain? Consider the example:<\/p>\n\n\n
\nvar dob = person?.DateOfBirth?.ToString();\n<\/pre><\/div>\n\n\nIt seems that since person?.DateOfBirth? just returns null there should be a NullReferenceException thrown, but this situation is handled with the language behavior that returns null immediately, without attempting execution further instruction, with no exceptions. This is a concept known as null-propagation.
What about a data type for the result of null-conditional? For example a data type for someValue?.Length \u2013 we can\u2019t use int. Attempting to assign it to int will results with compile error. In that case really handy are nullable types.<\/p>\n\n\n
\nint? length = person?.Name?.Length;\n<\/pre><\/div>\n\n\nBut we can also use the null-coallescing operator at the end of expression:
var count = post?.Tags?.Count ?? 0;<\/p>\n\n\n
\nint length = person?.Name?.Length ?? 0;\n<\/pre><\/div>\n\n\nExpression Bodied Methods and Auto-Properties<\/h2>\n\n\n\n
Expression bodied functions and auto-properties are implemented with an expression following the function declaration instead of statement body. To assign the expression use the arrow operator (=>). This simplified implementation can be used for methods with or without parameters. The same way we can implement read-only (getter only) properties \u2013 called expression bodied properties.<\/p>\n\n\n
\npublic TimeSpan Age => DateTime.Now \u2013 DateOfBirth;\npublic override string ToString() => string.Format("{0} is {1} old.", Name, Age);\n<\/pre><\/div>\n\n\nDictionary initializers<\/h2>\n\n\n\n
Prior to C# 6.0 the common method for initializing and filling Dictionary includes the {key, value} syntax. This is easy to implement for simple objects but when we have more complex object with nested structures might be not very clear and it\u2019s easy to lose track of all those curly brackets.
In C# 6 there is an improvement of dictionary assignment, using index-based syntax. The data types of key-value pairs are corresponding to the types declared for the dictionary.<\/p>\n\n\n
\nvar peopleDict = new Dictionary<string, Person>;\n{\n["mike"] = new Person("Mike Smith", 28),\n["lilly"] = new Person("Lilly Potter", 25)\n};\n<\/pre><\/div>\n\n\nString Interpolation<\/h2>\n\n\n\n
To display strings combined in one composite string we used string.Format() method. Probably any .NET developer struggled with that when there are many strings to put together. This is not easy to read or validate. The placeholders and parameters must be in proper order.<\/p>\n\n\n
\nstring.Format(\"{0} {1} was born {2} and now is {3}.\", FirstName, LastName, DateOfBirth, Age);\n<\/pre><\/div>\n\n\nIn C# 6 there is new alternative approach to composite formatting. The result of string.Format() we can obtain using string literal prefixed with a \u201c$\u201d and each argument within curly brackets.<\/p>\n\n\n
\n$\"{FirstName} {LastName} was born {DateOfBirth} and now is {Age}.\";\n<\/pre><\/div>\n\n\nThe string interpolation syntax prevent from disordered or missing arguments errors. Compiler transforms it into string.Format() so in effect there are no changes (eg. Localization). That means also that we can use options from original method defining format of an argument or use an expression.<\/p>\n\n\n
\nstring s = $\"It is now {DateTime.Now:d} at {DateTime.Now:t}\";\n<\/pre><\/div>\n\n\nUsing static<\/strong><\/h2>\n\n\n\nAnother feature simplifying C# code is using static. Prior to C# 6 there was possible to use only namespaces in the using directive but with this feature you can use type of static class. Therefore you can gain access to static members of type without prefix of the type name \u2013 you can invoke them directly.<\/p>\n\n\n
\n\/\/prior to C# 6\nvar result = Math.Sqrt(Math.Abs(x) * Math.Pow(y, 2) + z * Math.PI);\n\/\/C# 6\nvar result = Sqrt(Abs(x) * Pow(y, 2) + z * PI);\n<\/pre><\/div>\n\n\nWith using static you can restrict access to extension methods to single class unlike using namespace \u2013 when all of extension methods from this namespace are available.
Enums can also be called that way. It is very useful if the names of enum items are understandable and clear without type prefix.<\/p>\n\n\n
\nusing static System.ConsoleKey;\n\/\/\u2026\nswitch (keypressed)\n{\ncase A:\nbreak;\ncase B:\nbreak;\n}\n<\/pre><\/div>\n\n\nWhat about aliases to namespace? For example char \u2013 to use this type it\u2019s required to write full namespace, in this case System.Char.<\/p>\n\n\n
\nusing static char; \/\/Error\nusing static System.Char; \/\/Correct\n<\/pre><\/div>\n\n\nBe careful with using static though \u2013 in situation when you specify using static for types that have a member with the same name \u2013 to distinguish them it\u2019s required to add prefix of the type name while invoking them.<\/p>\n\n\n
\nusing static System.IO.Directory;\nusing static System.IO.File;\n\/\/\u2026\nif (!Exists(filename)) \/\/ ERROR: The call is ambiguous between the following methods or properties: 'Directory.Exists(string)' and 'File.Exists(string)'\n{\nthrow new ArgumentException(\"The file does not exist.\", nameof(filename));\n}\n<\/pre><\/div>\n\n\nThis feature was added to simplifying your code and make it more readable, but when the context is not obvious and using static could lead to confusion you probably shouldn\u2019t use it. It\u2019s best to limit number of the using static directives to just a few classes which you use frequently.<\/p>\n\n\n\n
The nameof Operator<\/strong><\/h2>\n\n\n\nAs the name of this feature suggests \u2013 operator nameof returns the name of any item like class, method, property or parameter. When the fully qualified identifier is passed as parameter to nameof() it will return just the final identifier (last part). This feature protects from runtime errors caused by misspellings and also works with renaming tools. nameof(someFancyParameterName) will return someFancyParameterName.<\/p>\n\n\n\n
Exception Improvements<\/strong><\/h2>\n\n\n\nPrior to C# 6 the exception filtering was only possible on the type level but now there was introduced the \u201cwhen\u201d clause to do more accurate filtering for exceptions. After a catch() you can now add an extra condition.<\/p>\n\n\n
\ntry\n{\nthrow new Exception(\"My exception\");\n}\ncatch (Exception ex) when (ex.Message == \"My exception\")\n{\nConsole.WriteLine(\"My exception caught\");\n}\ncatch (Exception ex)\n{\nConsole.WriteLine(\"Other exception caught here\");\n}\n<\/pre><\/div>\n\n