Enable Javascript

Please enable Javascript to view website properly

Toll Free 1800 889 7020

Looking for an Expert Development Team? Take two weeks Trial! Try Now

New Improvements in C#6

In this article, I would like to mention some new functionalities that became available with VS 2015. At the same time as Microsoft launched the new VS version, Microsoft also launched the latest version of c# that Microsoft included in the new build (version 14).

Experts working with .Net Development Company have explained new enhancements made in C#6 via this article post. If you are a .net developer and want to upgrade your skills, this post is for you. Read the complete article and brush up on your C#6 skills. For some, changes to a new version of C# may be of little value, as they are few and difficult for junior developers. But for the old .NET users, these improvements will save a lot of time and provide much more flexibility in the day-to-day development. Also, a big effort was given to the new compiler for the .NET that is "Roslyn".

Strings interpolation

In the new c#, it becomes possible to interpolate strings the same way as in the ECMAScript 6. In my opinion, these technologies each time are getting closer. You will be able now to insert text directly in the string. Same as the string.Format() method, but now the work will be done natively in a very optimized way. Let’s take a look at both examples:

<code> string test = string.Format("my name is {0}", p.Name); </code> <code> string test = $"my name is {p.Name}"; </code>

So, in my opinion, it will be a very beneficial feature and will save many .NET applications from errors that can be generated by using string.Format() method.

Usage of expressions in Method members

First, I would like to mention the new way of using lambda expressions in methods parameters and the scope. With the new version of the language, it is now possible to use expressions similar to lambda expressions to define methods in just one statement or block. The developer describing their body using lambda arrows could declare methods:

<code> public Coordinates Go(int a, int b) => new Coordinates(x + a, y + d); </code> <code> public static Special operator +(Special x, Special y) => x.Add(y); </code> The result is the same as if methods had only return instruction. The examples above are converted by the compiler into following code: <code> public Coordinates Go(int a, int b){ return new Coordinates(x + a, y + d); } </code> <code> public static Special operator +(Special x, Special y){ return x.Add(y); } </code>

In the cases when methods don’t have a return (void type), these functionalities still are valid, but the expression has to be built in the way of instruction:

<code> public void Digitalize() => Console.WriteLine("Digitalizing" + Data); </code> The expression body format could also be used to define properties and read-only indexers: <code> public string Description => Operation + " " + Date; </code> <code> public Car this[int idNumber] => stock.LookupStock(idNumber); </code>

New way to reference libraries

The same as happening with “using” (importing external libraries) for namespaces, the “using static” can reference static members of a class or enums, enabling using such members without specifying the class name.

<code> using static System.Console; class TestProgram { static void Main() { WriteLine(“Using static is working properly”); } } </code>

Let’s suppose that you are working on a big logic file (more than 2000 lines of code) with several methods. And in all of that methods, you use the methods provided by the same external library, so you could save a lot of code and also reduce complexity for those who are going to read your code if you could not specify a class name, like the Console in the example above.

properties in the new fashion

Properties are known as “auto-properties” when they are implemented automatically. It means that they are not abstract and not external. The accessors for that properties are defined using a semicolon. When a property is implemented automatically, the hidden field is created that supports the property and read/write accessors, which is implemented to read and write that field.

In the new version of the language, the initialization of properties declared automatically could be done in the same fashion as the fields are initialized:

<code> public class Car { public string Model { get; set; } = "Sedan"; } </code>

Like in the example above, the initializer will directly fill the value into the field without using a setter for the property, when initializing properties.

Also, one very excellent improvement is that it is now possible to declare read-only properties hiding the accessor responsible for writing, the setter. Let’s take a look at the following example:

<code> public class Car { public string Model { get; } = "Sedan"; } </code>

After the compiler is passed through the code above, it will generate a read-only field implicitly. The other way to initialize read-only properties is using its constructor. Let’s take a look at the following example:

<code> public class Car { public Car(string model) { Model = model; } } </code>

So in that sense, we automatically created the read-only Model field that the only constructor may assign.

Null-conditional operator

Now it becomes possible to reduce the quantity of the code we are writing when checking for the possibility of our variables having a null value. With the introduction of the null conditional operator, we may put “?” before the invocation of a method from any possibly null instance of some class, and the .NET will deal for us with checking the instance of being null and will return the null in the case when it is happening.

<code> // will assign null if client is null long? clientId = client?.Id; // will assign null value if myStringList is null string second = myStringList?[1]; </code>

After the work of the compiler, the code is translated in the following statement:

<code> long? clientId = (client != null) ? new long?(client.Id) : null; string second = (myStringList != null) ? myStringList [0] : null; </code>

Also, one very beneficial way to apply the null-conditional operator is to combine it with the coalesce operator:

<code> long clientId = client?.Id ?? 0; </code>

So, basically, in the example above, if the client is null, the default value to assign will be 0. Developers of ASP.Net Development Company have shared a great post about major enhancements introduced by officials of C#6. You can share your development experience with other readers on this post through comments.

Recent Blogs

Categories

NSS Note
Some of our clients
team