To make "Assign if variable is not null, otherwise skip" be shorter

[Flithor]

copied from dotnet/csharplang#4147

at present

if(variable != null)
   target = variable;

the current shortest is

target = variable ?? target;

but it still assign one time when variable is null.

Test:

//Code:
target = variable ?? target;
//IL:
//1 ldloc.0
//2 dup
//3 brtrue.s	6 stloc.1 
//4 pop
//5 ldloc.1
//6 stloc.1

//Code:
if (variable != null)
    target = variable;
//IL:
//1 ldloc.0
//2 brfalse.s	5 ldloc.1 
//3 ldloc.0
//4 stloc.1
//5 ldloc.1

consider to make it be shorter and faster?

[PathogenDavid]

As @canton7 noted on your csharplang question, IL doesn't really matter. What matters is what the JIT emits. If you compare the JIT assembly for your two code snippets, the generated code is essentially the same:

; Using ??
C.M1(System.Object, System.Object)
    L0000: test rdx, rdx
    L0003: jne short L0008
    L0005: mov rdx, r8
    L0008: mov rax, rdx
    L000b: ret

; Using if
C.M2(System.Object, System.Object)
    L0000: test rdx, rdx
    L0003: je short L0008
    L0005: mov r8, rdx
    L0008: mov rax, r8
    L000b: ret

[canton7]

To explain the IL a bit more...

public object M1(object variable, object target)
{
    target = variable ?? target;
    return target;
}

compiles to:

        IL_0000: ldarg.1
        IL_0001: dup
        IL_0002: brtrue.s IL_0006

        IL_0004: pop
        IL_0005: ldarg.2

        IL_0006: starg.s target
        IL_0008: ldarg.2
        IL_0009: ret

The spec guarantees that variable is read exactly once when ?? is used. However, it needs to be used twice: once for the null test, and once to assign to target if it's not null. This is what the IL does: it reads variable once with the ldarg.1, and then dups it to make a copy on the stack, without reading it again. The brtrue consumes one of the copies, leaving one behind on the stack. If the brtrue finds that variable is null, then that extra copy isn't needed, so needs to be poped, and target loaded in its place (the pop / ldarg.2) then assigned to target. If it finds that variable was not null, then the extra copy made with dup is used to assign to target.

If we instead look at the code

public object M2(object variable, object target)
{
    if (variable != null)
    {
        target = variable;
    }

    return target;
}

The IL is:

        IL_0000: ldarg.1
        IL_0001: brfalse.s IL_0006

        IL_0003: ldarg.1
        IL_0004: starg.s target

        IL_0006: ldarg.2
        IL_0007: ret

In this case, the compiler is free to generate multiple reads of variable, as this is what the C# code does (again, one for the variable != null test, and one for the target = variable assignment). It therefore doesn't make an extra copy with dup (and doesn't need to pop it if it turns out that it's null): instead it loads it again if it turns out that it's not null (the second ldarg.1).

See for yourself on SharpLab.

So as you can see, the compiler is behaving exactly as expected. The difference in IL is so minor that I wouldn't expect there to be any difference at all in execution, and indeed @PathogenDavid shows that the ASM is near enough identical in both cases. Indeed if you make variable a field instead of a parameter, ?? comes out shorter (although this says nothing about execution speed at all).

If you want to compare two code samples for speed, use BenchmarkDotNet.