.NET List best approach

I have a list which is declared below, at the start I default the list items to { -1, - }. please note that throughout the program the list size is fixed at 2.

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

My question is regarding, what would be the best approach if I need to overwrite the开发者_如何学编程 two values in the list.

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

Approach 1:

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

Approach 2:

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

What would be a better approach? With the second approach, even though I am sure there are 2 values set initially, I can run a risk of the Argument index out of range exception. But the first approach might eat more memory (correct me if I am wrong!) since I am creating a new list every time.

Is there a simpler, and/or better solution

Or is there a simpler and better solution?

Yes. Since the list has a fixed size, use a real object such as System.Drawing.Point:

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

why not a custom class, something like, especially since it is a fixed size.

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();
    }
}

Struct could work too

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;

Approach 2 would be better because Approach 1 causes unnecessary memory allocation (creating the new list, and array, etc.)

However, the fact that your list only ever has 2 items in it makes me think that a list is the wrong class to use in your scenario.

This looks like it wants to be encapsulated, which would remove the complexity at the usage site.

The encapsulation should provide all behaviors, including starting at -1, -1 and setting both X and Y at the same time. You could do something like this:

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;
    }
}

Maybe I don't understand your scenario, but I think a better solution would be a simple array??

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

I would recommend you use an array, which means the collection stays at a fixed size and the second method to access it. So:

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

and then to change it:

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

Since the array does not change size, and 2 values are allocated to it, you will not get a IndexOutOfRangeException. I would not usually use the first method to change the contents of a collection - in general it is better to change an existing object than create and new one.

Just as an aside, you can write an initialiser for a List<T> like:

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