The 6.0 release of C# contained many features that improve productivity for developers. Features in this release include:
è
You can
create read-only auto-properties that can be set only in constructors.
è
You can write
initialization expressions to set the initial value of an auto-property.
è
You can author one-line
methods using lambda expressions.
4. using static:
è
You can import all the
methods of a single class into the current namespace.
è
You can concisely and
safely access members of an object while still checking for null with the null
conditional operator.
è
You can write string
formatting expressions using inline expressions instead of positional
arguments.
è
You can catch
expressions based on properties of the exception or other program state.
è
You can let the compiler
generate string representations of symbols.
è
You can use await expressions in locations that previously disallowed them.
10. index
initializers:
è
You can author
initialization expressions for associative containers as well as sequence
containers.
è
Collection initializers
can rely on accessible extension methods, in addition to member methods.
è
Some constructs that
previously generated ambiguous method calls now resolve correctly.
Explaination:
Explaination:
Auto-Property Initializers:
C# 6.0 came with a new concept of initializing class properties inline rather than initializing them within the type's constructor. Another handy technique is, if you want to make the setter of a property private to block users from setting value in the property by an instance, you can just declare a getter only property. For example:
Before C# 6
Hide Copy Code
using static System.Console;
namespace NewInCSharp
{
class Program
{
static void Main(string[] args)
{
Employee employee = new Employee();
WriteLine("Name: " +
employee.Name + "\nSalary: " + employee.Salary);
ReadKey();
}
public class Employee
{
public string Name { get; set; }
public decimal Salary { get; set; }
public Employee()
{
/* Initializing property through constructor */
Name = "Sammy Jenkins";
Salary = 10000;
}
}
}
}
In C# 6.0
Hide Copy Code
using static System.Console;
namespace NewInCSharp
{
class Program
{
static void Main(string[] args)
{
Employee employee = new Employee();
WriteLine("Name: " +
employee.Name + "\nSalary: " + employee.Salary);
ReadKey();
}
public class Employee
{
/* Getter only property with inline initialization */
public string Name { get; } = "Sammy Jenkins"
/* Property with inline initialization */
public decimal Salary { get; set; } = 10000;
}
}
}
Dictionary Initializers:
C# 6.0 changed the way you can initialize
Dictionary. Previously on C# 5, you would have to initialize the Dictionary with this type of syntax, {"Key", "Value"}. Now in C# 6, you can just place the key between two curly brackets ["Key"] and then set the value of the key ["Key"] = "value"; , just like you set the value for other types of variable. This new syntax is friendlier than before.Before C# 6
Hide Copy Code
using System.Collections.Generic;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
Dictionary<string, string="">
alien = new Dictionary<string, string="">()
{
{"Name", "Fizzy"},
{"Planet", "Kepler-452b"}
};
foreach (KeyValuePair<string, string=""> keyValuePair in alien)
{
WriteLine(keyValuePair.Key + ": " +
keyValuePair.Value + "\n");
}
ReadLine();
}
}
}
In C# 6.0
Hide Copy Code
using System.Collections.Generic;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
/* The new and friendly syntax */
Dictionary<string, string=""> alien = new Dictionary<string, string="">()
{
["Name"] = "Fizzy",
["Planet"] = "Kepler-452b"
};
foreach (KeyValuePair<string, string=""> keyValuePair in alien)
{
WriteLine(keyValuePair.Key + ": " + keyValuePair.Value + "\n");
}
ReadLine();
}
}
}
Expression Bodied Function & Property:
You can now write functions and computed properties like lamda expressions to save extra headache of defining function and property statement block. Just use the lambda operator
=> and then start writing your code that goes into your function/property body. Here is a simple example:
Hide Copy Code
using static System.Console;
namespace NewInCSharp
{
internal class Program
{
private static void Main(string[] args)
{
double x = 1.618;
double y = 3.142;
WriteLine(AddNumbers(x, y));
ReadLine();
}
/* Expression bodied function */
private static double AddNumbers(double x, double y) => x + y;
}
}
For expression bodied property:
Hide Copy Code
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
Person person = new Person();
WriteLine("I'm " + person.FullName);
ReadLine();
}
public class Person
{
public string FirstName { get; } = "Fiyaz";
public string LastName { get; } = "Hasan";
/* Expression bodied computed property */
public string FullName => FirstName + " " + LastName;
}
}
}
Static Types as using:
So, we are all quite familiar with this notion of accessing
static class members using the qualification first. It is not required now. Importing static using can save the day. For example, before C# 6.0, we had to access ReadKey(), WriteLine() methods of the Console class by explicitly defining the static class qualifier.
Hide Copy Code
using System;
namespace NewInCSharp
{
class Program
{
static void Main(string[] args)
{
MySelf.WhoAmI();
Console.ReadKey();
}
}
static class MySelf
{
public static void WhoAmI()
{
Console.WriteLine("I'm Fizz!");
}
}
}
In C# 6.0, we can get rid of the qualifiers just by importing the
static types in the namespace like below:
Hide Copy Code
using static System.Console;
using static NewInCSharp.MySelf; /* Magic happens here */
namespace NewInCSharp
{
class Program
{
static void Main(string[] args)
{
WhoAmI();
ReadKey();
}
}
static class MySelf
{
public static void WhoAmI()
{
WriteLine("I'm Fizz!");
}
}
}
Null Conditional Operator & Null Propagation:
Again, we have this new notion of
null conditional operator where you can remove declaring a conditional branch to check to see if an instance of an object is null or not with this new ?. ?? null conditional operator syntax. The ?. is used to check if an instance is null or not, if it's not null then execute the code after ?. but if it is not, then execute code after ??. Check out the example below:Before C# 6.0
Hide Copy Code
using System;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
SuperHero hero = new SuperHero();
if (hero.SuperPower == String.Empty)
{
hero = null;
}
/* old syntax of checking if an instance is null or not */
WriteLine(hero != null ? hero.SuperPower : "You aint a super hero.");
ReadLine();
}
}
public class SuperHero
{
public string SuperPower { get; set; } = "";
}
}
In C# 6.0
Hide Copy Code
using System;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
SuperHero hero = new SuperHero();
if (hero.SuperPower == String.Empty)
{
hero = null;
}
/* New null conditional operator */
WriteLine(hero?.SuperPower ?? "You aint a super hero.");
ReadLine();
}
}
public class SuperHero
{
public string SuperPower { get; set; } = "";
}
}
Again checking a list instance if it is
null or not and then accessing its index is also somewhat similar.
Hide Shrink 
Copy Code
Copy Codeusing System;
using System.Collections.Generic;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
List<superhero> superHeroes = null;
SuperHero hero = new SuperHero();
if (hero.SuperPower != String.Empty)
{
superHeroes = new List<superhero>();
superHeroes.Add(hero);
}
WriteLine(superHeroes?[0].SuperPower ?? "There is no such thing as super heros.");
ReadLine();
}
}
public class SuperHero
{
public string SuperPower { get; set; } = "";
}
}
What if you want to invoke an event/delegate after checking if the handler function is
null or not? Well, the null checking syntax would be like in the example below. It is also known as null propagation.Before C# 6.0
Hide Shrink Copy Code
Copy Codeusing System;
using System.Collections.Generic;
using System.ComponentModel;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
Movie movie = new Movie();
movie.Title = "The Shawshank Redemption";
movie.Rating = 9.3;
WriteLine("Title: "+ movie.Title + "\nRating: " + movie.Rating);
ReadLine();
}
}
public class Movie : INotifyPropertyChanged
{
public string Title { get; set; }
public double Rating { get; set; }
public event PropertyChangedEventHandler PropertyChanged;
protected void OnPropertyChanged(string name)
{
PropertyChangedEventHandler handler = PropertyChanged;
/* Old syntax of checking if a handler is null or not */
if (handler != null)
{
handler(this, new PropertyChangedEventArgs(name));
}
}
}
}
In C# 6.0
Hide Shrink Copy Code
Copy Codeusing System;
using System.Collections.Generic;
using System.ComponentModel;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
Movie movie = new Movie();
movie.Title = "The Shawshank Redemption";
movie.Rating = 9.3;
WriteLine("Title: "+ movie.Title + "\nRating: " + movie.Rating);
ReadLine();
}
}
public class Movie : INotifyPropertyChanged
{
public string Title { get; set; }
public double Rating { get; set; }
public event PropertyChangedEventHandler PropertyChanged;
protected void OnPropertyChanged(string name)
{
PropertyChangedEventHandler handler = PropertyChanged;
/* Null propagation syntax */
handler?.Invoke(this, new PropertyChangedEventArgs(name));
}
}
}
String Interpolation:
You can now forget using placeholders in
strings to replace them with real values. C# 6 has a new feature called string interpolation using which you can now directly write your arguments instead of referring them with placeholders inside a string. You can also do whatever you would have done previously with String.Format() function.Before C# 6.0
Hide Copy Code
using System;
using System.Collections.Generic;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
string name = "Murphy Cooper";
string planet = "Cooper Station";
WriteLine("{0} is actually named after {1}", planet, name);
ReadLine();
}
}
}
After C# 6.0
Hide Copy Code
using System;
using System.Collections.Generic;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
string name = "Murphy Cooper";
string planet = "Cooper Station";
/* Magic happens here */
WriteLine($"{planet} is actually named after {name}");
ReadLine();
}
}
}
Again, these are a few
string formatting examples which I missed in the video. [Check the video link at the bottom of the article.]
Hide Copy Code
string name = "Sammy Jenkins";
double salary = 1000;
WriteLine($"{name}'s monthly salary is {salary:C2}");
WriteLine($"Man! This {name} is kind of a
{(salary >= 1000 ? "rich guy" : "poor guy")}");
/*Output:
Sammy Jenkins's monthly salary is $1000.00
Man! This Sammy Jenkins is kind of a rich guy
*/
Exception Filtering:
Exception filtering is nothing but some condition attached to the
catch block. Execution of the catch block depends on this condition. Let me give you a simple example.
In C# 5, we would have done something like the code given below to show users appropriate messages depending on the randomly generated http status codes.
Hide Shrink Copy Code
Copy Codeusing System;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
Random random = new Random();
var randomExceptions = random.Next(400, 405);
WriteLine("Generated exception: " + randomExceptions);
Write("Exception type: ");
try
{
throw new Exception(randomExceptions.ToString());
}
catch (Exception ex)
{
if(ex.Message.Equals("400"))
Write("Bad Request");
else if (ex.Message.Equals("401"))
Write("Unauthorized");
else if (ex.Message.Equals("402"))
Write("Payment Required");
else if (ex.Message.Equals("403"))
Write("Forbidden");
else if (ex.Message.Equals("404"))
Write("Not Found");
}
ReadLine();
}
}
}
Here, I'm randomly generating an exception code
randomExceptions. Inside the catch block, I'm showing the appropriate error message respective to the exception code.
Now you can achieve the same thing using exception filtering but the syntax is a bit different. Rather than entering the
catch block and checking to see which condition met our exception, we can now decide if we even want to enter the specific catch block. Here is the code:
Hide Shrink Copy Code
Copy Codeusing System;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
Random random = new Random();
var randomExceptions = random.Next(400, 405);
WriteLine("Generated exception: " + randomExceptions);
Write("Exception type: ");
try
{
throw new Exception(randomExceptions.ToString());
}
catch (Exception ex) when (ex.Message.Equals("400"))
{
Write("Bad Request");
ReadLine();
}
catch (Exception ex) when (ex.Message.Equals("401"))
{
Write("Unauthorized");
ReadLine();
}
catch (Exception ex) when (ex.Message.Equals("402"))
{
Write("Payment Required");
ReadLine();
}
catch (Exception ex) when (ex.Message.Equals("403"))
{
Write("Forbidden");
ReadLine();
}
catch (Exception ex) when (ex.Message.Equals("404"))
{
Write("Not Found");
ReadLine();
}
}
}
}
So, what's the main difference between these two. Well when you enter a
catch block, the current execution state is lost. So, the actual cause of the exception is really hard to find. But in the exception filtering, we stay where we should be staying, i.e., current execution state. This means the stack stays unharmed.
So, exception filtering is good, right? Well there is a catch! Since in the exception filtering, entering a
catch block depends on the filter applied on the catch, making a silly mistake can change the whole meaning of the exception. This may actually happen cause the filtering depends on a boolean result and this boolean result can be sent from any code block, making the exception have a different meaning. For example:
Hide Shrink Copy Code
Copy Codeusing System;
using System.Net.Http;
using System.Threading.Tasks;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
Task.Factory.StartNew(GetWeather);
ReadLine();
}
private static async void GetWeather()
{
string customErrorMessage;
HttpClient client = new HttpClient();
try
{
HttpResponseMessage httpResponseMessage =
await client.GetAsync
("http://api.openweathemap.org/data/2.5/weather?q=NewYorK");
WriteLine(httpResponseMessage);
}
catch (Exception ex) when
(DoASillyMistake(ex.Message, out customErrorMessage))
{
WriteLine(customErrorMessage);
}
}
private static bool DoASillyMistake
(string exceptionMessage, out string customErrorMessage)
{
if (exceptionMessage.Equals
("An error occurred while sending the request."))
{
customErrorMessage = "Unauthorized.";
return true;
}
else
{
customErrorMessage = "Bad Gateway.";
return true;
}
}
}
}
This is a silly example I must say, but let's assume that if a request to a weather service fails, it's because of two reasons, one the service is not up and running
[Bad Request] and the second is a user needs to be authorized before accessing the service [Unauthorized]. So, in my code, I know for sure that the HttpClient will throw an error message like below if it's a Bad Request.
Hide Copy Code
"An error occurred while sending the request."
Again for any other error messages, let's assume it's an
Unauthorized request. If you look carefully at the DoASillyMistake(string exceptionMessage, out string customErrorMessage) function, you will see I really did a silly mistake. I've shown the user that they are 'Unauthorized' to access the service while the message should be 'Bad Request' since the service url is not valid [there is a letter is missing in the url; 'r' to complete the word weather]. Now the funny and bit irritating part is that the user will now start looking for a registration process to get access to the service. But sadly, we all know that is not the case. The funnier part is even if he registered himself, from now he will get a 'Bad Request'. So, you must be careful when using exception filtering.
But even this side effect can sometimes come in handy. For example, you can attach a filter function which logs error messages and returns
false so that the log contains an appropriate exception and also the execution cursor doesn't end up in the catch block. Here is a good example from that I found in this open source .NET git repo documentation, New Language Features in C# 6.
Hide Copy Code
Hide Copy Code
private static bool Log(Exception e) { /* log it */ ; return false; }
....
try { .... } catch (Exception e) when (Log(e)) {}
nameof expression:
Next one is the
nameof expression. In enterprise level applications, lines of code run like a mad horse. So there is no means of avoiding exception handling where it is necessary. Showing a specific type name with an error message can be a quick way to find the code block where the exception just occurred. But we should also consider refactoring issues. We cannot just simply append a hard coded type name string with an error message and show it to the user because the type name can be changed anytime while refactoring but hard coded string won't change accordingly. So C# 6.0 introduced this concept of nameof expression. A simple example would be like this:Before C# 6
Hide Shrink Copy Code
Copy Codeusing System;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
try
{
CallSomething();
}
catch (Exception exception)
{
WriteLine(exception.Message);
}
ReadKey();
}
private static void CallSomething()
{
int? x = null;
if (x == null)
{
throw new Exception("x is null");
/* x is the type name. What if someone changes the
type name from x to i? The exception below would be inappropriate. */
}
}
}
}
class Program
{
private static void Main(string[] args)
{
try
{
CallSomething();
}
catch (Exception exception)
{
WriteLine(exception.Message);
}
ReadKey();
}
private static void CallSomething()
{
int? x = null;
if (x == null)
{
throw new Exception("x is null");
}
}
}
In C# 6.0
Hide Shrink Copy Code
Copy Codeusing System;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
try
{
CallSomething();
}
catch (Exception exception)
{
WriteLine(exception.Message);
}
ReadKey();
}
private static void CallSomething()
{
int? number = null;
if (number == null)
{
throw new Exception(nameof(number) + " is null");
}
}
}
}
Await in catch/finally Block:
I think many of you were waiting for this feature in C# where you can write asynchronous code inside
catch and finally block. Well, now you can do that.
Hide Shrink Copy Code
Copy Codeusing System;
using System.Net.Http;
using System.Threading.Tasks;
using static System.Console;
namespace NewInCSharp
{
class Program
{
private static void Main(string[] args)
{
Task.Factory.StartNew(() => GetWeather());
ReadKey();
}
private async static Task GetWeather()
{
HttpClient client = new HttpClient();
try
{
var result = await client.GetStringAsync
("http://api.openweathermap.org/data/2.5/weather?q=Dhaka,bd");
WriteLine(result);
}
catch (Exception exception)
{
try
{
/* If the first request throws an exception,
this request will be executed.
Both are asynchronous request to a weather service*/
var result = await client.GetStringAsync
("http://api.openweathermap.org/data/2.5/weather?q=NewYork,us");
WriteLine(result);
}
catch (Exception)
{
throw;
}
}
}
}
}
Refferences:
https://www.codeproject.com/Tips/1023426/Whats-New-in-Csharp
