C# Interface<T> { T Func<T>(T, t);} : Interfaces Génériques avec Paramétrée Méthodes Génériques Types de Retour

J'ai pensé que je pourrais utiliser certains (ce que je croyais) simple génériques à appliquer CRUD sur certaines Classes d'Affaires.
par exemple. 

public interface IReadable <T>
{
    T Read<T>(string ID);
}

et puis, peut-être, je pourrais avoir un NoteAdapter faire CRUD avec la Note de la classe, par exemple.

public class NoteAdapter : IReadable<Note>
{
    public Note Read<Note>(string ID) {
        return new Note();
    }
}

Mais pour une raison quelconque, te compilateur est de se confondre si j'ai à la fois un générique Type de retour et une fonction Paramétrée avec le même Type générique. C'est , si je fais :

public interface IReadable <T>
{
    void Read<T>(string ID);
}
public class NoteAdapter : IReadable<Note>
{
    public void Read<Note>(string ID) {
        return new Note();
    }
}

Il compile fine, bien qu'il ne marche pas faire ce que je veux !
Aussi, ce :

public interface IReadable <T>
{
    T Read (string ID);
}
public class NoteAdapter : IReadable<Note>
{
    public Note Read(string ID) {
        return new Note();
    }
}

fonctionne très bien ainsi, lui aussi Bien qu'elle ne satisfait pas aux exigences ! - Pourquoi ?
Parce que je peux pas avoir une Classe qui implémente un tas de ces Interfaces ..par exemple.

public interface IReadable <T>{
    T Read (string ID);
}
public class UniversalAdapter : IReadable<Note>, IReadable<Customer> ...
{
    public Note Read(string ID) {
        return new Note();
    }
    public Customer Read(string ID) {
        return new Customer();
    }
}

Coz, cela ne serait pas compiler comme type de retour ne font pas partie des méthodes de signature !

J'ai eu l'impression, en C# 3.5 + 

T Foo(T t);
T Foo<T> (T t);
T Foo(<SomeType> someInstance);

Tous ont des signatures différentes! Ce qui me manque ici ?

InformationsquelleAutor IM. | 2009-10-26
  1. 13

    Vous avez overspecified l'interface. Vous déclarez T dans la définition de l'interface, mais alors vous redeclare dans la méthode de définition:

    public interface IReadable <T>  /* T is declared here */
{
    T Read<T>(string ID); /* here, you've declare a NEW generic type parameter */
                          /* that makes this T not the same as the T in IReadable */
}

    En raison de cette confusion, vous vous retrouvez avec une erreur lorsque vous essayez d'implémenter l'interface.

    public class NoteAdapter : IReadable<Note> /* IReadable defines T to be Note */
{
    public Note Read<Note>(string ID) { /* Here, you're declaring a generic parameter */
                                        /* named Note.  This name then conflicts with */
                                        /* the existing type name Note */
        return new Note();
    }
}

    Pour résoudre ce problème, vous devez simplement supprimer le paramètre générique de la Read fonction, à la fois dans l'interface, et dans le NoteAdapter classe:

    public interface IReadable <T>
{
    T Read(string ID);
}
public class NoteAdapter : IReadable<Note>
{
    public Note Read(string ID) {
        return new Note();
    }
}

    EDIT:

    Ok, j'ai lu le reste de ton post, et il semble que vous avez déjà découvert que ce qui "fonctionne", mais vous avez l'air de penser que c'est incorrect. Pourquoi? Quelles sont les exigences que n'est-ce pas se rencontrer?

    • Thx pour ur aider.. c'est pas que je pensais que ce qui a fonctionné a été incorrect, mais que mon attente était le CLR équivaudrait les deux types génériques.. l'un de l'Interface et celle sur la Méthode.. c'est à dire l'Interface de <T>'s T serait le même que T Lire<T> 's type de retour <T>, ainsi que la Lecture<T>; mais en réalité, il ne correspond Interface<T> " s "T" avec le Type de retour
    InformationsquelleAutor P Daddy
  2. 3

    public interface IReadable <T>
    {
    T Read<T>(string ID);
    }

    ici vraiment autre Ts : IReadable <T> and T Read<T>(string ID)

    peut-être juste

    public interface IReadable <T>
    {
    T Read(string ID);
    }     ?

    parce que sinon, est égale à

    public interface IReadable <T>
    {
    X Read<X>(string ID);
    }

    Bon Génériques tutoriel

    EDIT:

    Peut-être vous avez besoin public interface IReadable <T> { T Read(T ID); } ?

    • Ouais, pour être plus précis, vous avez besoin: public interface IReadable <T> { T Lire (string ID); } Donc il n'y a qu'un seul paramètre générique ici, le T pour le type d'interface de définition.
    • Voir.. de dresser, mais ce n'est pas ce que je recherche.. que je vais probablement avoir UN adaptateur qui permettra de mettre en œuvre un tas de IReadable<T>s par exemple IReadable<Note>, IReadable<Client> etc.. et cela ne fonctionnerait pas comme tous ces "T Lire (string ID)"s évaluera à la même fonction que j'ai.e il wil permettent pas de "Note de Lecture(string ID);" et aussi "Client Lire(string ID)" dans la même classe ! ~Comme toujours..merci pour votre aide !
    • public interface IReadable <T> { T Lire(T-ID); } ?
    InformationsquelleAutor Ilya Khaprov
  3. 2

    Le CIL ne prend pas en charge surcharge de la méthode par le type de retour.

    • u as raison copain.. mon mauvais.. j'ai enlevé le mauvais exemple, mais mon point est que je Ne l'Interface de<T> { T Lire<T>{string id) } -, il semble être en mesure de faire correspondre une seule des Méthodes ReturnType OU les Méthodes Paramètre <T> avec l'Interface du Type <T> , mais pas les deux ! Thx pour ur le temps !
    InformationsquelleAutor Darin Dimitrov