[C# Feature Request] Type embedding

[gosub-com]

If I want my class to provide features from another class, I can either:

1. use inheritance (but there are many reasons I don't want to use inheritance for this)
2. use composition and manually write forwarding functions and properties in my class (but this is tedious and error prone)
3. use composition and require the user of my class to access the embedded class (but this publicly exposes the embedded class and also doesn't serialize properly)

None of these options are ideal, so I'd like to have something similar to type embedding from Golang https://go.dev/doc/effective_go#embedding, which allows an automatic version of method #2 above.

For example, if we have some classes we want to use functionality from:

class Common1
{
    public int A { get; set; }
    public void DoSomething() { }
}
class Common2
{
    public int B { get; set; }
    public void DoStuff() { }
}

Using method #3 above, I can add that functionality to my class:

class UseCommon
{
    public int C { get; set; }
    public Common1 Stuff1 { get; set; } = new();
    public Common2 Stuff2 { get; set; } = new();
   
}
void MyFunction()
{
    var useCommon = new UseCommon
    {
        C = 1,
        Stuff1 = new Common1 { A = 2 },
        Stuff2 = new Common2 { B = 3 }
    };
    useCommon.Stuff1.DoSomething();
    useCommon.Stuff2.DoStuff();
    JsonSerializer.Serialize(useCommon); // {"C":1,"Stuff1":{"A":2},"Stuff2":{"B":3}}
}

But I'd prefer users of my class to not need to deal with Stuff1 or Stuff2, and I'd like A and B to serialize at the same level as C.
This example uses a non-existent syntax with the using keyword to show what type embedding might look like in C#:

class UseCommon
{
    public int C { get; set; }
    public using Common1 { get; set; } = new();
    public using Common2 { get; set; } = new();  
}
void MyFunction()
{
    var useCommon = new UseCommon
    {
        C = 1,
        A = 2,
        B = 3
    };
    useCommon.DoSomething();
    useCommon.DoStuff();
    var s = JsonSerializer.Serialize(useCommon); // {"C":1,"A":2,"B":3}
}

There have been some complaints about type embedding. One complaint is it looks like inheritance, but acts differently. Another is that adding new features to the embedded type may add unwanted new features to the class using them. To address those complaints, I propose requiring explicit annotations on which functions and properties are publicly visible:

class UseCommon
{
    using Common1[A, DoSomething]   // Only 'A' and 'DoSomething' become public members of UseCommon
    using Common2[B, DoStuff]       // Only 'B' and 'DoStuff' become public members of UseCommon
    using Common3[*]                // All public members of Common3 become public members of UseCommon 
}

The list of symbols [A, DoSomething] makes it clear that only those symbols are being publicly exported and also protects from having new fields or functions appear magically when something was added to the embedded type. Note that the list of symbols includes all overloads with the same name (e.g. Adding void DoSomething(int a) to Common1 adds the new overload to UseCommon).

The special syntax using Common3[*] could be used to allow exporting all public members. There may be cases where we want to allow users of our class to access the embedded class directly, in which case public using Common3[*] could be used to allow public access to Common3 (as a readonly field or property). Neither of these uses can be confused with inheritance since there is no implicit conversion to the embedded type.

I also propose that this syntax automatically create a new readonly class during construction, and by extension require that the embedded class have an empty constructor. Internally, using Common1[...] would translate to something like readonly Common1 Common1 = new(); This allows a simpler syntax, easier deserialization, and embedded types are always known to be non-nullable.

[bernd5]

You could use a source generator to emit the forwarding calls....