Który jest lepszy projekt klasy C# do czynienia z czytaniem i pisaniem w porównaniu tylko do odczytu

Question

Rozważam dwa różne projekty klas do obsługi sytuacji, w której niektóre repozytoria są tylko do odczytu, a inne są do odczytu i zapisu. (I nie przewidują żadnych potrzebę tylko do zapisu repozytorium.)

---

Klasa Projekt 1 - zapewnić pełną funkcjonalność w klasie bazowej, a następnie wystawiać zastosowanie funkcjonalności publicznie w klasach podrzędnych

public abstract class RepositoryBase 
{ 
    protected virtual void SelectBase() { // implementation... } 
    protected virtual void InsertBase() { // implementation... } 
    protected virtual void UpdateBase() { // implementation... } 
    protected virtual void DeleteBase() { // implementation... } 
} 

public class ReadOnlyRepository : RepositoryBase 
{ 
    public void Select() { SelectBase(); } 
} 

public class ReadWriteRepository : RepositoryBase 
{ 
    public void Select() { SelectBase(); } 
    public void Insert() { InsertBase(); } 
    public void Update() { UpdateBase(); } 
    public void Delete() { DeleteBase(); } 
} 

---

Klasa Projekt 2 - klasa odczytu dziedziczy tylko do odczytu klasy

public class ReadOnlyRepository 
{ 
    public void Select() { // implementation... } 
} 

public class ReadWriteRepository : ReadOnlyRepository 
{ 
    public void Insert() { // implementation... } 
    public void Update() { // implementation... } 
    public void Delete() { // implementation... } 
} 

---

Czy jeden z tych projektów jest wyraźnie silniejszy od drugiego? Jeśli tak, to który i dlaczego?

P.S. Jeśli to brzmi jak pytanie o pracę domową, nie jest, ale możesz go używać jako jednego, jeśli chcesz :)

Answer 1

Jak o trzeciej opcji, ściśle związany z pierwszym, ale przy użyciu interfejsów zamiast:

public interface IReadRepository { 
    public void Select(); 
} 

public interface IWriteRepository { 
    public void Insert(); 
    public void Update(); 
    public void Delete(); 
} 

// Optional 
public interface IRepository : IReadRepository, IWriteRepository { 
} 

public class Repository : IRepository { 
    // Implementation 
} 

ten sposób realizacja jest (lub może być) wszystko w jednym miejscu, a rozróżnienie tylko przez na który interfejs patrzysz.

Answer 2

Z pewnością powiedziałbym, że projekt 2 jest najsilniejszy. Jeśli chcesz mieć implementację tylko do odczytu, nie musisz nic wiedzieć o pisaniu. Rozsądnie jest rozszerzyć implementację tylko do odczytu dzięki metodom wstawiania, aktualizowania i usuwania. Myślę też, że ten wzór najbardziej pasuje do Open-Closed principle.

Answer 3

(Edycja:.. myślę Eric Petroelje oferuje bardzo ładne rozwiązanie interfejsu opartego na jego odpowiedź będzie prawdopodobnie głosować za jego sugestią, przede wszystkim)

Z twoich dwóch opcji, ja wyraźnie głosowałoby za projektem nr 2: .

Z projektu # 1, myślę, że to nie ma sensu mieć klasę „tylko do odczytu”, która wewnętrznie nie jest tylko do odczytu w ogóle:

1. dane prędkości odczytu tylko klasa jest "cięższa" niż powinna.

2. Każdy może pochodzić z klasy tylko do odczytu, a następnie wywołać dowolną metodę modyfikacji klasy podstawowej. Przynajmniej, z projektem nr 1, powinieneś utworzyć klasę tylko do odczytu sealed.

design # 2, jest znacznie jaśniejsze niż klasa tylko do odczytu jest zmniejszona wersja (klasa podstawowa) w pełni funkcjonalny klasę lub sformułowane inaczej.

Answer 4

Po pierwsze, pozwól mi przyznać, że przyjmuję pewne założenia dotyczące tego, co możesz zrobić.Jeśli to nie trafi w sedno, daj mi znać.

Nie jestem pewien, jak przydatne będą zajęcia w jednej z dwóch opcji. Zakładam, że wywoływałbyś kod, który używałby instancji repozytorium tylko do odczytu, aw innych przypadkach instancji repozytorium do odczytu/zapisu, ale interfejsy nie pasują, więc i tak musiałbyś rozróżnić kod?

Lepszym rozwiązaniem może być udostępnienie wspólnego interfejsu, a następnie wyrzucanie wyjątków, jeśli spróbujesz napisać do repozytorium, gdy zostanie on przeczytany, a Twój kod będzie obsługiwał wyjątki.

Answer 5

Powiedziałbym projekt # 2, ale wtedy powinieneś zmienić nazwę ReadOnlyRepository na coś w stylu ReadRepository.

Dziedziczenie definiuje relację IS-A między klasami, a wyrażenie "ReadWriteRepository to ReadOnlyRepository" nie brzmi logicznie. Ale robi to "ReadWriteRepository is ReadingRepository".

Answer 6

Sugerowałbym posiadanie klasy bazowej ReadableFoo, z zamkniętą pochodną klasy ImmutableFoo, której konstruktor pobiera ReadableFoo, i ewentualnie dziedziczoną pochodną klasy MutableFoo, i ewentualnie klasę ReadableShadowFoo, której konstruktor wymagałby ReadableFoo (który może lub może nie może być zmienna), ale który działałby jako opakowanie tylko do odczytu.

Answer 7

Odpowiedź Eric oznacza SOLIDną zasadę ISP. Jest tak prosty i łatwy w użyciu.