Création d'une liste générique des objets en C#

Par la voie de l'intro, je suis en création d'un Quadtree moteur à des fins personnelles à des fins de formation. Je suis désireux de ce moteur pour avoir la capacité de travailler avec de nombreux différents types de formes (au moment où je vais avec des cercles et des carrés) qui vont tous se déplacer dans une fenêtre et effectuer une action lors de la collision se produit.

Voici mes objets de forme que j'ai jusqu'à présent:

public class QShape {
    public int x { get; set; }
    public int y { get; set; }
    public string colour { get; set; }
}

public class QCircle : QShape {
    public int radius;
    public QCircle(int theRadius, int theX, int theY, string theColour) {
        this.radius = theRadius;
        this.x = theX;
        this.y = theY;
        this.colour = theColour;
    }
}

public class QSquare : QShape {
    public int sideLength;
    public QSquare(int theSideLength, int theX, int theY, string theColour) {
        this.sideLength = theSideLength;
        this.x = theX;
        this.y = theY;
        this.colour = theColour;
    }
}

Maintenant, ma question est, comment puis-je créer une liste générique (List<T> QObjectList = new List<T>();) en C# donc je peux avoir une liste contenant toutes ces formes diverses qui peuvent avoir des propriétés différentes (par exemple, QCircle a le "rayon" de la propriété, tandis que QSquare a la "sideLength de la propriété")? Un exemple de mise en œuvre serait utile.

Je sais juste qu'il est bêtement évident de répondre à cette question, mais j'apprécierais toute aide de toute façon. Je suis en train de revenir en C#; il a évidemment été un moment...

