ref deconstrurctor

[xoofx]

Hello,

We have a case at Unity where we would like our users to iterate on a group of ref:

foreach(ref var (key, value) in Query(...)){
    // process key and value
}

Unfortunately, a regular deconstruct pattern can't allow returning ref:

public void Deconstruct(out AnotherStruct1 key, out AnotherStruct2 value) { }

So, in our case above, we could imagine that the result of the Query function would return an IEnumerable<MyStruct> where MyStruct could be defined like this:

public unsafe struct MyStruct {
    private void* _buffer;

    // default name "key" for this deconstruct
    [Deconstruct(0, "key")]
    public ref AnotherStruct1 GetStruct1Ref() => ref Unsafe.AsRef<AnotherStruct2>(_buffer + someoffset1);

    // default name "value" for this deconstruct 
    [Deconstruct(1, "value")]
    public ref AnotherStruct2 GetStruct2Ref() => ref Unsafe.AsRef<AnotherStruct2>(_buffer + someoffset2);
}

The DeconstructAttribute would define which method or property getter can serve as a deconstruct. The first int argument defines the order (you cannot access a deconstructed 1 without deconstructing 0). The second defines the used name (probably more useful for IDE assistance).

Thoughts?

[YairHalberstadt]

if ref fields become a thing (https://github.com/dotnet/csharplang/blob/main/proposals/low-level-struct-improvements.md) then maybe you could solve this by making AnotherStruct1 and AnotherStruct2 pointer sized wrappers around a ref field, and then you wouldn't need to pass them by ref.

Would that work for your use case? Or are AnotherStruct1 and AnotherStruct2 arbitrary user defined types?

[xoofx]

Or are AnotherStruct1 and AnotherStruct2 arbitrary user defined types?

They are arbitrary user defined types (e.g other structs). Not sure I follow your suggestion and how ref fields could help with deconstruct, do you have an example?

[YairHalberstadt]

I'm saying that you wouldn't need to return it by ref at all, if AnotherStruct1 looked like this

public struct AnotherStruct1
{
    ref LargeStruct ActualData;
}

since AnotherStruct1 would be ref sized.

[xoofx]

Yep, though that still requires a way to deconstruct these ref fields. ref fields are orthogonal here but the DeconstructAttribute proposed above could apply to ref fields.

[En3Tho]

I believe the idea is to use ref fields ad a workaround. You could pass into deconstruct's out patterns a struct containing a single ref field and then use dot notation to get it after deconstruction.

[xoofx]

I believe the idea is to use ref fields ad a workaround. You could pass into deconstruct's out patterns a struct containing a single ref field and then use dot notation to get it after deconstruction.

I understand, but I wouldn't have opened this issue otherwise. We can perfectly use ref properties today and that would work as ref fields.

This issue is for proposing ref deconstructor which is not possible today.

[ufcpp]

I also encountered a situation I needed ref deconstruction or out ref (ref of ref) when I ported Recast/Detour to C#.

class NavMesh
{
    Status GetTileAndPolyByRef(dtPolyRef @ref, out ref MeshTile tile, out ref Poly poly);
    // or
    (ref MeshTile tile, ref Poly poly)? GetTileAndPolyByRef(dtPolyRef @ref);
}

if (navMesh.GetTileAndPolyByRef(polyRef, out var tile, out var poly) == Status.Success) { }
// or
if (navMesh.GetTileAndPolyByRef(polyRef) is { tile: var tile, poly: var poly }) { }

[bottle2]

noooooooo you can't make a ref deconstructor!!!!!!!

here is a kludge bro:

Lalas lalas = new(2);

foreach (var (a, b) in lalas)
{
    a[0] += 5;
    b[0] += 5;
}

Console.WriteLine(lalas.ass[0] + lalas.ass[1] + lalas.bss[0] + lalas.bss[1]);

struct Lalas(int n)
{
    internal int[]    ass = new int   [n];
    internal double[] bss = new double[n];
    int i = -1;
    int n = n;

    public Lalas GetEnumerator() => this;

    public Lala Current => new() { a = ass.AsSpan(i, 1), b = bss.AsSpan(i, 1) };

    public bool MoveNext() => ++i < n;

    public ref struct Lala
    {
        internal Span<int> a;
        internal Span<double> b;

        public void Deconstruct(out Span<int> a, out Span<double> b)
        {
            a = this.a;
            b = this.b;
        }
    }
}

seriously what is the big deal??
please add what this gentle sir wants pleeeeeeease
just, I don't like your attribute idea, just let us declare pubic void Deconstruct(ref int a, ref double b)!!!!

[bottle2]

and then get rid of error CS9072, erase it from existence >:)

[bottle2]

unlike JavaScript were destructuring assignment is actual variable declaration, in C# tuples exist as types, ValueType... hmmm #2584

[bottle2]

or is it? I think I did something illegal? but it runs fine
(?)

[CyrusNajmabadi]

@bottle2 Please engage people following the rules of the .net code of conduct. This generally acting in a generally professional and constructive manner. You might also want to consider engaging on our discord. Please don't call out people in this fashion though. I'd also advise you flesh out several of your posts. They tend to come across as very cryptic and stream-of-consciousness-esque. That makes them much harder to engage with.

Thanks.