Czy możesz użyć słowa kluczowego C#, aby rozwinąć właściwości w interfejsie?

Question

Rozumiem, jak słowo kluczowe "nowe" może ukryć metody w klasie pochodnej. Jakie są jednak implikacje dla klas implementujących interfejsy wykorzystujące słowo kluczowe?

Rozważmy ten przykład, w którym decyduję się rozwinąć interfejs, zmieniając jego właściwości w odczyt/zapis.

public interface IReadOnly { 

    string Id { 
     get; 
    } 
} 

public interface ICanReadAndWrite : IReadOnly { 

    new string Id { 
     get; 
     set; 
    } 
} 

Wtedy jesteś w stanie robić takie rzeczy:

public IReadOnly SomeMethod() { 
    // return an instance of ICanReadAndWrite 
} 

Czy to zły projekt? Czy spowoduje to problemy dla moich klas, które implementują ICanReadAndWrite?

Edit: Oto zmyślony przykład dlaczego może chcę zrobić coś takiego:

że mam klasy fabrycznej, która zwraca IShoppingCartItemReadWrite. Mogę wtedy mieć warstwę usługową, która manipuluje cenami, zmienia rzeczy itp. Następnie mogę przekazać te obiekty jako IShoppingCartItemReadOnly do jakiejś warstwy prezentacji, która ich nie zmieni. (Tak, wiem, że to technicznie możliwezmiana them-- jest to kwestia projektu, nie bezpieczeństwa, itd.)

Answer 1

To nie jest szczególnie zły pomysł. Trzeba mieć świadomość, że implementor może (jeżeli niejawnie implementuje interfejs, a następnie pojedynczy odczyt/zapis właściwości mogłyby zaspokoić oba interfejsy) zapewniają dwa różne implementacje:

class Test : ICanReadAndWrite { 
    public string Id { 
     get { return "100"; } 
     set { } 
    } 
    string IReadOnly.Id { 
     get { return "10"; } 
    } 
} 

Test t = new Test(); 
Console.WriteLine(t.Id); // prints 100 
Console.WriteLine(((IReadOnly)t).Id); // prints 10 

Nawiasem mówiąc, w ogóle, new modyfikator dziedziczenia nie robi nic, poza poleceniem kompilatorowi zamknięcia i nie wyrzucania ostrzeżenia "ukrywasz tego członka". Pominięcie go nie będzie miało wpływu na skompilowany kod.

Answer 2

Nie jestem pewien, czy to kompiluje, czy nie, ale nie jest to wskazane, wzór do naśladowania. Mając możliwość wykonania jawnej implementacji interfejsu, teoretycznie można dostarczyć dwie całkowicie różne implementacje dla wersji IReadOnly i ICanReadAndWrite dla właściwości Id. Rozważ zmianę interfejsu ICanReadAndWrite poprzez dodanie metody ustawiającej dla właściwości zamiast zastępowania właściwości.

Answer 3

Jest to całkowicie legalne i implikacje dla twojej klasy, które implementują interfejs ICanReadAndWrite, byłyby po prostu tym, że gdy jest traktowane jako IReadOnly, to może tylko czytać, ale gdy zostanie potraktowane jako ICanReadAndWrite, będzie w stanie zrobić oba.

Answer 4

Możesz to zrobić, ale nie jestem pewien, co masz nadzieję osiągnąć, robiąc to.

public IReadOnly SomeMethod() { 
    // return an instance of ICanReadAndWrite 
} 

Ta metoda zwróci odwołanie do IReadOnly co oznacza, że ​​nie ma znaczenia, że ​​zwrócił ICanReadAndWrite. Czy to podejście nie byłoby lepsze?

public interface IReadOnly 
{ 
    String GetId(); 
} 

public interface ICanReadAndWrite : IReadOnly 
{ 
    String SetId(); 
} 

Answer 5

Nie powinieneś implementować ICanReadWrite na podstawie IReadOnly, ale zamiast tego uczynić je oddzielnymi.

tj.tak:

public interface IReadOnly 
{ 
    string Id 
    { 
     get; 
    } 
} 

public interface ICanReadAndWrite 
{ 
    string Id 
    { 
     get; 
     set; 
    } 
} 

Oto klasa korzystania z nich:

public class SomeObject : IReadOnly, ICanReadWrite 
{ 
    public string Id 
    { 
     get; 
     set; 
    } 
} 

Zauważ, że ta sama nieruchomość w klasie może obsługiwać oba interfejsy.

Należy zauważyć, że zgodnie z komentarzem, jedynym sposobem na uzyskanie solidnego rozwiązania będzie również posiadanie obiektu opakowania.

Innymi słowy, to nie jest dobre: ​​

public class SomeObject : IReadOnly, ICanReadWrite 
{ 
    public string Id 
    { 
     get; 
     set; 
    } 

    public IReadOnly AsReadOnly() 
    { 
     return this; 
    } 
} 

jako dzwoniący może po prostu to zrobić:

ICanReadWrite rw = obj.AsReadOnly() as ICanReadWrite; 
rw.Id = "123"; 

Aby uzyskać solidne rozwiązanie, trzeba obiekt otoki, jak poniżej:

public class SomeObject : IReadOnly, ICanReadWrite 
{ 
    public string Id 
    { 
     get; 
     set; 
    } 

    public IReadOnly AsReadOnly() 
    { 
     return new ReadOnly(this); 
    } 
} 

public class ReadOnly : IReadOnly 
{ 
    private IReadOnly _WrappedObject; 

    public ReadOnly(IReadOnly wrappedObject) 
    { 
     _WrappedObject = wrappedObject; 
    } 

    public string Id 
    { 
     get { return _WrappedObject.Id; } 
    } 
} 

To będzie działać i będzie solidne, aż do momentu, w którym osoba dzwoniąca używa refleksji.