Champion "ref extension methods on structs" (C# 7.2)

[gafter]

• Proposal added https:/dotnet/csharplang/blob/master/proposals/csharp-7.2/readonly-ref.md
• Discussed in LDM
• Decision in LDM
• Finalized (done, rejected, inactive)
• Spec'ed

See also dotnet/roslyn#165

[Thaina]

Very important feature

[benaadams]

Precedent in VB.NET. Should be compatible? (Currently C# can't see VB.NET's byref extension methods)

Also should work with ref returns; which enables low cost fluent or functional struct apis

[orthoxerox]

See also #128 (ref operators (on structs))

[alrz]

What happens if we have two overloads,

void Deconstruct<T, U>(in this KeyValuePair<T, U> k, out T key, out U value) { .. }
void Deconstruct<T, U>(this KeyValuePair<T, U> k, out T key, out U value) { .. }

I think this should be possible to provide a ref variant without breaking existing code and the compiler should prefer the first overload afterwards.

[Thaina]

The reasons why we do not want to allow this on classes
It would break long standing invariant that a method call cannot turn non-null receiver to become null after invocation.
In fact, currently a non-null variable cannot become null unless explicitly assigned or passed by ref or out. That greatly aids readability or other forms of "can this be a null here" analysis.

I think it could be amend this case by having compiler enforce that, extension method must not assign a possible null value into the ref this argument

The ability to mutate reference type make it easy to write a lazy initializing or conditional caching

public static class Ext
{
    public void InitializeIfNull<T>(ref this T obj) where T : ICanInitial // some interface for initializing pattern
    {
        if(obj != null)
            return;

        // initialize obj by ICanInitial pattern
    }
}

public class SomeClass : ICanInitial
{
    public static DerivedSomeClass _instance;
    public static DerivedSomeClass Instance => _instance.InitializeIfNull();
}

And we must always check that it will not be null anytimes in that function

public static class Ext
{
    public T InitializeIfNull<T>(ref this T obj) where T : ICanInitial // some interface for initializing pattern
    {
        if(obj != null)
            return;

        obj = GetFromSomeWhere(); // ERROR it might be null
        if(GetFromSomeWhere() is var got && got != null)
            obj = got; // not null by flow analysis

        obj = GetFromSomeWhere() ?? obj; // should not error, it never change from object to null, worst case is null to null
    }
}

[TCROC]

Would it make sense to include this on extension methods for other immutable types like delegates as well?

[333fred]

If you want to propose that, I would suggest opening a new issue. This shipped a few years ago and is just waiting to be added to the ECMA spec.