python ruby-programming-language Smalltalk Vue.js Knockoutjs TypeScript JavaScript, OOPs JavaScript Angular 8,7,6,5,4 and 2 Interview Questions and Answers Angular 8,7,6,5,4 and 2 Interview Questions and Answers Angular 4 Angular 2 AngularJs 1.x NodeJs Perl Programming R Programming RequireJs Rust Programming Backbonejs closure programming language go-programming-language kotlin-programming-language
A Glimpse of the future in the C# 8.0!

A Glimpse of the future in the C#, What's New in C# 8.0 Features?

Today, I happy to share the some selected and important feature proposals for C# 8.0 which are introduce in the below -
ü  Extension Everything
ü  Default Implementation on Interfaces
ü  Nullable Reference Types
ü  Preventing Assignment from Nullable to Non-Nullable

Some Are Proposed Features will available on future -
ü  Default interface methods
ü  Support for virtual extension methods
ü  Overrides in interfaces
ü  Reabstraction
ü  Static and private methods
ü  Base interface invocations
ü  CLR support API
ü  Abstract Override

These all are available in the Future Release.

Extension Everything - I hope you are familiar with an extension method which was introduced in C# 3.0.

Extension method is a static method to the existing static class. Extension methods enable you to add methods to the existing types without modifying the original type.

Let’s try to understand “Extension everything” using the below examples i.e.

Previous code looks like –
public static class IntExtensions
{
   public static bool EvenNum(this int i)
   {
        return i % 2 == 0;
   }
}

Now with Extension its looks like –
public extension IntExtension extends int
{
    public bool EvenNum => this % 2 == 0;
}

Now the code would be able to use the property normally –
int i = int.Parse(Console.Readline());
if (i.Even)
{
    Console.WriteLine("You have interd an even number.");
}

2 - Default Implementation on Interfaces –
Let’s try to understand “Default Implementation on Interfaces” using the below examples i.e.
interface IDisplayInfo
{
    void DisplayInfo(string message) { WriteLine(message); }
}

Nullable Reference Types - Suppose we have a “User” class with an “Age” property of type “int.” Then, we write the following methods.

In the C# 8.0 promises to change that by making reference types non-nullable by default.

Examples –
//If you want “u” to be nullable.
public int CalculateAgeOfUser(User? u)
{
    int age = u.Age;
    return age * age;
}


//If you want “u” could be null.
public int CalculateAgeOfUser(User p)
{
    int age = u.Age;
    return age * age;
}

//Now that “u” can be null, trying to access Age which is not safe.
public int CalculateAgeOfUser(User? u)
{
    var result = 0;
    if (u != null)
        result = u.Age * u.Age;

    return result;
}

//The “u” cannot possibly be null and will leave you alone.
public int CalculateAgeOfUser(Person? u)
{
    int age = u?.Age ?? 0;
    return age * age;
}


Preventing Assignment from Nullable to Non-Nullable –

//Its looks like.
string? nullableStr = "Hello, I am Anil";
string nonNullableStr = nullableStr;


//Using the string.IsNullOrEmpty() method
//The below code will generate a warning message, despite it not being possible for "name" to be null.
public void User(string? name)
{
     if (!name.IsNullOrEmpty())
     {
          var length = name.Length;
     }
}

//Keep in my mind when you using this operator, you are basically telling the compiler - "Trust me! I know what I'm doing".”
public void User(string? name)
{
     if (!name.IsNullOrEmpty())
     {
          var length = name!.Length;
     }
}


Some Proposed features will available on future -
ü  Default interface methods
ü  Support for virtual extension methods
ü  Overrides in interfaces
ü  Reabstraction
ü  Static and private methods
ü  Base interface invocations
ü  CLR support API
ü  Abstract Override

Some of Examples over the proposed features and its looks like -

- Overrides in interfaces
interface ICountry
{
    void GetCountry() {
        WriteLine("ICountry.GetCountry");
    }
}

interface IState : ICountry
{
    override void ICountry.GetCountry() {
         WriteLine("IState.GetCountry");
    } //explicitly named
}

interface ICity : ICountry
{
    override void GetCountry() {
        WriteLine("ICity.GetCountry");
    } // implicitly named
}

- Reabstraction

interface ICountry
{
    void Method() { WriteLine("ICountry.Method"); }
}
interface IState : ICountry
{
    override abstract void Method();
}
class City : IState { } // Got an Error - class 'City' does not implement 'ICountry.Method'.

-  Abstract Override

//The above example has ability to "reabstract" an inherited method.
interface ICountry
{
    void Method();
}
interface IState : ICountry
{
    override void Method() { }
}
interface ICity : IState
{
    override void Method(); // make it abstract again
}

I hope you are enjoying with this post! Please share with you friends!! Thank you!!!
ANIL SINGH

Hi there! Welcome to my blog. My name is Anil Singh. I'm a author of this blog. For more detail about me, kindly refer to this link..
My Blogs - http://code-sample.com and http://code-sample.xyz
My Books - Interview Questions and Answers Books- Get Your Book in 15+ Digital Stores Worldwide..

You Might Also Like
www.code-sample.com/. Powered by Blogger.
ASK Questions