Implementowanie ogólnych metod z interfejsu przy użyciu innego interfejsu

Question

Próbuję utworzyć wspólny interfejs, który pozwoli mi korzystać z metod interakcji z bazą danych. Chcę, aby moja aplikacja biznesowa była w stanie utworzyć instancję dowolnej metodologii połączeń i mieć pewność, że interfejs jest identyczny.

Oto uproszczona wersja tego, co próbuję teraz.

Interfejs bazy danych, w którym IElement to kolejny interfejs definiujący tabelę. Interfejs

public interface IDatabase 
{ 
    void setItem(IElement task); //this works fine 
    List<T> listTasks<T>() where T : IElement; // this doesn't 
} 

IElement:

public interface IElement 
{ 
    int id { get; set; } 
} 

Realizacja IElement:

public class TaskElement: IElement 
{ 
    public int id { get; set; } 
    public string name {get; set; } 
} 

Realizacja IDatabase:

public class SQLiteDb: IDatabase 
{ 
    public SqLiteDb(SQLiteConnection conn) 
    { 
     database = conn; 
    } 

    public void setItem(IElement task) 
    { 
     // works fine when passed a new TaskElement() which is an implementation of IElement. 
     database.Insert(task); 
    } 

    //it all goes off the rails here 
    public List<T> listItems<T>() where T : IElement 
    { 
     var returnList = new List<IElement> 

     foreach (var s in database.Table<TaskElement>()) 
     { returnList.Add(s); } 

     return returnList; 
    } 

Próbowałem wiele wariacji na ten temat, ale każdy daje mi nową pozwać. Tutaj na przykład są dwa błędy.

1)

typu argumenty dla metody 'SQLiteDb.listTasks<T>()' nie można wywieść ze stosowania. Spróbuj jawnie określić argumenty typu.

2)

nie można niejawnie przekonwertować typu 'System.Collections.Generic.List<TaskElement>' do 'System.Collections.Generic.List<T>'

Próbowałem zmiany sposobu korzystania z wyraźną typ ale mieli tam problemy. Jeśli używam IElement (mój ogólny interfejs dla wszystkich elementów), nie mogę zwrócić listy obiektów TaskElement (moja implementacja IElement), ponieważ nie pasuje ona do typu zwracanego (List<IElement>), a jeśli zmienię typ zwracany na List<TaskElement> I "Nie będę już wdrażać interfejsu.

Warto zauważyć, że mogę łatwo uruchomić to, jeśli przestanę używać interfejsu i generycznych, ale wydaje mi się to idealną sytuacją do korzystania z interfejsu. Może staram się włożyć dużo rzeczy do interfejsu, gdy inna aplikacja (jak dziedziczenie bezpośrednie) może być lepsza?

Pytanie

Jak mogę zaimplementować interfejs z ogólnej wartości zwracanej przy jednoczesnym ograniczeniu typów, które mogą być zwracane tylko do implementacji innego interfejsu.

Answer 1

Spójrzmy uważnie na swojej realizacji listItems:

public List<T> listItems<T>() where T : IElement 
{ 
    var returnList = new List<IElement> 

    foreach (var s in database.Table<TaskElement>()) 
    { returnList.Add(s); } 

    return returnList; 
} 

Co zrobiłeś tutaj opisana metoda, w której osoba dzwoniąca może poprosić o dowolny typ na liście, o ile ten typ implementuje IElement. Ale kod w twojej metodzie nie daje im listy typów, które chcą, daje im listę IElement. Więc to łamie umowę.

Ale prawdziwym źródłem problemu jest database.Table<TaskElement>(). To może tylko dać ci instancje TaskElement. Musisz zrobić to T, ale aby to zrobić trzeba dodatkowe ograniczenie Generic:

public List<T> listItems<T>() where T : IElement, new 
{ 
    var returnList = new List<T> 

    foreach (var s in database.Table<T>()) 
    { 
     returnList.Add(s); 
    } 

    return returnList; 
} 

To dlatego database.Table<T> ma new ograniczenia, co oznacza, że ​​może być podane tylko typy, które mają konstruktora bezparametrowego (ponieważ ta metoda stworzy instancje danej klasy).

Answer 2

Trzeba użyć uniwersalnym typem podczas tworzenia instancji obiektu:

Zamiast

var returnList = new List<IElement>(); 

Wykonaj

var returnList = new List<T>(); 

Answer 3

wierzę powinno być coś takiego

public List<T> listItems<T>() where T : IElement 
    { 
     var returnList = new List<T> 

     foreach (var s in database.Table<T>()) 
     { returnList.Add(s); } 

     return returnList; 
    } 

Answer 4

Myślę, że jesteś na dobrej drodze z wyraźnie zdefiniowanie listy tak:

public interface IDatabase 
{ 
    void setItem(IElement task); //this works fine 
    List<IElement> listTasks<IElement>(); 
} 

Ponieważ nie można bezpośrednio cast Lista <TaskElement> do listy <IElement> trzeba będzie zrobić konwersję w swojej metodzie listTasks. Istnieje kilka metod zalecanych tutaj: Shorter syntax for casting from a List<X> to a List<Y>?. Myślę, że metoda LINQ to najprostszy, jeśli jesteś ok z LINQ:

List<IElement> listOfIElement = listOfTaskElement.Cast<IElement>().ToList()