Tuesday, October 6, 2015

C# : What is New in C# 6.0?


New features in C#6.0
In this post we will see the newly added features in C# 6.0. In C# 6.0 some very cool features has been added like "Auto-property Enhancements", "Primary Constructors", "Expressions as Function Body", "Use of Static", "Exception Filters", "inline declarations", "nameof Expressions", "Null-conditional Operators", "String interpolation", "Await in catch and finally".





Introduction

Here, you will find nine new cool features of C# 6.0:

  1. Auto-property Enhancements
  2. Parameters on Classes and Structs
  3. Using Static
  4. Exception Filters
  5. Null-conditional Operators
  6. Index Initializers
  7. $ sign
  8. String Interpolation
  9. nameof Expression
  10. Await in catch and finally block
  1. Auto-property Enhancements

    You can initialize the properties in the same way as you initialize variables, fields.
    public class Employee
    {
    public string FirstName { get; set; } = "Pankaj";
    public string LastName { get; set; } = "Maurya";
    }
    
  2. Parameters on Classes and Structs

    You can pass the parameter to the classes/structs in the same way as you do with the methods/functions.
    public class Employee(string firstName, string lastName)
    {
    public string FirstName { get; set; } = firstName;
    public string LastName { get; set; } = lastName;
    }
    
    You can also add the logic on parameters as:
    public class Employee(string firstName, string lastName)
    {
    if (Equals(firstName,null))
    {throw new ArgumentNullException("firstName");}
    if (Equals(lastName,null))
    {throw new ArgumentNullException("lastName");}
    public string FirstName { get; } = firstName;
    public string LastName { get; } = lastName;
    }
    
  3. Using Static

    In C# 6.0, Microsoft announced a new behaviour to our CS compiler that allows us to call all the static methods from the static class without the name of the classes.
    Code in C# 5.0
    static void Main(string[] args)
    {
        Console.WriteLine("Enter first number :");
        int num1 = Convert.ToInt32(Console.ReadLine());
        Console.WriteLine("Enter second number :");
        int num2 = Convert.ToInt32(Console.ReadLine());
        Console.WriteLine("Multiplication : {0}", (num1 * num2));
        Console.ReadLine();
    }
    
    Code in C# 6.0
    using static System.Console;
    using static System.Convert;
    
    public class UsingStaticTest
    {
           static void Main(string[] args) 
           { 
                WriteLine("Enter first number :"); 
                int num1 = ToInt32(ReadLine()); 
                WriteLine("Enter second number :"); 
                int num2 = ToInt32(ReadLine()); 
                WriteLine("Multiplication : {0}", (num1 * num2)); 
                ReadLine(); 
            } 
    }
    
    
  4. Exception Filters

    With this new feature, you can add conditional logic to catch block that decide which catch block will execute based on condition.
    try
    {
    throw new Exception("Pankaj");
    }
    catch (Exception ex) if (ex.Message == "Pankaj")
    {
    // this will execute because exception message matches.
    }
    catch (Exception ex) if (ex.Message == "Maurya")
    {
    // this will not execute because exception message does not match
    }
    
  5. Null-conditional Operators

    The Null-Conditional operator is a new concept in C# 6.0 that automatically checks with null references. In previous version C# 5.0, if we are accessing any property of a class, then first we check the object of class with null and if not null, then reading the property but in C# 6.0, you can do the same with "?" operator.
    Code in C# 5.0
    namespace ConditionalTest
    {  
        class Program  
        {  
           static void Main()  
            {  
                Employee emp = new Employee(){ 
                FullName = "Pankaj Maurya",  
                EmpAddress = new Address()  
                {  
                    ResidenceAddress = "New Ashok Nagar",  
                    OfficeAddress = "Udyog Vihar Pahse 2"  
                }
              } 
                if(emp!= null && emp.EmpAddress!=null)     
                {
                 WriteLine((emp.FullName) + "  " + (emp.EmpAddress.ResidenceAddress??"No Address")); 
                } 
                ReadLine();  
            }  
        }  
        class Employee  
        {  
            public string FullName { get; set; }  
            public Address EmpAddress { get; set; }  
        }  
        class Address  
        {  
            public string ResidenceAddress { get; set; }  
            public string OfficeAddress { get; set; }  
        }  
    }   
    
    Code in C# 6.0
    namespace ConditionalTest
    {  
        class Program  
        {  
           static void Main()  
            {  
                Employee emp = new Employee(){  
                FullName = "Pankaj Maurya", 
                EmpAddress = new Address()  
                {  
                    HomeAddress = "New Ashok Nagar",  
                    OfficeAddress = "Udyog Vihar Pahse 2"  
                }
                }            
                WriteLine((emp?.FullName) + "  " + (emp?.EmpAddress?.ResidenceAddress??"No Address")); 
                ReadLine();  
            }  
        }  
        class Employee  
        {  
            public string FullName { get; set; }  
            public Address EmpAddress { get; set; }  
        }  
        class Address  
        {  
            public string ResidenceAddress { get; set; }  
            public string OfficeAddress { get; set; }  
        }  
    }   
    
  6. Index Initializers

    C# 6.0 introduces new syntax to initialize index based collections.
    Code in C# 5.0
    var persons = new Dictionary {
    { 3, "Pankaj" },
    { 4, "Manish" },
    { 6, "Anand" }
    };
    
    Code in C# 6.0
    var persons = new Dictionary {
    [3] = "Pankaj",
    [4] = "Manish",
    [6] = "Anand"
    };
    
  7. $ Sign

    C# introduces new to initialize and access index objects.
    var persons = new Dictionary()
    {
    // using inside the intializer
    $first = "Pankaj"
    };
    
    //Assign value to member
    
    //in C# 5.0 
    persons["first"] = "Pankaj";
    
    // in C# 6.0
    persons.$first = "Pankaj";
    
  8. String Interpolation

    Before C# 6.0, if we need to format strings, then we used String.Format() method, which is taking an input string filling placeholders with indexes and then providing an array of values which is plotted in the string with their respective indexes. Let us suppose an Employee class has two properties, FirstName and LastName and we have to put the FullName then generally we are using it like:
    string FullName = String.Format("{0} {1}",FirstName,LastName);
    
    In C# 6.0, a new feature String Interpolation (use $ to format string) is added which provides the formatting of string with the source of parameter value itself.
    string FullName = $"{FirstName} {LastName}";
    
  9. nameof Expression

    Before C# 6.0, when we need to use a property, function or a data member name into a message as a string, so we need to use the name as hard-coded in “name” in the string and in the future if my property or method's name changed, so we have to change all the messages in every form or every page.

    To resolve this issue, C# 6.0 introduces nameof as new keyword which will return string literal of the name of property or a method.
    Code in C# 5.0
    namespace NameOfTest
    {  
        class Program  
        {  
            static void Main(string[] args)  
            {  
                Employee emp = new Employee();  
                WriteLine("{0} : {1}", "EmpCode", emp.EmpCode);  
                WriteLine("{0} : {1}", "EmpName", emp.EmpName);            
                ReadLine();  
            }  
        }  
        class Employee  
        {  
            public int EmpCode{ get; set; } = 101;  
            public string EmpName { get; set; } = "Pankaj"; 
           
        }  
    }   
    
    Code in C# 6.0
    namespace NameOfTest
    {  
        class Program  
        {  
            static void Main(string[] args)  
            {  
                Employee emp = new Employee();  
                WriteLine("{0} : {1}", nameof(Employee.EmpCode), emp.EmpCode);  
                WriteLine("{0} : {1}", nameof(Employee.EmpName), emp.EmpName);            
                ReadLine();  
            }  
        }  
        class Employee  
        {  
            public int EmpCode{ get; set; } = 101;  
            public string EmpName { get; set; } = "Pankaj"; 
           
        }  
    }
    
  10. Await in Catch and Finally Block

    Let's suppose a situation where we need to call an async method and there is a try and a catch{} block, so when the exception occurs, it is thrown in the catch{} bock. We need to write log information into a file or send a service call to send exception details to the server so call the asynchronous method, this is only possible in C# 6.0 by using await in catch{} block.
    namespace AwaitCatchTest
    {    
        public class CustomMath
        {  
            public async void DivisionWrapper(int num1, int num2)  
            {  
                try  
                {  
                    int res = num1/ num2;  
                    WriteLine("Division : {0}", res);  
                }  
                catch (Exception ex)  
                {  
                    await asyncMethodForCatch();  
                }  
                finally  
                {  
                    await asyncMethodForFinally();  
                }  
            }  
            private async Task asyncMethodForCatch()  
            {  
                WriteLine("Method from async Catch !!");  
            }
            private async Task asyncMethodForFinally()
            {
                WriteLine("Method from async finally !!");
            }
        }  
    }
    
Happy reading!!

No comments:

Post a Comment

If You Enjoyed This Post Please Take 5 Seconds To Share It.

^ Scroll to Top hgpromo