A brief introduction to the new features of C# 6

A few weeks ago I read in various places about some new features of C#6. I decided to collect them all together so that if you haven't read them yet, you can go through them all at once. Some of them may not be as magical as expected, but that's just the update for now.

　You can get them by downloading VS2014 or installing the Roslyn package for visual studio2013 here.

　So let’s take a look:

　1. The role of $identifier

　$ is to simplify string indexing. It is different from the dynamic nature of indexing in C# which uses regular expression matching internally. An example is as follows:

var col = new Dictionary<string, string>()
            {
                $first = "Hassan"
            };
 
   //Assign value to member
   //the old way:
   col.$first = "Hassan";
 
   //the new way:
   col["first"] = "Hassan";

　2. Exception filter

　Exception filter has been supported in the VB compiler for a long time, and now C# also supports it. Exception filters allow developers to create a catch block for a certain condition. The code in the catch block will only be executed when the condition is met. This is one of my favorite features. An example is as follows:

try
            {
                throw new Exception("Me");
            }
            catch (Exception ex) if (ex.Message == "You")

　3. await keyword in catch and finally blocks

As far as I know, no one knows The reason why the await keyword is unavailable in the catch and finally code blocks in C# 5 is that it is unavailable no matter how it is written. This is good because developers often want to view the I/O operation log, and in order to record the captured exception information into the log, this needs to be done asynchronously.

try
            {
                DoSomething();
            }
            catch (Exception)
            {
                await LogService.LogAsync(ex);
            }

　4. Declare expression

　This feature allows developers to define a variable in an expression. This is simple but practical. In the past, I used asp.net to build many websites. Here is the code I commonly use:

long id;
if (!long.TryParse(Request.QureyString["Id"], out id))
{ }

Optimized code:

if (!long.TryParse(Request.QureyString["Id"], out long id))
{ }

The scope of variables in this declaration method is the same as the scope of variables declared in C# in the normal way. the same.

　5. Use of Static

　This feature allows you to specify a specific type in a using statement, and then all static members of this type can be used in subsequent clauses.

using System.Console;
 
namespace ConsoleApplication10
{
    class Program
    {
        static void Main(string[] args)
        {
            //Use writeLine method of Console class
            //Without specifying the class name
            WriteLine("Hellow World");
        }
    }
}

　6. Attributes Auto-initialization:

　 C# 6 auto-comforts properties like fields at declaration locations. The only thing you need to know here is that this initialization will not cause the setter method to be called internally. The background field value is set directly. The following is an example:

public class Person
    {
        // You can use this feature on both
        //getter only and setter / getter only properties
 
        public string FirstName { get; set; } = "Hassan";
        public string LastName { get; } = "Hashemi";
    }

　7. Main constructor:

　Hahaha, main constructor The constructor will help you eliminate the pain of getting the constructor parameters and setting them into the fields of the class to support subsequent operations. This is really useful. The main purpose of this feature is to use constructor parameters for initialization. When the main constructor is declared, all other constructors need to use :this() to call this main constructor.

Finally the following example:

//this is the primary constructor:
    class Person(string firstName, string lastName)
    {
        public string FirstName { get; set; } = firstName;
        public string LastName  { get; } = lastName;
    }

Note that the main constructor is called at the top of the class .