IDisposable and multiple-inheritance

Question

I am using a third party class library. This implements class A that implements IDisposable and an interface B that also implements IDisposable.

I have a class that needs to inherit from class A and implemnt interface B. If a do a Visual Studio code analysis it reports that I am not implementing IDisposable correctly and to remove IDisposable from the list of interfaces.

Given that I cannot change A or B and the fact they both need to handle IDisposable. Is there a recommended way of handling this or doing I just ignore this.

External library has:

public interface IModbusMaster : IDisposable

public abstract class ModbusDevice : IDisposable

My code uses:

public abstract class ModbusMaster : ModbusDevice, IModbusMaster

Thanks

Can I ask why you need to inherit from both? I would hope that the 3rd party library set this up their model so that is never needed — Sayse, Sep 01 '14 at 13:27
The question is how you are going to do multiple inheritance in C# ? — Beatles1692, Sep 01 '14 at 13:28
Multiple inheritance is not possible by .NET. You could *implement* multiple interfaces but not *inherit* from multiple classes. — Dirk, Sep 01 '14 at 13:28

score 2 · Answer 1 · edited May 23 '17 at 12:01

2

Found a similar question here, implies a false positive that can be suppressed.

Code Analysis CA1063 fires when deriving from IDisposable and providing implementation in base class

edited May 23 '17 at 12:01

Community

1
1

answered Sep 01 '14 at 14:26

user3997323

31
3

score 0 · Answer 2 · answered Sep 01 '14 at 13:33

0

You cannot inherit from multiple classes in C# so you have to code your way around this with a Delegation Pattern.

You should inherit from A (is-a) and "have" (has-a) instance of B:

class MyClass extends A
{
    private B instance_of_b;

    public MyClass(B instance_of_b) // constructor
    {
        this.instance_of_b = instance_of_b;
        ...

Your methods from B are then delegated to the instance of b:

    public double MethodInB(int arg1, string arg2)
    {
        return instance_of_b.MethodInB(arg1, arg2);
    }

This is the only chance you get to mix behaviour of more than one class and mimic multi-inheritance.

Obviously, this comes with a lot of other synchronization and management problems you'll have to tackle.

answered Sep 01 '14 at 13:33

pid

11,472
6
34
63

The question has been changed. It is not actual multiple inheritance. – iCollect.it Ltd Sep 01 '14 at 13:34
Sorry I has a class and an interface – user3997323 Sep 01 '14 at 13:34
Ok, maybe I'll remove it later. If it's useful for some random visitor it might be better to leave it. – pid Sep 01 '14 at 13:35

score 0 · Answer 3 · answered Sep 01 '14 at 13:37

If A is a class, and it implements IDisposable, it must provide a Dispose method. It can however provide an abstract definition (if the class itself is marked as abstract), which means that you must override that Dispose method when you inherit from that class:

public abstract class BaseClassFromLibrary : IDisposable
{
    public abstract void Dispose();
}

public class MyClass : BaseClassFromLibrary
{
    public override void Dispose()
    {
    }
}

IDisposable and multiple-inheritance

3 Answers3