Implementar una interfaz con métodos genéricos

Question

Estoy haciendo un espacio en blanco en este caso y parece que no puedo encontrar ningún ejemplo anterior que haya escrito. Estoy tratando de implementar una interfaz genérica con una clase. Cuando implemento la interfaz, creo que algo no funciona bien porque Visual Studio produce continuamente errores que indican que no estoy implementando todos los métodos en la Interfaz genérica.

Aquí es un esbozo de lo que estoy trabajando con:

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

Entonces, ¿qué debe mi clase parecerse?

Answer 1

usted debe reelaborar su interfaz, así:

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

a continuación, se puede implementar como una clase genérica:

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 
    } 
} 

O bien, puede aplicar de manera concreta:

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

creo que es probable que desee volver a definir su interfaz de la siguiente manera:

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

Creo desea que los métodos a utilizar (reutilización) los parámetros genéricos de la interfaz genérica en la que están declaradas; y que probablemente no desee convertirlos en métodos genéricos con sus propios parámetros genéricos (distintos de la interfaz).

Teniendo en cuenta la interfaz como redefiní ella, puede definir una clase como esta:

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

o definir una clase genérica de esta manera:

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

- Editar

El otras respuestas son mejores, pero tenga en cuenta que puede hacer que VS implemente la interfaz por usted, si no está seguro de cómo debería verse.

Proceso descrito a continuación.

Bueno, Visual Studio me dice que debería tener este aspecto:

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 
} 

Tenga en cuenta que todo lo que hice fue interfaz de escritura, a continuación, haga clic en él, y esperar a que el pequeño icono al emergente para tener VS generar el aplicación para mí :)