[Proposal]: Add the composition capability to C#

[Nefcanto]

Hello

I've been working with C# for more than a decade now. And I was happy.

Yet after learning React and feeling firsthand how Composition over inheritance is much more powerful, now I wish C# had composition too.

I can start a story for why it's amazing, but since it's just a discussion, I first wait to see what others might say. Maybe this discussion won't even be noticed at all.

[ufcpp]

#7296

[Nefcanto]

@ufcpp thanks for that link. Its syntax is however not a simple syntax and it does not provide a method to compose a type, rather than type members.

Let me give you an example of my real requirement.

• I need to have a Read.cs class that contains some methods to read data from our database. For example GetList(ListParameters parameters) or GetBySlug(string slug) or Exists(string key), etc.
• I need to have a Write.cs class that contains methods for writing to our database. For example Create(T t), or Update(T t), etc.
• I also have a Tree.cs that adds some capabilities for hierarchical structures, based on a convention. For example GetChildren(T t), etc.

Now I want to create a StudentService.cs class and I want to use the least amount of boilerplate code to be able to include those three classes inside it. My preference is as simple as include Read.cs or include Write.cs or Tree.cs.

In other words, the best option is to have this code:

public class StudentService
{
    include Read;
    include Write;
    include Tree;
}

And this inclusion can be a very simple file-based textual inclusion. In other words, the content of the Read.cs based on convention can be read and inserted in this place before compiling the code.

[HaloFour]

And this inclusion can be a very simple file-based textual inclusion.

Such a method would not work in C# as it cannot work with referenced assemblies as there is no "source" to include textually.

What you probably want are "traits", which are similar to interfaces but that contributed towards the members of the type.

[Nefcanto]

@HaloFour yes I had the PHP traits in mind. They are very useful. I have firsthand experience working with them. What if they are present? Can't we distinguish between existing code and non-existing code? A code that is besides my code, and a code that is inside another assembly?

[HaloFour]

C# is not a scripted or templated language. It would be expected that the majority of reusable components for composition would be exposed as compiled in other assemblies and that C# can work with them as such, just like interfaces today.

If you want templating behavior, you could use source generators which can automatically emit source into your project as part of your classes.

[iam3yal]

@Nefcanto

The experience isn't where it should be when it comes to composition in C# but it's not like it's forbidden you just need to make a bit work to implement it.

Composition over inheritance is much more powerful

These statements 🤦 I mean inheritance is just as powerful so it really depends on the problem you're trying to solve, advocating to use composition just because say in React it makes more sense doesn't mean everything should be constructed like this, you can see insane amount of examples in .NET, Roslyn and pretty much anywhere where inheritance was the right tool for the job, I'm not saying that composition is not awesome where it's appropriate and applicable but it's a tool to express a certain relationship and that's how we should look at it, comparing it to inheritance and say that it's more powerful is misleading.

Blazor components that are written in Razor support similar composition that exists in React.

private string? Color { get; set; }
private RenderFragment? ChildContent { get; set; }

private RenderFragment FancyBorder()
{
    return @<div class=@($"FancyBorder FancyBorder-{Color}")>
                @ChildContent
           </div>;
}

[Nefcanto]

@eyalalonn what is your solution for my use case which is a real-world use-case? These are the solutions:

1. Composition
2. Multiple Inheritance
3. Interface default members (which is an ugly attempt to support composition, and a disgrace to C#)
4. Source generation
5. IL weaving

From these methods, the composition method is the most mature way of doing it. That's why I wish C# had something like PHP traits.

[iam3yal]

@Nefcanto

Now I want to create a StudentService.cs class and I want to use the least amount of boilerplate code to be able to include those three classes inside it. My preference is as simple as include Read.cs or include Write.cs or Tree.cs.

With the upcoming feature of Primary Constructors you can actually do this:

public sealed class StudentService(
    Read read, 
    Write write, 
    Tree tree)
{
    // Do something with read, write and tree.
}

• Default Interface Members weren't introduced to support composition they are primarily introduced to evolve existing code and interoperability with Java, so you have to get your facts straight.

From these methods, the composition method is the most mature way of doing it. That's why I wish C# had something like PHP traits.

I don't know what "most mature way" means and each language is its own thing but I wouldn't oppose to make the experience better and more friendly in C#.

[TahirAhmadov]

#5897

[CyrusNajmabadi]

Thanks. Closing as dupe.