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#:

```csharp
using System;

// Define the first interface
public interface IFirstInterface
{
    void FirstMethod();
}

// Define the second interface
public interface ISecondInterface
{
    void SecondMethod();
}

// Implement the interfaces in separate classes
public 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 interfaces
public 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.