Allow implementing properties from getter and setter declared in separate interfaces

[jcouv]

@OJacot-Descombes commented on Wed Nov 04 2015

Being able to declare separate readonly and writeonly interfaces that could be "joined" into a common read-write interface including properties and indexers would allow great interface designs.

public interface IReadOnlyFoo<out T> {
    T Value { get; }
}

public interface IWriteOnlyFoo<in T> {
    T Value { set; }
}

// If you program against this interface, currently you get an "ambiguity" compiler error.
public interface IReadWriteFoo<T> : IReadOnlyFoo<T>, IWriteOnlyFoo<T> {
}

// This, however works:
public class ReadWriteFoo<T> : IReadOnlyFoo<T>, IWriteOnlyFoo<T> {
    T Value { get; set; } // Implements IReadOnlyFoo<T>.Value and IWriteOnlyFoo<T>.Value
}

Note: This would allow us to have a call-site variance by specifying either the Read or the Write interface.

---

@HaloFour commented on Wed Nov 04 2015

This is legal in C# 6.0/VS2015:

public interface IFoo<out T> {
    T Blah { get; }
}

public interface IBar<in T> {
    T Blah { set; }
}

public interface IFooBar<T> : IFoo<T>, IBar<T> {
    new T Blah { get; set; }
}

public class FooBar<T> : IFooBar<T>, IFoo<T>, IBar<T> {
    public T Blah { get; set; }
}

---

@svick commented on Wed Nov 04 2015

This already seems to work for me:

public class ReadWriteFoo<T> : IReadOnlyFoo<T>, IWriteOnlyFoo<T> {
    public T Value { get; set; }
}

In IReadWriteFoo<T>, you don't need to redeclare the property, just inheriting from the base interfaces is enough:

public interface IReadWriteFoo<T> : IReadOnlyFoo<T>, IWriteOnlyFoo<T> {
}

public class ReadWriteFoo<T> : IReadWriteFoo<T> {
    public T Value { get; set; }
}

---

@OJacot-Descombes commented on Wed Nov 04 2015

I think that I closed to early. I'm getting a compiler error when trying to access the property.

    IReadWriteFoo<string> rw = new ReadWriteFoo<string>();
    rw.Value = "hello"; // ==> Ambiguity between ' IReadOnlyFoo<string>.Value and 
                        //        IWriteOnlyFoo<string> Value'

It looks like now we have 2 Value properties instead of one having both a getter and a setter.

---

However the following works, but if you want to program against interfaces it is not useful:

    var rw = new ReadWriteFoo<string>();
    rw.Value = "hello"; //  Works if rw is typed as the class.

Result: Classes can join getters and setters, interfaces cannot.

---

@HaloFour commented on Wed Nov 04 2015

It's interesting, if IReadWriteFoo<T> declares a shadowing property it works fine, but if it just "inherits" the members from IReadOnlyFoo<T> and IWriteOnlyFoo<T> it fails with the message that you're seeing.

---

@iskiselev commented on Tue Jan 17 2017

Looks like #14164 is duplicate of it, but this one is still in planning state, other one was closed with "Resolution-By Design" label.

---

@OJacot-Descombes commented on Wed Jan 18 2017

@iskiselev: The point of my issue is have a kind of call-site variance by specifying either the Read or the Write interface.

---

@jcouv commented on Sat Oct 21 2017

Moving language design discussions to csharplang. Thanks