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
}
|
Anil Singh is an author, tech blogger, and software programmer. Book writing, tech blogging is something do extra and Anil love doing it. For more detail, kindly refer to this link..
|