In today's blog post, I will be discussing some of the new features of
C# 6 which I am pretty excited about and will be using in my code soon.
For example,
So by using nameof expression, we don't have to hard code the string id
in our trace statement. We can simply use nameof(id). So in future, if
we decide to change the name of this variable to something else (right
click, Refactor -> Rename), we don't have to worry about updating all
our trace statements throughout our code. The nameof expression will
use the variable name by itself. This will certainly save us time during
refactoring :)
As only get method is exposed, the field becomes read-only. As a result, the underlying backing field automatically becomes read-only. So this makes it more convenient to set the value using auto property initializers.
These null checks just pollute our code base and make it look bulky. Now, with the new null conditional operator, we can simply do this:
This will essentially do the same thing as the code above but now it's simply written in 1 line instead of 4 lines. So if myInteger is null, it will return null without throwing any null reference exception. How cool is that?
With the new string interpolation feature in C# 6, we can create string expressions that look like a template string containing expressions. The expressions are replaced by their ToString() representations of the expression's result. By using the $ escape character we can simply embed the string name inside curly braces.
In my opinion, it's easier to read and follow an interpolated string.
For example,
So as you can see, there are multiple catch blocks here. Since Error Code = 1234 is true, only that catch block gets executed. And finally block gets executed as expected.
For future updates to my weekly blog, please subscribe to my blog via the "Subscribe To Weekly Post" feature at the right.
nameof Expression
So many times, we have to use magic strings within our code which essentially map to program elements. For such cases, nameof expression can be pretty useful to access the name of program element.For example,
public ActionResult Details(int? id)
{
/* some code*/
Employee employee = db.Employees.Find(id);
System.Diagnostics.Trace.WriteLine(String.Format("The value
of variable {0} = {1} is not valid",
nameof(id), id));
/* some code*/
return View(employee);
}
Auto Property Initializers
Earlier, in order to make a field read-only and set some value to the field, we had to use explicit implementation. We used to set the value of read-only defined backing field and initialize it from within the constructor. Now with C# 6.0 we can assign the value of the property from within their declaration. For example,public class Employee
{
public int EmployeeId { get; set; }
public string Department { get; } = "Development";
}
Null Conditional Operator
This is my favorite one and I think I will be using this the most. So many times, we have lots of null checks throughout our code to avoid null reference exceptions. For example,int? myInteger; if (myInteger == null) return null; else return myInteger.ToString();
return myInteger?.ToString();
This will essentially do the same thing as the code above but now it's simply written in 1 line instead of 4 lines. So if myInteger is null, it will return null without throwing any null reference exception. How cool is that?
String Interpolation
I prefer using String.Format for string formatting instead of combining multiple strings using + operator. However, with String.Format() using indexed formatters was somewhat of a pain as my eyes had to go back and forth to see what's the element at zeroth index and first index and so on. As I showed in an example above, String.Format looks like this:String.Format("The value of variable {0} = {1} is not valid",
nameof(id), id)
With the new string interpolation feature in C# 6, we can create string expressions that look like a template string containing expressions. The expressions are replaced by their ToString() representations of the expression's result. By using the $ escape character we can simply embed the string name inside curly braces.
System.Diagnostics.Trace.WriteLine($"The value of variable
{nameof(id)} = {id} is not valid");
Exception Filters
With this new feature, you can specify condition along with the catch block. So the exception will be caught only when the condition is met, otherwise it will be skipped.For example,
string ErrorCode = "1234";
try
{
throw new Exception("User Error");
}
catch (Exception ex) when (ErrorCode == "5678")
{
System.Diagnostics.Trace.WriteLine("Error 5678");
}
catch (Exception ex) when (ErrorCode == "1234")
{
System.Diagnostics.Trace.WriteLine("Error 1234");
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine("Error Unknown");
}
finally
{
System.Diagnostics.Trace.WriteLine("Finally Block");
}
So as you can see, there are multiple catch blocks here. Since Error Code = 1234 is true, only that catch block gets executed. And finally block gets executed as expected.
Conclusion
C# is now sharper than ever ;) (This time its not a bad joke...). These new features will certainly make the language easier to use and make developers more efficient.For future updates to my weekly blog, please subscribe to my blog via the "Subscribe To Weekly Post" feature at the right.
