Implementation of Rusts DeRef Trait for Reference Wrapping

[markusstephanides]

Introduce a DeRef-like trait in C# to allow direct usage of wrapped types in structs, akin to Rust's DeRef Trait, enhancing syntactic convenience.

Rust Example:

use std::ops::Deref;

struct MyRef<'a, T> where T: 'a {
    value: &'a mut T,
}

impl<'a, T> MyRef<'a, T> {
    fn new(value: &'a mut T) -> Self {
        Self { value }
    }
}

impl<'a, T> Deref for MyRef<'a, T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        self.value
    }
}

struct SampleStruct {
    number: i32,
}

impl SampleStruct {
    fn print_number(&self) {
        println!("{}", self.number);
    }
}

fn main() {
    let mut sample = SampleStruct { number: 5 };
    let my_ref = MyRef::new(&mut sample);
    my_ref.print_number();  // Output: 5
}

C# using current language features

public ref struct MyRef<T> where T : struct {
    private ref T value;
    public MyRef(ref T value) => this.value = value;
    public ref T Value => ref value;
}

public struct SampleStruct {
    public int Number;

    public void PrintNumber() {
        Console.WriteLine(Number);
    }
}

var sample = new SampleStruct() { Number = 5 };
var myRef = new MyRef<SampleStruct>(ref sample);
myRef.Value.PrintNumber();  // Output: 5

Proposed C# Example:

public ref struct MyRef<T> where T : struct {
    private ref T value;
    public MyRef(ref T value) => this.value = value;

    public static implicit operator ref T(MyRef<T> wrapper)
    {
        return ref wrapper.Value;
    }
}

public struct SampleStruct {
    public int Number;

    public void PrintNumber() {
        Console.WriteLine(Number);
    }
}

var sample = new SampleStruct() { Number = 5 };
var myRef = new MyRef<SampleStruct>(ref sample);
myRef.PrintNumber();  // Output: 5 - no explicit access to Value required

[HaloFour]

Could you explain what the use cases would be for implementing such a struct? In Rust it sounds like the reason you'd want to use this pattern is to implement smart pointers that can be dereferenced like a normal pointer. That doesn't seem applicable/desirable to C#.

[markusstephanides]

It's mostly about syntactic sugar. I'm writing an Entity Component System where data is represented in structs. When accessing the data, I want to work with references to it to avoid copies where not necessary. I currently have two options:

// Option 1
ref var data = ref world.GetData<Mesh>(entityId); // GetData returns a ref T and the caller needs to explicitly use ref twice to avoid copying and to keep the reference.
data.SomeMethod();
// Option 2
Ref<Mesh> data = world.GetDataRef<Mesh>(entityId); // GetData returns a CommunityToolkit.HighPerformance.Ref<T> which is a ref struct and basically wraps the reference of the data.
data.Value.SomeMethod();
// Option 3 (proposed)
Ref<Mesh> data = world.GetDataRef<Mesh>(entityId); // GetData returns a CommunityToolkit.HighPerformance.Ref<T> which is a ref struct and basically wraps the reference of the data but also allows implicit deref and direct access to fields and methods of .Value.
data.SomeMethod();

The first option is how it's done usually but requires more syntax and is prone to forgetting that the GetData method returns a reference that should also be stored as such.

The second option solves the issue of the first option and will always return a reference. But with the caveat of not allowing direct access to the underlying value - I have to use .Value everytime which isn't really much prettier than the Option 1 example but safer.

[colejohnson66]

Such a feature could also be used for "delegating types" that have been proposed a few times. Unfortunately, each time, source generators are proposed as the solution. For your case, the best you'll probably get in C# would be an analyzer for your APIs that flags forgetful use of ref.