What is an example of multiple inheritance in C# or .NET Core that actually works (not just for classes)?

In C# and .NET, multiple inheritance is not supported for classes. However, you can achieve a form of multiple inheritance using interfaces. Unlike classes, interfaces can be implemented by multiple classes, allowing a class to inherit from multiple sources.Here's an example that demonstrates "multiple inheritance" using interfaces in C#:```csharpusing System;// Define the first interfacepublic interface IFirstInterface{ void FirstMethod();}// Define the second interfacepublic interface ISecondInterface{ void SecondMethod();}// Implement the interfaces in separate classespublic class FirstImplementation : IFirstInterface{ public void FirstMethod() { Console.WriteLine("FirstMethod from FirstImplementation"); }}public class SecondImplementation : ISecondInterface{ public void SecondMethod() { Console.WriteLine("SecondMethod from SecondImplementation"); }}// Implement a class that "inherits" from both interfacespublic class MultipleInheritanceClass : IFirstInterface, ISecondInterface{ private readonly FirstImplementation firstImplementation; private readonly SecondImplementation secondImplementation; public MultipleInheritanceClass() { firstImplementation = new FirstImplementation(); secondImplementation = new SecondImplementation(); } public void FirstMethod() { firstImplementation.FirstMethod(); } public void SecondMethod() { secondImplementation.SecondMethod(); }}class Program{ static void Main() { // Create an instance of the class MultipleInheritanceClass myInstance = new MultipleInheritanceClass(); // Call methods from both interfaces myInstance.FirstMethod(); myInstance.SecondMethod(); }}```In this example:- `IFirstInterface` and `ISecondInterface` are two interfaces that declare methods.- `FirstImplementation` and `SecondImplementation` are two classes that implement these interfaces separately.- `MultipleInheritanceClass` "inherits" from both interfaces by holding instances of `FirstImplementation` and `SecondImplementation` and delegating method calls to them.While this is not true multiple inheritance in the classical sense, it allows a class to "inherit" behavior from multiple sources through interfaces and composition. This approach is commonly used in C# to achieve similar goals without the complications introduced by true multiple inheritance. read less