Ref Interfaces

[conmaster2112]

A lot of us are directly excited with ref struct, let's introduce a simple concept with ref interface, these interfaces could be used only where ref struct could be, that allows for ref struct to implement such a interface, but also allows other types such as class or basic struct to implement this interface as well.

Pseudo Example

ref interface IReader
{
    public ReadOnlySpan<byte> ReadBytes(int count);
}

ref struct ReadOnlySpanReader(ReadOnlySpan<byte> span, ref int offset): IReader
{
    public readonly ReadOnlySpan<byte> Span = span;
    public readonly ref int Offset = offset;
    public readonly ReadOnlySpan<byte> ReadBytes(int count)
    {
         ReadOnlySpan<byte> result = Span.Slice(offset, count);
         offset += count;
         return result;
    }
}
class ReadOnlBufferReader(byte[] buffer, int offset): IReader
{
    public readonly byte[] Buffer = buffer;
    public int Offset = offset;
    public ReadOnlySpan<byte> ReadBytes(int count)
    {
         ReadOnlySpan<byte> result = Buffer.AsSpan(offset, count);
         offset += count;
         return result;
    }
}

Pseudo Usage

// Everything is all right
int ReadInt32(IReader reader)
{
   return BinaryPrimitives.ReadInt32LittleEndian(reader.ReadBytes(sizeof(int)));
}

// Compiler error, ref struct may be part of the IReader
async Task<int> ReadInt32Async(IReader reader)
{
   return BinaryPrimitives.ReadInt32LittleEndian(reader.ReadBytes(sizeof(int)));
}

Interface Implementation Chain

Every ref interface is able to implement non-ref interface, but non-ref interface can't implement ref interface and ref keyword has to be added to child interface as well.

[huoyaoyuan]

This is already implemented in latest C# compiler. See https://github.com/dotnet/csharplang/blob/main/proposals/ref-struct-interfaces.md . It's also already used in BCL.

[KennethHoff]

Is a ref interface unable to be boxed? If so, I assume the following code wouldn't work?

MySpan sp = new MySpan();

IRef spAsRef = (IRef)sp; // Compile error. Would require boxing.

public void DoThingWithIRef(IRef ref) { } // Compile error. Would require boxing.

public void DoThingWithIRefGenerically<TRef>(TRef ref) where TRef: IRef {} // Would work.

public ref interface IRef
{
	string GetString();
}

public ref struct MySpan : IRef
{
	public string GetString() => "Hey";
}

[timcassell]

I think that could work by the runtime treating the ref interface as a fat pointer (reference to the struct + pointer to type information).

Do I think it's worth it? Probably not, since we can now apply regular interfaces to ref structs and constrain generics.