Liste<QShape> ??
Une telle liste, on retrouve les classes qui héritent de QShape? Si oui, j'ai été à droite; la réponse est bêtement évident.
Oui, il le ferait. Mais vous ne pourrez accéder à la QShape propriétés à moins de vous jeter des objets individuels.
Pourrais-je obtenir que dans le formulaire de réponse, y compris un exemple de comment vous pouvez mettre en œuvre que (c'est à dire, comment vous pouvez accéder à QCircle et QSquare propriétés spécifiques de la Liste<QShape>)?
Vous ne pouvez pas. Je ne sais pas pourquoi son commentaire est upvoted. Vous avez clairement l'état que vous souhaitez accéder aux différentes propriétés qui ne sont pas contenues dans le parent de la classe à l'aide de la classe de base comme le type ne fonctionnera pas.

OriginalL'auteur Djentleman | 2012-07-06

c#generics list object quadtree

7

Vous avez besoin d'utiliser de passer

Stocker les objets dans une liste avec la classe de base
```
 List<QShape> shapes = new List<QShape>
```
Vous pouvez ensuite sortie de l'objet en toute sécurité si vous savez ce que c'est par exemple
```
if(shapes[0] is QSquare)
{
     QSquare square = (QSquare)shapes[0]
} 
```
Vous pouvez également implicitement abattu objets
```
QSquare square = new Square(5,0,0,"Blue");
QShape shape =  square
```
Pour plus d'informations, lisez l'Upcasting et de Passer des sections ici

Si vous êtes d'avoir à les types de tests et de fonte lorsque vous traitez avec des articles génériques de collections, c'est un signe que quelque chose a mal tourné.
Je ne suis pas tout à fait sûr de ce que tu veux dire, c'est une alternative à une interface de type d'accès des propriétés spécifiques.
Je crois que vous pouvez utiliser l'option mot-clé dans votre exemple, il est disponible depuis un certain temps. si(monobjet est MyType)
Merci, je ne savais pas à ce sujet.
J'apprends beaucoup de choses que je ne connaissais pas sur ce site... tous les jours en fait, je pense que j'apprends quelque chose de nouveau.

OriginalL'auteur Joel
3

Vous devez mettre en œuvre une Interface. Par exemple
```
public interface IHasLength
{
    int Length;
}
```
Puis dans la mise en œuvre, vous pouvez faire
```
public class QSquare : QShape, IHasLength {
    public int sideLength;
    public QSquare(int theSideLength, int theX, int theY, string theColour) {
        this.sideLength = theSideLength;
        this.x = theX;
        this.y = theY;
        this.colour = theColour;
    }
    public int Length { get { return sideLength; } }
}
public class QCircle : QShape, IHasLength {
    public int radius;
    public QSquare(int theSideLength, int theX, int theY, string theColour) {
        this.sideLength = theSideLength;
        this.x = theX;
        this.y = theY;
        this.colour = theColour;
    }
    public int Length { get { return radius; } }
}
```
Enfin, dans votre liste:
```
List<IHasLength> shapesWithSomeLength = new List<IHasLength>();
```
Maintenant votre liste peut contenir TOUT ce qui implémente IHasLength si c'est un QCircle, QShape, ou même un QDuck si vous voulez tant qu'il implémente IHasLength.

J'aime cette réponse, mais est-il une raison particulière pour utiliser une interface, par opposition à une super-classe dans cette instance?
Parce que vos classes n'ont pas de propriété commune de tous les noms. Donc, si vous deviez créer une liste de QShape et je voulais effectuer une itération sur elle et obtenir la longueur de toutes les formes, de QCircle et QSquare vous ne pouvez pas. Si vous implémentez l'interface, puis vous serez en mesure de le faire.
Ahh, je vois. Très agréable. De temps à lire sur les interfaces! Merci 🙂
Juste une note rapide pour votre bénéfice. Je suis allé avec ce genre de démarche, sauf que j'ai changé d'IHasLength à ISpatialNode. Cette interface est pour x,y de positionnement. Plus de sens, et signifie que je peux ajouter n'importe quel objet qui nécessite le positionnement dans mon Quadtree.
Bien sûr, vous voulez utiliser les noms/propriétés de sens pour votre mise en œuvre. Je viens de choisir Length pour l'exemple puisque c'est ce que vous avez mentionné dans votre question (radius, sideLength). Je suis sûr que tout est clair maintenant 😉

OriginalL'auteur Pete
2

Vous pouvez stocker dans un List<QShape> mais cela voudrait dire que vous ne pourriez pas accéder à propriétés spécifiques à un type.

Généralement, vous pourriez aborder ce en fournissant une interface commune dans votre classe de base, et en remplaçant le comportement dans les sous-classes. De cette façon, une interface commune peut en cacher une communauté variée de comportements. Par exemple, un Grow méthode pourrait masquer la complexité croissante des éléments de différentes formes et peut être appelée sans autorisation explicite des connaissances de la forme sur laquelle il est en fonctionnement.
```
public abstract class QShape {
    public abstract void Grow(int amt);
}
public class QSquare : QShape {
    private int sideLength;
    public override void Grow(int amt)
    {
        sideLength+=amt;
    }
}
public class QCircle : QShape {
    private int radius;
    public override void Grow(int amt)
    {
        radius+=amt;
    }
}
```
QShape devrait également être abstrait. Aussi, je ne vois pas l'utilisation d'une interface dans votre exemple.
J'utilise le terme d'interface dans un lâche de la mode. Tous les objets ont une interface en vertu de l'offre des méthodes et des propriétés... et pas seulement ceux qui héritent d'un interface mise en œuvre.
Gotcha... merci.
J'aime bien, semblable à Pete de réponse. Merci!

OriginalL'auteur spender

Est-ce que vous souhaitez?

public class QShape
{
protected QShape() { }
public int x { get; set; }
public int y { get; set; }
public string colour { get; set; }
}
public class QCircle : QShape
{
public int radius;
public QCircle(int theRadius, int theX, int theY, string theColour)
{
this.radius = theRadius;
this.x = theX;
this.y = theY;
this.colour = theColour;
}
}
public class QSquare : QShape
{
public int sideLength;
public QSquare(int theSideLength, int theX, int theY, string theColour)
{
this.sideLength = theSideLength;
this.x = theX;
this.y = theY;
this.colour = theColour;
}
}
class Program
{
static void Main(string[] args)
{
List<QShape> list = new List<QShape>();
list.Add(new QCircle(100, 50, 50, "Red"));
list.Add(new QCircle(100, 400, 400, "Red"));
list.Add(new QSquare(50, 300, 100, "Blue"));
foreach (var item in list.OfType<QCircle>())
{
item.radius += 10;
}
foreach (var item in list.OfType<QSquare>())
{
item.sideLength += 10;
}
}
}

Ouais, c'est exactement le genre de chose que je suis après, merci 🙂
Une question: ne Serait-il pas plus efficace pour parcourir la liste une fois et d'effectuer des actions sur les différents types à l'aide des instructions conditionnelles dans dit itération, plutôt que de parcourir en deux fois (une fois pour chaque forme) que vous avez ici?
Oui, mais...Pour les petites listes (<10 000 éléments), il fait probablement pas de différence. C'est vraiment pas clair à partir de l'OP de ce que les objectifs et les exigences.

OriginalL'auteur ja72

1

J'ai l'impression de manquer quelque chose mais...
```
List<QCircle> circleObjects = new List<QCircle>();
```
et
```
List<QSquare> squareObjects = new List<QSquare>();
```
fonctionne parfaitement bien.

EDIT:

Ah, je ne comprenais pas ce qui était demandé.

Oui, que votre QCircle et QSquare les classes héritent de QShape, vous pouvez le faire.
```
List<QShape> shapes= new List<QShape>();
```
Il est intéressant de noter que si vous souhaitez accéder à la radius propriété de tous les QCircle's dans cette liste, alors vous allez avoir à filtrer la liste en fonction de leur type.

L'OP veut une Liste<T>, qui comprendra à la fois. Par conséquent, il serait Liste<QShape>.
Oui, ça fonctionne, mais il veut UNE liste de tenir n'importe quel type de QShape, QCircle, et QSquare.
J'aurais été plus clair, mais je suis désireux d'une seule liste, si possible.
Votre modifier clarifier les choses, merci 🙂

OriginalL'auteur Alastair Pitts
1

Vous pouvez utiliser Ian Mercer commentaire List<QShape>

Et voici comment le remplir:
```
List<QShape> shapes = new List<QShape>();
QCircle circle = new QCircle(); 
shapes.Add(circle);
```
Lui unbox:
```
QCircle circle = (QCircle) shapes[0];
```
Si vous avez besoin d'appeler une méthode, au large de la classe de base, pas besoin de unbox viens de l'utiliser.

Bonne réponse, très simple et pourtant instructif. Joël réponse est similaire, mais un peu plus détaillé, mais merci quand même!

OriginalL'auteur Chris Gessler
-1

Stockage

Vous êtes déjà sur la bonne voie avec vos définitions de classe. Ce que vous avez à faire est de faire une List de la super-classe (dans ce cas, QShape), qui sera en mesure de contenir tous vos formes.

Voici un exemple de la façon dont vous feriez:
```
List<QShape> objects = new List<QShape>();
objects.add(new QCircle(...));
objects.add(new QSquare(...));
```
Accès

Le problème ici est de différencier ce qui est ce que une fois que tout est dans la liste. C'est fait avec le getType() et typeof() méthodes de C#. (Jon Skeet a une excellente réponse sur la façon de le faire). En gros, ça ressemble à ça:
```
if(objects.get(some_position).getType() == typeof(QCircle))
QCircle circle = objects.get(some_position);
else if(/* like above with QSquare */)
QSquare square = objects.get(some_position);
```
Après vous faites cela, vous pouvez continuer à utiliser vos objets comme normal. Mais si vous essayez d'accéder à partir de la liste, vous pouvez uniquement utiliser les méthodes et les variables qui QShape a, comme chaque objet mis dans la liste sera jeté à elle.

WTF est des objets.get().getType() ?? Et pourquoi ne pas la raccourcir si(monobjet est MyType)
Même si certains peuvent apparaître pour être à l'extérieur, je comprends ce que vous dites, alors merci!
essais d'un type de l'objet pour l'égalité avec un type connu n'est pas le même que le is de l'opérateur (et 99% du temps, le programmeur voulait le comportement de la is de l'opérateur, de toute façon, de sorte que le type de contrôle d'égalité est généralement un bug).
Je faisais allusion à la uncompilable (non-C#) code

OriginalL'auteur Jon Egeland

-1

public Class abstract  Base<T>
{
public abstract List<T>GetList();
}

ensuite ce faire

public class className:Base<ObjectName>
{
public override List<T>GetList()
{
//do work here 
}
}

Une explication serait utile.

OriginalL'auteur Bulelani Cimani

Vous devez vous connecter pour publier un commentaire.

Stockage

Accès