Proposal: ref interface to avoid boxing

[ygc369]

C# should allow to declare ref interface, structs that inherit ref interface don't get boxed when used as the interface. Instead, pass by ref.
Only struct can inherit ref interface, class can't.
Ref interface can't be class member, can't be stored on the heap. (stack-only)
For example:

public ref interface ISomeInterface { ...... }
public struct A: ISomeInterface { ...... }

static void test(ISomeInterface ia) //passed by ref
{
    ref A a = (ref A)ia;
    ......
}

static void main()
{
    A a0=new A();
    test((ISomeInterface)a0); //pass by ref
}

[yaakov-h]

How would this work?

[ygc369]

@yaakov-h
I think I have described it clearly.

[yaakov-h]

@ygc369 I do not think so, for if you had, I would not have needed to ask the question.

[ygc369]

@yaakov-h
The core idea is passing by ref, not boxing. If you still don't understand, you should point out which part of this idea puzzles you.

[yaakov-h]

@ygc369 Well, all of it really.

C# should allow to declare ref interface

What is a ref interface? Please elaborate.

structs that inherit ref interface don't get boxed when used as the interface

How so? How does this work at all?

Instead, pass by ref.

How do you pass a struct by ref from the call-site but deal with it as an interface at the use-site? Is this something the CLR can already do, or would this require CLR changes?

Only struct can inherit ref interface, class can't.

Language limitation, or CLR limitation?

Ref interface can't be class member, can't be stored on the heap. (stack-only)

This has been raised many times before with no good results - what happens if it needs to be lifted to a class member for an async or iterator (yield) method?

[ygc369]

@yaakov-h
This idea needs CLR help. I don't know whether CLR can already do it, if not, it would require CLR changes.

Language limitation, or CLR limitation?

Language limitation.

what happens if it needs to be lifted to a class member for an async or iterator (yield) method?

Have you seen ref struct in C# 7.2? It simply forbids these cases. So this idea should do the same.

[MkazemAkhgary]

You can go ahead and say have ref class/interface that only lies on stack. How references and objects are stored in stack needs to be discussed.

You can not avoid boxing of struct when its cast to object. Objects have references, value types dont have that so when you cast it needs to be boxed so you can have reference to it

[ygc369]

@MkazemAkhgary
I don't want to avoid boxing of struct when it cast to object, I only want to avoid boxing when it cast to ref interface. I think the compiler/CLR could do some magic here.

[MkazemAkhgary]

I understand that you are trying to keep things on stack, which is some times a good thing.

note that some times trying to keep things on stack leads to excessive complexity and if you just let them go on heap your code becomes simpler, easier to understand and even faster to run.

I'm not telling that what you are trying to do is good or not, I just wanted to note that, its your decision which way to go.

Having all of that said, imagine we had such thing as ref class/interfaces, with this you can take advantage of inheritance and interfaces as well, you don't even bother to use struct in your case. you just use your lightweight class, enjoy its awesomeness, have it on stack instead of heap :)

btw I don't think its that simple. probably there are lots of concerns, or maybe blockades on this way.

---

edit: maybe stackalloc class can be a better keyword combination :)

[ufcpp]

@ygc369

The core idea is passing by ref

Do you know how to invoke virtual method? This needs the VTable (virtual method table). An instance of struct doesn't have the VTable pointer. This is why boxing is needed.

[benaadams]

Could achieve similar with what exists today if you could define a constraint only interface (e.g. couldn't be used as a parameter/boxed)

public constraint ISomeInterface { ...... }
public struct A : ISomeInterface { ...... }

static void test<T>(ref T a) where T : ISomeInterface
{
    ......
}

static void main()
{
    A a0 = new A();
    test(ref a0);
}

[benaadams]

e.g. you can currently do this to to avoid any boxing

public interface ISomeInterface { ...... }
public struct A : ISomeInterface { ...... }

static void test<T>(ref T a) where T : ISomeInterface
{
    ......
}

static void main()
{
    A a0 = new A();
    test(ref a0);
}

But I assume you want to eliminate the possibility that the interface could be used for boxing?

[CodingMadness]

Can you do that also somehow when you want to return T where T: struct, ISomeInterface

That would be awesome too, because I myself have a scenario where I need to get a concrete struct type back from a List<ISomeInterface>. so that would be awesome too.

[ygc369]

@benaadams

But I assume you want to eliminate the possibility that the interface could be used for boxing?

Yes.

[maniero]

So you don't wanna a new mechanism, just a new constraint to compiler enforce?

[benaadams]

I think you only would need a way to indicate the interface was only for constraints; not for parameters.

That would be more flexible as it could still work for classes.

Then if you additionally wanted to force stack-only you could additionally use the struct constraint e.g.

static void test<T>(ref T a) where T : struct, ISomeInterface

[orthoxerox]

Sounds like a shape to me.

[ygc369]

I hope the "ref interface" could behave like this: when it is used as a parameter, it will pass struct by ref without boxing, and pass class just like before (not by ref, the class reference can't be changed after function returns).

[ygc369]

For example:

public ref interface ISomeInterface { ...... }
public struct A: ISomeInterface { ...... }
public class B: ISomeInterface { ...... }

static void foo(params ISomeInterface args[])
{ ...... }

var a = new A();
var b = new B();
foo(a, b); //a is struct, pass by ref, but b is class, need not pass by ref

[aviadmini]

This is still valid for method return type:

struct SomeStruct : ISomeInterface
{
}

ISomeInterface GetSome()
{
    return SomeStruct();
}

this will perform boxing of value type, while marking interface as proposed could prevent that

[watsonsong]

For example:

public ref interface ISomeInterface { ...... }
public struct A: ISomeInterface { ...... }
public class B: ISomeInterface { ...... }

static void foo(params ISomeInterface args[])
{ ...... }

var a = new A();
var b = new B();
foo(a, b); //a is struct, pass by ref, but b is class, need not pass by ref

How about his proposal going on, is it closed?

It actually useful is someone want to reduce GCAlloc.
When I want to use polymorphism on a stack, it will have a way to avoid any GCAlloc and boxing.

And more the 'delegate' has the same issue. For example, the Array.Sort or anything need a predicator, and the predicator capture some local variables, there is no way to avoid boxing. This issue just change the 'delegate' to 'interface'.

[CyrusNajmabadi]

How about his proposal going on, is it closed?

Yes. As you can see, @ygc369 closed this a couple of years ago.

[stevendarby]

Can this be reopened, or would it require creating another issue? @aviadmini provides a good use case for such a feature.

[333fred]

Please create a new discussion.

[ygc369]

As some people requires, I will reopen this issue.

[333fred]

Then as our README indicates, I've converted this to a discussion.

[CodingMadness]

Any news on this so far?

[HaloFour]

Related: #7608