.NET Liste meilleure approche

Question

J'ai une liste qui est déclarée ci-dessous, au début je par défaut la liste des éléments à {-1, -}. S'il vous plaît noter que tout au long du programme, la taille de la liste est fixée à 2.

List<int> list = new List<int>(new int[] {-1, -1}); 

Ma question concerne, quelle serait la meilleure approche si je dois remplacer les deux valeurs dans la liste.

int x = GetXValue(); 
int y = GetYValue(); 

Approche 1:

list = new List<int>(new int[] {x, y}); 

Approche 2:

list[0] = x; 
list[1] = y; 

Quelle serait une meilleure approche? Avec la deuxième approche, même si je suis sûr qu'il y a 2 valeurs initiales, je peux courir le risque de l'exception Argument index out of range. Mais la première approche pourrait manger plus de mémoire (corrigez-moi si je me trompe!) Puisque je crée une nouvelle liste à chaque fois.

est-il un plus simple, et/ou une meilleure solution

Answer 1

Ou est-il une solution plus simple et mieux?

Oui. Étant donné que la liste a une taille fixe, utilisez un objet réel tel que System.Drawing.Point:

Point p = new Point(1, -1); 
p = new Point(5, 10); 
Console.WriteLine("X = {0}, Y = {1}", p.X, p.Y); 

Answer 2

Peut-être que je ne comprends pas votre scénario, mais je pense qu'une meilleure solution serait un simple tableau ??

int[] list = new int[] { -1, 1 }; 

Answer 3

Je vous recommande d'utiliser un tableau, ce qui signifie que la collection reste à une taille fixe et la deuxième méthode pour y accéder. Alors:

int[] array = new[] { -1, -1 }; 

puis pour le changer:

array[0] = x; 
array[1] = y; 

Étant donné que le tableau ne change pas de taille, et 2 valeurs sont allouées, vous ne serez pas obtenir un IndexOutOfRangeException. Je n'utiliserais généralement pas la première méthode pour modifier le contenu d'une collection - en général, il vaut mieux modifier un objet existant que créer et nouveau.

---

En passant, vous pouvez écrire un initialiseur pour une List<T> comme:

new List<int> {-1, -1}; 

Answer 4

Cela ressemble il veut encapsuler, qui supprimerait la complexité sur le site d'utilisation.

L'encapsulation doit fournir tous les comportements, y compris en commençant à -1, -1 et en réglant à la fois X et Y en même temps. Vous pourriez faire quelque chose comme ceci:

public class ItemSet 
{ 
    public ItemSet() 
    { 
     this.X = -1; 
     this.Y = -1; 
    } 

    public int X { get; private set; } 

    public int Y { get; private set; } 

    public void SetItems(int x, int y) 
    { 
     this.X = x; 
     this.Y = y; 
    } 
} 

Answer 5

pourquoi pas une classe personnalisée, quelque chose comme, d'autant plus que c'est une taille fixe.

class MyClass { 
    public MyClass(int x, int y) { 
    } 
    public int X { get; set; } 
    public int Y { get; set; } 

    public int[] ToArray() { 
     return new[] { X, Y }; 
    } 
    public List<int> ToList() { 
     return ToArray().ToList(); 
    } 
} 

Answer 6

Struct pourrait travailler aussi

public struct Point 
{ 
    public int X { get; set; } 
    public int Y { get; set; } 

    public Point(int x, int y):this() 
    { 
     this.X = x; 
     this.Y = y; 
    } 
} 

Point p = new Point(-1, -1); 
// ... 
p.X = newX; 
p.Y = newY; 

Answer 7

approche 2 serait mieux parce que l'approche 1 cause l'allocation de mémoire inutile (la création de la nouvelle liste, et tableau, etc.)

Cependant, le fait que votre liste ne contient que 2 éléments, cela me fait penser qu'une liste est la mauvaise classe à utiliser dans votre scénario.