Implementing a class from 2 interfaces that share some parts

Question

Is the following not a good practice?

public interface IMyImmutableData
{
    int Data { get;}
}

public interface IMyMutableData
{
    int Data { set;get;}//implements both get and set
}

public class MyData : IMyImmutableData, IMyMutableData
{
    public int Data{get;set;} //implements both IMyImmutableData, IMyMutableData
}

void Main()
{
    MyData myData = new MyData{Data=10};
    Console.WriteLine(myData.Data);
}

The reason I ask is that resharper gives me the following warning: "possible ambiguity while accessing by this interface"

The reason I want to do the above is that when I create methods that use the MyData class, I would like to send it either as IMyMutable or IMyImmutable objects, so that users of the method know that they can expect the method to update or not update the passed in object.

Just as a note, I think `IMyReadOnlyData` would carry better meaning than `IMyImmutableData`, since the object is mutable at all. — Joel B Fant, Aug 25 '11 at 17:25

score 5 · Answer 1 · answered Aug 25 '11 at 17:28

I think you can ignore resharper's warning, as the ambiguity is intentional.

However, usually a wrapper class is used to provide readonly access to something, that way it can't be cast to anything that does provide more functionality.

public class MyReadonlyData : IMyReadonlyData {
    private MyData instance;

    public int Data {
        get {
            return instance.Data;
        }
    }

    public MyReadonlyData( MyData mydata ) {
        instance = mydata;
    }
}
// no access to original object or setters, period.

Although, I accepted dlev's answer, I like your solution, and will be reworking my project to use your idea. Its more elegant (imo). — Raj Rao, Aug 26 '11 at 15:23

score 3 · Answer 2 · answered Aug 25 '11 at 17:24

3

You need to make one or both of the implementations explicit:

public int IMyImmutableData.Data { get; }
public int IMyMutableData.Data { get; set; }

When you mark one as explicit, it can only be accessed when specifically cast as that type:

MyData obj = new MyData();
obj.Data; // Doesnt exist
(obj as IMyImmutableData).Data // Exists, specifically cast as this interface

If you choose to not mark one as explicit, it will be the property chosen when cast as other appropriate types.

answered Aug 25 '11 at 17:24

Tejs

40,736
10
68
86

Just a note - the explicit implementations can't be marked public, though they can be accessed publicly through the interface, as per Jon Skeet's answer here: http://stackoverflow.com/questions/1392252/c-sharp-what-is-the-reason-for-explicitly-implemented-interface-members-are-a – lightw8 Jun 20 '12 at 17:54

score 1 · Accepted Answer · answered Aug 25 '11 at 17:27

I think in this case your structure is fine. You don't want to explicitly implement the interfaces via separate properties, because then the Data you access via the immutable interface will actually be different than that for the mutable interface.

Also, your actual code is likely more complex, because in this case there is no ambiguity: you are accessing Data via the object itself, so interfaces need not be considered.

One solution with explicit interface implementation would be to use a common backing field, rather than auto-properties:

private int _data;
public int IMyImmutableData.Data
{
    get
    {
        return this._data;
    }
}

public int IMyMutableData.Data
{
    get
    {
        return this._data;
    }
    set
    {
        this._data = value;
    }
}

I marked this answer as "the" answer because it was closet to my answer. But I think, I will be using Joel B Fant's solution, as its more elegant. — Raj Rao, Aug 26 '11 at 15:22

score 0 · Answer 4 · answered Aug 25 '11 at 17:33

0

You could cast the variable and tell the compiler what exactly you mean: (resolve ambiguity)

MyData myData = new MyData{Data=10};
Console.WriteLine( ((IMyMutableData)(myData)).Data );

answered Aug 25 '11 at 17:33

Yochai Timmer

48,127
24
147
185

score 0 · Answer 5 · answered Aug 26 '11 at 00:07

You need a combined interface with a "new" qualifier on the read-write interface to avoid the squawk. Further, your interfaces are poorly named. Better names would be something like "IReadableData" and "IWritableData", and "IReadWriteData". Note that while "IReadableData" does not provide any means of mutating the data, that by no stretch of the imagination implies that the data is immutable. If something is immutable it won't every be changed by anyone; that would clearly not be the case with an object of type MyData.

Implementing a class from 2 interfaces that share some parts

5 Answers5