I can refactor this code (popular as/null check
pattern)
var a = b as MyType;
if(a != null) { ... }
..into a nice "is" type pattern expression:
if(b is MyType a) { ... }
..which is cool... I think... Is it?
But now I am also thinking to refactor
var a = SomeMethod();
if(a != null) { ... }
..into:
if(SomMethod() is MyType a) { ... }
Note: there is no as
and SomeMethod() already returns MyType. It looks like (pseudocode) if(A is A)
and may easily confuse, no?
The first refactoring is legal, but what about the latter one? I am not an IL expert to check myself and C# 7.0 features are still new to me. Perhaps there are problems which I didn't discover yet?
In C#, IsNullOrEmpty() is a string method. It is used to check whether the specified string is null or an Empty string. A string will be null if it has not been assigned a value. A string will be empty if it is assigned “” or String.
Any() is an extension method that throws ArgumentNullException if the source is null.
So, to overcome such types of exception C# provides is operator. The is operator is used to check if the run-time type of an object is compatible with the given type or not. It returns true if the given object is of the same type otherwise, return false. It also returns false for null objects.
Pattern matching is a technique where you test an expression to determine if it has certain characteristics. C# pattern matching provides more concise syntax for testing expressions and taking action when an expression matches.
Obviously the 2 implementations are very similar, the difference would be negligible in memory, allocations, and cycles.
The compiler basically treats them as follows (for reference types)
First
MyType myType = SomeMethod();
if (myType != null)
{
Console.WriteLine(myType.ToString());
}
Second
MyType myType2;
if ((object)(myType2 = SomeMethod()) != null)
{
Console.WriteLine(myType2.ToString());
}
Probably better seen with the IL
First
IL_0000: ldarg.0
IL_0001: call instance class C/MyType C::SomeMethod()
IL_0006: stloc.0
IL_0007: ldloc.0
IL_0008: brfalse.s IL_0015
IL_000a: ldloc.0
IL_000b: callvirt instance string[mscorlib] System.Object::ToString()
IL_0010: call void[mscorlib] System.Console::WriteLine(string)
Second
IL_0015: ldarg.0
IL_0016: call instance class C/MyType C::SomeMethod()
IL_001b: dup
IL_001c: stloc.1
IL_001d: brfalse.s IL_002a
IL_001f: ldloc.1
IL_0020: callvirt instance string[mscorlib] System.Object::ToString()
IL_0025: call void[mscorlib] System.Console::WriteLine(string)
Note : You can check out the disassembly, IL and jit-asm here
The IL difference is basically 2 opcodes:
dup
: Copies the current topmost value on the evaluation stack, and then pushes the copy onto the evaluation stack.Ldloc
: Loads the local variable at a specific index onto the evaluation stack.When Jitted, it would most likely optimize into the same instructions anyway
Summary
is
version is a bit neater and a little more succinct I guess.If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With