Allow by-ref Extension methods.

[mburbea]

Currently C# allows methods that are public and static on static classes to be extension methods by augmenting the first parameter with the this keyword.

This is all well and good, but structs cannot really benefit from this feature as much as struct method invocation is basically always by-ref. e.g. Calling 3.GetHashCode() actually translates in il like...

ldc.i3
stloc.0
ldloca.s 0
call Int32 GetHashCode

(Forgive me if that's wrong its from memory.) The basic gist here is that we actually get a reference to the memory location and then invoke the method. My proposal is to allow a user to declare extension methods with a by ref first parameter if it is a struct. Thus:

public static void MyMethod(this ref int x){...} // allowed
public static void MyMethod<T>(this ref T x) where T:struct //allowed
public static void MyMethod(this ref string x) // not allowed.

Technically, I suppose we don't need to restrict it. But I think the behavior isn't as necessary for class types.

This would be a large benefit for larger structs as copying them is something you always would want to avoid.

[pharring]

Interestingly, Visual Basic already supports ByRef extension methods

[fubar-coder]

ref extension methods should only allowed when used together with readonly (as in #115) to prevent a reassignment of x inside the extension method.

[sharwell]

@fubar-coder No, that would completely defeat the purpose of this proposal. The purpose here is to be able to create an extension method for a struct type which behaves like an instance method of that type. Instance methods of a struct type pass the instance by reference; extension methods look the same in code but always pass the instance by value.

Keep in mind that when you call an instance method on a struct which is marked readonly, a local variable is allocated to hold a copy of that struct, and a reference to that local copy is passed to the method. This means even the memory allocation benefits of pass-by-reference would be lost if you required it only be used with readonly.

[mburbea]

Oh there is an interesting question to ask.
Currently new int().GetHashCode() is legal, but calling a method like this is not SomeMethod(ref new int()). If SomeMethod was now an extension method would new int().SomeMethod() be legal?

[sharwell]

@mburbea I would imagine yes. In new int().GetHashCode(), the int is getting implicitly passed by reference.

[fubar-coder]

I guess that you misunderstood me. Just take a look at this example:

public static void MyExtensionMethod(this ref SomeStruct x) {
    x = new SomeStruct();
}

This should not be allowed, because it produces an unpredictable side effect.

When I wrote about readonly, I meant that x cannot b be reassigned, but x will still be mutable. What you meant was a const value that x points to, which might be useful too, but wasn't the problem I wrote about. Therefore my resolution: ref extension methods must not allow a reassignment of x, which matches the readonly parameter proposal.

EDIT: Even when the value of x is immutable, then this doesn't require a copy of the value. readonly for the parameter and/or value are just contracts that guarantee that x doesn't get replaced with a different instance and/or that the value of x remains unchanged.

[sharwell]

The following is valid code:

public struct SomeStruct
{
    public void SomeMethod()
    {
        this = new SomeStruct();
    }
}

The following should be valid as well, with exactly the same result:

public static void SomeMethod(this ref SomeStruct value)
{
    value = new SomeStruct();
}

[dfkeenan]

I think this would be a great idea. But I would not restrict it to structs, I think it has merits for classes as well, for example:

public static void Release<T>(this ref T disposable) where T : class, IDisposable
{
      if (disposable != null)
      {
            disposable.Dispose();
            disposable = null;
      }
 }

[pharring]

Indeed. Visual Basic already allows exactly that:

<Extension>
Public Sub Release(Of T As {Class, IDisposable})(ByRef disposable As T)
    If disposable IsNot Nothing Then
        disposable.Dispose()
        disposable = Nothing
    End If
End Sub

[thomaslevesque]

This feature would only encourage mutable structs, which are almost always a bad idea.