Lista de .NET mejor enfoque

Question

Tengo una lista que se declara a continuación, al principio de manera predeterminada los elementos de la lista a {-1, -}. Por favor, tenga en cuenta que a lo largo del programa el tamaño de la lista se fija en 2.

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

Mi pregunta está relacionada, lo que sería el mejor enfoque si necesito para sobrescribir los dos valores de la lista.

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

Enfoque 1:

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

Enfoque 2:

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

lo que sería un mejor enfoque? Con el segundo enfoque, aunque estoy seguro de que hay dos valores establecidos inicialmente, puedo correr el riesgo de la excepción Argument index out of range. Pero el primer enfoque podría consumir más memoria (¡corrígeme si estoy equivocado!) Ya que estoy creando una nueva lista cada vez.

¿Existe una solución más simple, y/o mejor

Answer 1

O hay una solución más sencilla y mejor ?

Sí. Dado que la lista tiene un tamaño fijo, utilice un objeto real, como 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

Tal vez no entienden su situación, pero creo que una mejor solución sería una simple matriz ??

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

Answer 3

Le recomendaría que use una matriz, lo que significa que la colección se mantiene en un tamaño fijo y el segundo método para acceder a ella. Por lo tanto:

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

y luego a cambiarlo:

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

Dado que la matriz no cambia de tamaño, y 2 valores se asignan a la misma, no obtendrá un IndexOutOfRangeException. Normalmente no utilizaría el primer método para cambiar el contenido de una colección; en general, es mejor cambiar un objeto existente que crear uno nuevo.

---

Como nota aparte, puede escribir un inicializador para una List<T> como:

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

Answer 4

Esto parece que quiere ser encapsulado, lo que eliminaría la complejidad en el lugar de uso.

La encapsulación debe proporcionar todos los comportamientos, incluso comenzando en -1, -1 y configurando X y Y al mismo tiempo. Usted podría hacer algo como esto:

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

¿por qué no una clase personalizada, algo así como, sobre todo porque es un tamaño fijo.

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 podría funcionar también

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

Enfoque 2 sería mejor porque la asignación del Método 1 causas innecesario de memoria (la creación de la nueva lista, y la matriz, etc.)

Sin embargo, el hecho que tu lista solo tenga 2 elementos me hace pensar que una lista es la clase incorrecta para usar en tu escenario.