New Features of C sharp 6.0

 

1 Auto Property Initializer

Auto property is not the new feature but this was there from C sharp 3.0 onwards.

Drawbacks

We cannot initialize the backing field during object initialization, But you can initialize explicitly in constructors.

Example:

Output:

In the above example you can see FirstName and LastName were Auto - Implemented properties, and the values  initialized during constructor call.

But with C sharp 6.0

---

public class AutoPropertyInitializer

    {

        public string FirstName { get; set; } =  "Uday";

        public string LastName { get; } = "Kumar";

        //public string FullName { get; } = this.FirstName + this.LastName;

        public string FullName { get; }

        public AutoPropertyInitializer()

        {

            this.FullName = this.FirstName + " " + this.LastName;

        }

    }​

---

The FirstName and LastName were initialized directly after the declaration. You can notice the LastName were made readonly by not mentioning the setter. The backing field produced for a readonly property is also a readonly variable.

The FullName though it is  initialized inside constructor as the object initialization works before the constructor call, and hence initialization cannot evaluate "this".

2 Static Class Uses:

If we want to print something we use Console.WriteLine. Why can I use only WriteLine ?  instead of Console.WriteLine. Static class uses does the same thing. Static class uses also recognize extension methods, hence if say a static class defines extension methods, if you add it, it will automatically recognize the extension methods as well.

But with C sharp 6.0

---

using static System.Console;

using static System.Linq.Enumerable;

    public class UseStatic

    {

        public void CallMe()

        {

            WriteLine("Hi");  //Console.WriteLine

            var range = Range(10, 10);   //From the namespace Linq.Enumerable

            var check = range.Where(e => e > 13);

            // Static extension method can

            // only be called with fulll representation

        }

    }

---

In the above code the WriteLine is automatically detected as we added the head using static statement. The static uses automatically recognized the extension methods as well.

If you look at the internals of the static uses, the compiler rewrites the static type calls on every occurrences of its method call.

In the actual IL, you can see, the WriteLine is padded with its appropriate type Console and Range is also associated with Enumerable. The re-writing is done by the compiler.

3 Null conditional operators

For developers Enemy exception are NullReferenceException or "Object reference not set to instance of an object" is one of the most common exception. For this developer need to check the null value before calling any member functions. Null for compiler is unknown, and hence if you call a method on null, it will point nowhere and hence throws NullReferenceException and exists the stack.

Microsoft already introducted Null coalesce operator (??) or Conditional operators.

string name = (student == null? null : student.name);

In the first statement the student is checked with null and when it has student, it will only then evaluate the name.

string postalcode = (student == null? null : (student.address == null ? null : student.address.postalcode))

On the second statement, the student object is checked with null, then its address and then finally the postalcode is evaluated.

But with C sharp 6.0

---

string name = student?.name;

string postalcode = student?.address?. postalcode;

Here code is reduced but the actual logic remains the same. The ? mark is used for null conditioning. Null conditional operators does not exists as well, it is the same representation as that of the previous conditional operators.

Note: You can see the null conditional operators are replaced by the compiler with normal conditional statements.

4 Exception Filters

In C# the exception block contains try/catch/finally with multiple catch blocks supported. Based on type of the exception that has been encountered during runtime, the runtime chooses the appropriate catch block to execute.

But with C sharp 6.0

Exception filters it allows  you to filter out the catch blocks to ensure which catch block can handle the exception. With exception filters in place, there could be multiple catch blocks with same type where the type determines which filter it will call first.

Let us take a look at the code :

public class ExceptionFilters

    {

        public static bool LogException(Exception ex)

        {

            //Log

            return false;

        }

        public static bool LogAgainException(Exception ex)

        {

            //Log

            return true;

        }

        public void CallMe()

        {

            try

            {

                throw new ArgumentException("Exception");

            }

            catch (Exception ex) when (LogException(ex))

            {

                //Keep exception stack intact

            }

            catch(Exception ex) when (LogAgainException(ex))

            {

                // Calling the catch

            }

        }

    }

Here the ArgumentException is thrown when CallMe is invoked. So the execution is like, it will call LogException method, executes the code and see whether the return statement is true or false. If it is true, it executes the catch block and exit, or otherwise it move and call LogAgainException method.

The exception filter expects a boolean value, hence the call to LogException should be a method returning bool.

5 nameof Operator

But with C sharp 6.0

---

Here the compiler determines the name of a Property, Function or an Extension method and writes it directly in compiled output. For instance,

string name1 = nameof(this.MyProp); // evaluates MyProp

string name2 = nameof(DateTime.Now);//evaluates Now

string name3 = nameof(Console.WriteLine); //evaluates WriteLine

string name4 = nameof(new List<string>().FirstOrDefault); // Evaluates FirstOrDefault

string name5 = nameof(name4); //Evaluates name4

The nameof operator works on any type where the type has a name. In case you specify a variable, the nameof operator will evaluate to the name of the variable.

6 Dictionary initializers

var dict = new Dictionary<int,string>();

dict.Add(0, "Uday");

dict.Add(1, "Kumar");

//Access

var first = dict[0];

var second = dict[1];

In C# 6.0, you can define dictionary using the following syntax :

var dict = new Dictionary<int,string>

{

   [10] = "Uday",

   [20] = "Kumar"

};

//Access

var first = dict[10];

var second = dict[20];

Or even if the key is declared as string, you can also use like:

var dict = new Dictionary<string,string>

{

   ["first"] = "uday",

   ["second"] = "Kumar"

};

//Access

var first = dict["first"];

var second = dict["second"];

This way it is very easier to declare and use dictionaries. The last two syntaxes were introduced in C# 6.0.

---