Klasa abstrakcyjna lub pomocnik Klasa

Question

Właśnie dzisiaj dowiedziałem się trochę o Kompozycji na dziedziczenie. Zastanawiałem się, czy powinienem zastosować tę koncepcję do czegoś, co napisałem niedawno.

Mamy wcześniej miał dwie klasy, które były prawie identyczne, poza kilkoma małymi różnicami. Zawierały one kilka podstawowych funkcji dostępu do baz danych, ale działały na różnych (ale powiązanych) typach obiektów. Więc wcześniej miał klasę, które zostały zorganizowany mniej więcej tak:

class BallMillDBHandler{ 

    public BallMillDBHandler(){ ... } 

    public void InsertTool(BallMill tool) { ... } 
    public BallMill QueryTool(string toolID) { ... } 
    public void UpdateTool(BallMill tool) { ... } 
    public void DeleteTool(string toolID) { ... } 
} 

class DiamondToolDBHandler{ 

    public DiamondToolDBHandler(){ ... } 

    public void InsertTool(DiamondTool tool) { ... } 
    public DiamondTool QueryTool(string toolID) { ... } 
    public void UpdateTool(DiamondTool tool) { ... } 
    public void DeleteTool(string toolID) { ... } 
} 

wziąłem większość metod zbliżonych powielany i refactored je do klasy BaseToolDBHandler() i odziedziczył go od dwóch pozostałych, zapewniając kilka abstrakcyjnych metod i właściwości do obsługi różnic w dostępie do samych parametrów bazy danych.

Czy ma to sens, aby zamiast tego uczynić z BaseToolDBHandler klasę pomocniczą, zawartą w akcesoriach do baz danych i udostępnić im wspólny interfejs poprzednio abstrakcyjnych właściwości/metod? Czy powinienem zostawić to jako przypadek dziedziczenia?

Answer 1

Wygląda to na scenariusz, który przyniesie korzyści zarówno rodzajowym, jak i dziedziczenia za pośrednictwem klasy bazowej/interfejsu.

class DBHandler<TTool> where TTool : ToolBase // or ITool 
{ 
    public DBHandler(){ ... } 

    public void InsertTool(TTool tool) { ... } 
    public TTool QueryTool(string toolID) { ... } 
    public void UpdateTool(TTool tool) { ... } 
    public void DeleteTool(string toolID) { ... } 
} 

Jeśli trzeba, można zrobić bazę (opcjonalnie streszczenie) klasę lub interfejs do wykorzystania jako rodzaj przymusu, który gwarantowałby, że pewne elementy potrzebne narzędzia, które mają wewnątrz ciał metod.

Przykłady:

var handler = new DBHandler<BallMill>(); 
BallMill value = handler.QueryTool("xyz"); 
value.SomeProperty = "New Value"; 
handler.UpdateTool(value); 

Answer 2

Dziedziczenie jest często nadużywane, ale wydaje się, że jest to odpowiedni przypadek. W wielu przypadkach ludzie widzą tylko zduplikowany kod i myślą: "Wykorzystam dziedziczenie do usunięcia duplikatu kodu przez klasę podstawową". W rzeczywistości większość zduplikowanych kodów może zostać ponownie przetworzona na inną klasę, która jest używana w kilku miejscach. Zwykle klasy używające go nie są "powiązane", robią dwie całkowicie różne rzeczy i po prostu dzielą się potrzebą wykonania niektórych (lub niektórych serii) małych zadań.

Dziedziczenie powinno być używane w przypadku klas, w których można naprawdę powiedzieć, że klasa "jest" instancją klasy bazowej, a nie tylko jakaś klasa, która potrzebuje dostępu do zestawu metod zdefiniowanych gdzie indziej. W twoim konkretnym przypadku jasne jest, że obie klasy to sterowników DB. W ich sednie, obaj służą temu samemu ogólnemu celowi, ale są to dwie różne możliwe implementacje tego celu. Jedyny problem, który mogłem tu zauważyć (biorąc pod uwagę, że nie pokazałeś zawartości żadnej z metod), to że możesz połączyć obie klasy w jedną klasę, ale musielibyśmy dowiedzieć się więcej o szczegółach. wiedzieć, czy jest to możliwe, czy to możliwe.

Answer 3

powiedziałbym to zdecydowanie zadanie dla dziedziczenia ... ale przejdźmy jedną rzecz pierwsza. Skład jest wzorcem projektowym, który może i powinien być stosowany tam, gdzie dziedziczenie wielu klas nie jest cechą danego języka (np. C#)

Skład oznacza, że ​​twoja klasa kompozytowa tworzy instancje klas, na których zazwyczaj będą dziedziczone. W tym przypadku dostarczasz umowę do implementacji za pośrednictwem interfejsów.

Aby dać przykład, jak szorstki dziedziczenie może być stosowana do kodu, rozważ to: (nie jest to za pomocą kompozycji)

public interface IHandler 
{ 
    void InsertTool(ITool tool); 
    void UpdateTool(ITool tool); 
    void DeleteTool(string toolID); 
    //void DeleteTool(ITool tool) - seems more consistent if possible!? 

    ITool QueryTool(string toolID); 
} 

public interface ITool 
{ 

} 

class BallMill : ITool 
{ 
} 

class DiamondTool : ITool 
{ 
} 

class BallMillDBHandler : IHandler 
{ 

    public BallMillDBHandler(){ ... } 

    public void InsertTool(ITool tool) { ... } 
    public BallMill QueryTool(string toolID) { ... } 
    public void UpdateTool(ITool tool) { ... } 
    public void DeleteTool(string toolID) { ... } 
} 

class DiamondToolDBHandler : IHandler 
{ 

    public DiamondToolDBHandler(){ ... } 

    public void InsertTool(ITool tool) { ... } 
    public DiamondTool QueryTool(string toolID) { ... } 
    public void UpdateTool(ITool tool) { ... } 
    public void DeleteTool(string toolID) { ... } 
} 

Answer 4

Zamiast dziedziczenia użyć rodzajowych. Chcesz wykonać tę samą operację na różnych typach obiektów, co jest właśnie tym, co generycy robią najlepiej.