Multiple Inheritance in C#

Rushee Mahorkar

3y1kC#

//Interface I1 and I2 I cant change as they are 
public interface I1
{
    void Display();
}
public interface I2
{
    void Display();
    void Display2();
}

//I can make changes here
public class MyClass : I1, I2
{
    void I1.Display()
    {
    }
    void I2.Display()
    {
    }

    void I2.Display2()
    {
        
    }
}

//Calling this method from a diffrent class
void processData(I1 data) //I have to accept I1 interface refrence only
{
    var temp = data.Display2(); //Error 
}

In processData() method data.Display2() is giving error. How I can achive as data is basically MyClass object then how can I call Display2() with I2 reference. Is there any solution like Casting or any SOLID principle which I am missing?

3 Replies

Know the answer? Post it — somebody with the same question will find it here.

Deepak Rawat3y ago
In order to call the Display2() method on the data object inside the processData() method, you need to cast the data object to the I2 interface. Since data is declared as I1, you can't directly access the Display2() method using that reference. Here's how you can achieve it:
```
void processData(I1 data)
{
    if (data is I2 dataWithDisplay2) // Check if data implements I2
    {
        dataWithDisplay2.Display2(); // Call Display2() using the I2 reference
    }
}
```
In the above code, we use the is keyword to check if data implements I2. If it does, we assign the data object to a new variable dataWithDisplay2, which has the type I2. Then we can call the Display2() method using dataWithDisplay2.

By using this approach, you can handle the scenario where data can be an object that implements both I1 and I2, and selectively call methods based on the interface it implements.

Rajkiran Swain3y ago

public interface IFirstInterface
{
    void Display();
}

public interface ISecondInterface
{
    void Display();
    void Display2();
}

public class MyClass : IFirstInterface, ISecondInterface
{
    void IFirstInterface.Display()
    {
    }

    void ISecondInterface.Display()
    {
    }

    void ISecondInterface.Display2()
    {
    }
}

void processData(IFirstInterface data) // Accepting IFirstInterface interface reference
{
    data.Display();    // Accessible through IFirstInterface
}

void processData(ISecondInterface data) // Accepting ISecondInterface interface reference
{
    data.Display2();   // Accessible through ISecondInterface
}

// Example usage:
var myObject = new MyClass();
processData(myObject); // Passes an instance of MyClass to the appropriate processData method

Mohamed Azarudeen Z3y ago

Hi Rushee

// Interface definitions (I1 and I2 remain unchanged)
public interface I1
{
    void Display();
}

public interface I2
{
    void Display();
    void Display2();
}

// MyClass implementing both I1 and I2
public class MyClass : I1, I2
{
    void I1.Display()
    {
    }
    
    void I2.Display()
    {
    }

    void I2.Display2()
    {
    }
}

// Calling the processData method from a different class
void processData(I1 data)
{
    if (data is I2 i2Data)
    {
        i2Data.Display2(); // Accessing Display2 using I2 reference
    }
    else
    {
        // Handle the case where the data does not implement I2
    }
}