primordial abstrait méthode générique de non classe générique

de la classe de base

class Drawer
{
    public abstract void Draw<T>(T type);    
}

classe dérivée #1

class ADrawer : Drawer
{
    public override void Draw<T>(List<T> list)
    {
        foreach (var a in list)
        {
            DrawA(a);
        }
    }

    public void DrawA(Agent a)
    {
        //draw code here
    }
}

classe dérivée #2

class AnotherDrawer : Drawer
{
    public override void Draw<T>(T number)
    {
        if (number == 1)
        {
            //draw code
        }
    }
}

L'erreur est dans le #1 de la classe dérivée : "pas de méthode appropriée trouvé pour remplacer"

dois-je utiliser "virtuel" dans la classe de base ainsi que le "résumé"?

Comment dois-je définir le type de paramètre pour permettre une variété de paramètres dans les classes dérivées?

Juste une note de côté, une méthode abstraite est implicitement une méthode virtuelle de sorte que vous ne devriez jamais avoir à définir une méthode à la fois abstrait ET virtuel.
bon à savoir 🙂
Vous disposez de deux méthodes conceptuellement différentes. L'un de vos "Dessiner" les méthodes de tire une chose, et le attire beaucoup de choses. Vous ne devriez pas essayer de les faire dans la même méthode, en premier lieu; make deux méthodes: Draw<T>(T item) et DrawMany<T>(IEnumerable<T> items). Même que List<T> a Add et AddRange méthodes; de faire quelque chose pour une seule chose et faire quelque chose de beaucoup de choses sont deux opérations différentes, donc deux méthodes différentes.

OriginalL'auteur Whiplash450 | 2012-02-08

abstract c#generics override

8

Votre code a plus de problèmes que de simplement celui que vous vous posez sur. Mettant de côté le correcteur de question pour le moment, la classe ADrawer besoin d'une contrainte de type (where T : Agent):
```
class ADrawer : Drawer 
{ 
    public void Draw<T>(List<T> list) where T : Agent
    { 
        foreach (var a in list) 
        { 
            DrawA(a); 
        } 
    }
    public void DrawA(Agent a) 
    { 
        //draw code here 
    } 
} 
```
Sans cette contrainte, il n'est pas légal de faire passer a à DrawA, parce que a est une référence de type T, et sans contrainte, il n'y a pas de conversion implicite de type T de type Agent.

La AnotherDrawer de classe a d'une utilisation illégale de la == de l'opérateur. Il n'est pas possible d'appliquer la == opérateur pour des opérandes de type T et int. Vous pourriez contourner en utilisant le object.Equals remplacer.

Enfin, la classe de base a une erreur parce que c'est un non-classe abstraite contenant un résumé membre.

En général, toutefois, ce code indique que le classe doit être générique, plutôt que de la méthode:
```
abstract class Drawer<T>
{
    public abstract void Draw(T type);
}
```
classe dérivée #1
```
class ADrawer : Drawer<List<Agent>>
{
    public override void Draw(List<Agent> list)
    {
        foreach (var a in list)
        {
            DrawA(a);
        }
    }       

    public void DrawA(Agent a)
    {
        //draw code here
    }
}
```
classe dérivée #2
```
class AnotherDrawer : Drawer<int>
{
    public override void Draw(int number)
    {
        if (number == 1)
        {
            //draw code
        }
    }
}
```
À suivre Eric Lippert du commentaire, qui était aussi ma première réaction à votre question, vous pourriez envisager de cette conception de la place:
```
abstract class Drawer<T>
{
    public abstract void Draw(T type);
    public void DrawMany(IEnumerable<T> types)
    {
        foreach (var t in types)
            Draw(t);
    }
}
```
classe dérivée #1
```
class ADrawer : Drawer<Agent>
{
    public override void DrawA(Agent a)
    {
        //draw code here
    }
}
```
Classe dérivée #2 est inchangé.

Merci beaucoup pour ce très utile de répondre. J'ai fait la classe de base Abstraite maintenant, et tout se compile. Mon seul problème maintenant c'est que quand je créer une liste de Tiroir, j'ai maintenant de spécifier un type (e.g List<Drawer<Type>> drawerList). Que puis-je mettre ce serait un générique de "type" ou est-il un moyen de contourner cela??
vous voulez avoir une liste de tiroirs, où les tiroirs de dessiner différents types d'objets? Si oui, regardez cette question et ma réponse: stackoverflow.com/q/9115593/385844. Il existe plusieurs solutions, mais aucune n'est aussi lisse que vous espérer.
La meilleure solution dépend un peu du contexte dans lequel se objets à tirer. Sont-ils également dans une collection que vous êtes à l'itération (dans ce cas, la référence pour les objets seraient d'un socle commun de type)? Ou vous avez une plus statique spécifique référence à un objet, et vous avez besoin pour obtenir le corrrect tiroir pour cette référence?
Le point de les séparer des tiroirs est de sorte qu'ils ont chacun un seul la responsabilité de l'élaboration d'un élément type de chaque (ie. agent de noeuds, etc..). Ces tiroirs prendre une liste d'objets passés au moment de l'exécution. Mais il y a d'autres tiroirs qui ne l'est pas et juste obtenir passé un int(par exemple). Je voudrais avoir tous les tiroirs dans une liste de sorte qu'ils peuvent tous être mis à jour dans une boucle.
En raison de prendre des différents paramètres sur leurs méthodes de Tirage, le tirage au sort des appels doivent être effectués séparément (ce qui est regrettable, mais inévitable, je crois). Comme la base de Tiroir de la classe est maintenant "tapé", est-ce à dire que la seule façon de stocker toutes les tiroirs est dans une Liste personnalisée de classe?

OriginalL'auteur phoog
5

méthode abstraite doit avoir cette signeture
```
  public abstract void Draw<T>(List<T> type);  
```
ah ok, mais j'ai plusieurs classes dérivées à partir du type de base, que chaque de prendre un autre type de paramètre, alors la configuration de la base du paramètre 'générique'?
Je suggère de faire de la base class ont le paramètre générique, puis les classes dérivées pourrait mettre en œuvre Drawer<int> ou Drawer<Agent> etc.

OriginalL'auteur wiero
1

Pour la compiler modifier la classe de base:
```
class Drawer
{
    public abstract void Draw<T>(List<T> type);    
}
```
List<T> n'est pas le même que T, de sorte que lorsque vous passez dans un List<T> dans la classe dérivée de la méthode, vous ne pouvez pas remplacer la méthode de base que qui a une T paramètre, pas un List<T> paramètre.

OriginalL'auteur George Duckett

Vous devez vous connecter pour publier un commentaire.