Getter i seter pochodzących z różnych interfejsów

Question

I naprawdę trzeba mieć coś takiego:

interface IReadableVar 
{ 
    object Value { get; } 
} 

interface IWritableVar 
{ 
    object Value { set; } 
} 

interface IReadableWritableVar : IReadableVar, IWritableVar 
{ 
} 

Jednak gdy próbuję użyć IReadableWritableVar.Value otrzymuję błędy kompilacji, chyba że wyraźnie oddane do interfejsu bazowego, jak tutaj:

static void Main() 
{ 
    IReadableWritableVar var = null; 
    var t = var.Value; // <-- CS0229: Ambiguity between 'IReadableVar.Value' and 'IWritableVar.Value' 
    var.Value = null; // <-- CS0229: Ambiguity between 'IReadableVar.Value' and 'IWritableVar.Value' 

    var v = ((IReadableVar)var).Value; // compiles fine 
    ((IWritableVar)var).Value = null; // compiles fine 
} 

Dlaczego pojawiają się te błędy, mimo że wszystko powinno być jasne dla kompilatora? Czy jest jakiś sposób na rozwiązanie tego problemu poza rzutowaniem (setki miejsc w aplikacji)?

Aktualizacja: zasugerowano, że jest to duplikat Implementing 2 Interfaces with 'Same Name' Properties, ale jest to nieco inne, ponieważ w drugim przypadku nie ma dziedziczenia w interfejsach. W każdym razie problem został rozwiązany teraz - patrz zaakceptowana odpowiedź.

Answer 1

Możliwe obejście można zmodyfikować interfejs IReadableWritableVar tak:

interface IReadableWritableVar : IReadableVar, IWritableVar 
{ 
    new object Value { get; set; } 
} 

jednak zachować w moim, że ważna realizacja powinna być:

class ReadableWritableVar : IReadableWritableVar 
{ 
    public object Value 
    { 
     get { throw new NotImplementedException(); } 
     set { throw new NotImplementedException(); } 
    } 

    object IWritableVar.Value 
    { 
     set { throw new NotImplementedException(); } 
    } 

    object IReadableVar.Value 
    { 
     get { throw new NotImplementedException(); } 
    } 
} 

Bardziej konkretny przykład:

class ReadableWritableVar : IReadableWritableVar 
{ 
    public object Value 
    { 
     get { return ((IReadableVar)this).Value; } 
     set { ((IWritableVar)this).Value = value; } 
    } 

    object _val; 

    object IWritableVar.Value { set { _val = value; } } 

    object IReadableVar.Value => _val; 
} 

Albo jeszcze lepiej:

class ReadableWritableVar : IReadableWritableVar 
{ 
    public object Value { get; set; } 

    object IWritableVar.Value { set { Value = value; } } 

    object IReadableVar.Value => Value; 
} 

Answer 2

użycie interfejsu klasy abstrakcyjnej rozwiąże problem.

Answer 3

Cóż, skutecznie Getter i Setter to tylko dwie metody. Kiedy używamy interfejsu IReadableWritableVar, istnieją dwie metody o identycznej nazwie odziedziczone po interfejsach bazowych, a kompilator nie wie, którego z nich należy użyć, stąd dwuznaczność.

Kiedy rzuca się to na jeden z tych interfejsów, drugi członek zniknął i nie ma błędu.

Jeśli wdrożymy te państwa nie będzie żadnego błędu jak kompilator użyje tej realizacji:

class ReadableWritableVar : IReadableWritableVar 
{ 
    public object Value { get; set; } 
} 

var @var = new ReadableWritableVar(); 
var t = @var.Value; 

Również można użyć jawnego interfejsu od implementacji członków odpowiedź @Alessandro D'Andria, jeśli jest to wymagane że korzystasz z interfejsu, a nie z klasy.

Answer 4

Interesujące pytanie. Myślę, że metody rozszerzenia pomogą w tym przypadku.

public static class Extension 
{ 
    public static object GetValue(this IReadableVar v) 
    { 
     return v.Value; 
    } 

    public static void SetValue(this IWritableVar v, object value) 
    { 
     v.Value = value; 
    } 
} 

trzeba zmienić kod, aby go użyć:

IReadableWritableVar variable = null; 
var t = variable.GetValue(); 
variable.SetValue(null); 

Metoda rozszerzenie ma obsadę dla Ciebie.

Answer 5

Możliwym rozwiązaniem jest użycie wyraźny (styl Java) pobierania i ustawiania metod zamiast nieruchomości:

interface IReadableVar 
{ 
    object GetValue(); 
} 

interface IWritableVar 
{ 
    void SetValue(object value); 
} 

interface IReadableWritableVar : IReadableVar, IWritableVar 
{ 

} 

Wykorzystanie wówczas postać:

static void Main(string[] args) 
{ 
    IReadableWritableVar aVar = null; 

    var t = aVar.GetValue(); 
    aVar.SetValue(null); 
}