Implementowanie interfejsu z metodami ogólnymi

Question

Rysuję puste miejsce na tym i nie mogę znaleźć żadnego poprzedniego przykładu, który napisałem. Próbuję zaimplementować ogólny interfejs z klasą. Kiedy implementuję interfejs, myślę, że coś nie działa poprawnie, ponieważ Visual Studio nieustannie generuje błędy, mówiąc że nie wplatam wszystkich metod w Ogólny interfejs.

Oto stub co pracuję z:

public interface IOurTemplate<T, U> 
{ 
    IEnumerable<T> List<T>() where T : class; 
    T Get<T, U>(U id) 
     where T : class 
     where U : class; 
} 

Więc co moja klasa powinna wyglądać?

Answer 1

należy przerobić interfejs, tak jak poniżej:

public interface IOurTemplate<T, U> 
     where T : class 
     where U : class 
{ 
    IEnumerable<T> List(); 
    T Get(U id); 
} 

Następnie można wdrożyć go jako ogólne klasy:

public class OurClass<T,U> : IOurTemplate<T,U> 
     where T : class 
     where U : class 
{ 
    IEnumerable<T> List() 
    { 
     yield return default(T); // put implementation here 
    } 

    T Get(U id) 
    { 

     return default(T); // put implementation here 
    } 
} 

Albo można wdrożyć go konkretnie:

public class OurClass : IOurTemplate<string,MyClass> 
{ 
    IEnumerable<string> List() 
    { 
     yield return "Some String"; // put implementation here 
    } 

    string Get(MyClass id) 
    { 

     return id.Name; // put implementation here 
    } 
} 

Answer 2

myślę prawdopodobnie chcesz przedefiniować swój interfejs tak:

public interface IOurTemplate<T, U> 
    where T : class 
    where U : class 
{ 
    IEnumerable<T> List(); 
    T Get(U id); 
} 

Myślę, że chcesz użyć metody (re-use) ogólne parametry interfejsu rodzajowe, w których są one deklarowanej; i prawdopodobnie nie chcesz, aby były one generycznymi metodami z własnymi (odmiennymi od interfejsu) parametrami generycznymi.

Biorąc interfejs jak na nowo go, można zdefiniować klasę tak:

class Foo : IOurTemplate<Bar, Baz> 
{ 
    public IEnumerable<Bar> List() { ... etc... } 
    public Bar Get(Baz id) { ... etc... } 
} 

lub zdefiniować rodzajowe klasa tak:

class Foo<T, U> : IOurTemplate<T, U> 
    where T : class 
    where U : class 
{ 
    public IEnumerable<T> List() { ... etc... } 
    public T Get(U id) { ... etc... } 
} 

Answer 3

- Edycja

inne odpowiedzi są lepsze, ale pamiętaj, że możesz zaimplementować interfejs dla VS, jeśli nie masz pojęcia, jak powinien wyglądać.

Proces opisany poniżej.

Dobrze, Visual Studio informuje mnie powinno to wyglądać tak:

class X : IOurTemplate<string, string> 
{ 
    #region IOurTemplate<string,string> Members 

    IEnumerable<T> IOurTemplate<string, string>.List<T>() 
    { 
     throw new NotImplementedException(); 
    } 

    T IOurTemplate<string, string>.Get<T, U>(U id) 
    { 
     throw new NotImplementedException(); 
    } 

    #endregion 
} 

Zauważ, że wszystko zrobiłem było interfejs zapisu, a następnie kliknij na nim, i czekać na małą ikonę, aby popup mieć VS generowania realizacja dla mnie :)