Como a herança múltipla é ruim (torna a fonte mais complicada), o C # não fornece esse padrão diretamente. Mas às vezes seria útil ter essa habilidade.

Por exemplo, sou capaz de implementar o padrão de herança múltipla ausente usando interfaces e três classes como essa:

public interface IFirst { void FirstMethod(); }
public interface ISecond { void SecondMethod(); }

public class First:IFirst 
{ 
    public void FirstMethod() { Console.WriteLine("First"); } 
}

public class Second:ISecond 
{ 
    public void SecondMethod() { Console.WriteLine("Second"); } 
}

public class FirstAndSecond: IFirst, ISecond
{
    First first = new First();
    Second second = new Second();
    public void FirstMethod() { first.FirstMethod(); }
    public void SecondMethod() { second.SecondMethod(); }
}

Toda vez que eu adiciono um método a uma das interfaces, eu preciso mudar a classeFirstAndSecond também.

Existe uma maneira de injetar várias classes existentes em uma nova classe como é possível em C ++?

Talvez haja uma solução usando algum tipo de geração de código?

Ou pode parecer com isso (sintaxe c # imaginária):

public class FirstAndSecond: IFirst from First, ISecond from Second
{ }

Assim, não haverá necessidade de atualizar a classe FirstAndSecond quando modificar uma das interfaces.

EDITAR

Talvez seja melhor considerar um exemplo prático:

Você tem uma classe existente (por exemplo, um cliente TCP baseado em texto baseado em ITextTcpClient) que você já usa em locais diferentes dentro de seu projeto. Agora você sente a necessidade de criar um componente da sua classe para ser facilmente acessível para desenvolvedores de formulários do Windows.

Tanto quanto eu sei que você atualmente tem duas maneiras de fazer isso:

Escreva uma nova classe que é herdada de componentes e implemente a interface da classe TextTcpClient usando uma instância da própria classe, conforme mostrado em FirstAndSecond.

Escreva uma nova classe que herda de TextTcpClient e de alguma forma implemente o IComponent (ainda não tentei isso ainda).

Em ambos os casos, você precisa trabalhar por método e não por turma. Como você sabe que precisaremos de todos os métodos de TextTcpClient e Component, seria a solução mais fácil simplesmente combiná-los em uma classe.

Para evitar conflitos, isso pode ser feito por geração de código, onde o resultado pode ser alterado depois, mas digitar isso manualmente é uma dor pura na bunda.