Implémenter une Interface avec des Méthodes Génériques

Je dessine un vide sur celui-ci et n'arrive pas à trouver quelque exemple précédent que j'ai écrit. Je suis en train de mettre en œuvre une interface générique, avec une classe. Quand j'ai implémenter l'interface je pense que quelque chose ne fonctionne pas bien parce que Visual Studio constamment produit des erreurs disant que je ne suis pas implmenting toutes les méthodes dans l'Interface Générique.

Voici un bout de ce que je suis en train de travailler avec:

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

Alors, que devez-ma classe de ressembler?

  • Mauvaise question du titre. Il y a des méthodes génériques dans les classes normales et des interfaces, et il y a des interfaces génériques avec des méthodes.
InformationsquelleAutor Jason N. Gaylord | 2009-08-28
  1. 90

    Vous devez retravailler votre interface, comme suit:

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

    Ensuite, vous pouvez la mettre en œuvre comme une classe générique:

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

    Ou, vous pouvez la mettre en œuvre concrètement:

    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
    }
}
    • Parfait. Je savais que je devais préciser le générique de vars, mais ne pouvait pas se rappeler où (no pun intended). Grâce Reed!
    • Le résultat souhaité peut ne pas être possible, mais IMO cette réponse n'a pas de méthodes génériques, mais plutôt une classe générique avec des méthodes dépendant. Techniquement, il semble que les méthodes ont leurs propres paramètres du modèle.
    • Vous êtes de droite. Mauvaise question du titre, mais la bonne réponse pour la question.
    • Vous pouvez utiliser l'Activateur pour créer l'instance de T comme ceci: T obj = Activateur.CreateInstance<T>();
    InformationsquelleAutor Reed Copsey
  2. 11

    Je pense que vous voulez probablement pour redéfinir votre interface comme ceci:

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

    Je pense que vous voulez les méthodes à utiliser (re-use) les paramètres génériques de l'interface générique dans lequel elles sont déclarées, et que vous ne voulez probablement pas à faire d'eux des méthodes génériques avec leur propre (distincte de celle de l'interface) paramètres génériques.

    Compte tenu de l'interface comme je l'ai redéfini, vous pouvez définir une classe comme ceci:

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

    Ou définir une classe générique comme ceci:

    class Foo<T, U> : IOurTemplate<T, U>
    where T : class
    where U : class
{
    public IEnumerable<T> List() { ... etc... }
    public T Get(U id) { ... etc... }
}
    • Vous pouvez également mettre en œuvre la présente comme une classe générique, c'est à dire: la classe Foo<T,U> : IOurTemplate<T,U> -- je ne suis pas sûr de l'option Jason était après.
    • Vous avez raison, je vais le rajouter.
    InformationsquelleAutor ChrisW
  3. 1

    -- Edit

    Autres réponses sont mieux, mais notez que vous pouvez avoir VS implémenter l'interface pour vous, si vous êtes confus quant à la façon dont il devrait ressembler.

    Processus décrit ci-dessous.

    Bien, Visual Studio me dit que ça doit ressembler à ceci:

    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
}

    Noter que tout ce que je fait, c'est écrire l'interface, puis cliquez sur elle et d'attendre que la petite icône déroulante avoir VS générer la mise en œuvre pour moi 🙂

    • Voir: bien que vous spécialisé T et U dans l'interface (ils sont tous deux string), les méthodes elles-mêmes sont génériques avec leur propre distincte des paramètres génériques ... qui n'est probablement pas ce que les OP prévu.
    • Je suis d'accord, je pense que ton conseil est bon, je suis était juste en montrant comment il est possible d'obtenir VS implémenter l'interface pour vous, si vous êtes confus au sujet de la façon dont il regarde.
    InformationsquelleAutor Noon Silk