How to unchain items in list class

Question

can some one explain to me how to break the chain with a NEW statement?

Let me clarify the chain I’m talking about. When I call to a class I use the NEW statement like so

Myclass x =new Myclass();

My understanding is this creates a new empty instance of Myclass. Now correct me if I’m wrong but having a new empty instance one should be able to add what ever data the class supports?

I use this lot and would think the above to be true until adding data in such a manner

Myclass x =new Myclass();

//oldMyclass being old data that needs to be changed then 
//added back to the class as a new or duplicate entry  
x = oldMyclass[1]; 
//we change the data 
x.red= 0x54;
//we add it back 
oldMyclass.add(x); 

All is good until we edit the data after adding it say we need to change another value. We access the oldMyclass and select the proper item say its index is 2 but we only want to change the values of index 2

Myclass x =new Myclass();
x = oldMyclass[2]; 
x.red=soemvalue;
oldMyclass[2] = x; 

This will change the red value of both index 1 and index 2. How can I break the chain between index 1 and index 2?

I think I might have over simplified this question let me know.

Thanks for any information.

Edit: Here is the copy method that I tried

public static Items.SavedItem Copy(Items.SavedItem old)
        {
            Items.SavedItem x = new Items.SavedItem();
            x.generator = old.generator;
            x.hireling_class = old.hireling_class;
            x.id = old.id;
            x.item_slot = old.item_slot;
            x.owner_entity_id = old.owner_entity_id;
            x.socket_id = old.socket_id;
            x.square_index = old.square_index;
            x.used_socket_count = old.used_socket_count;
            return x;
        }

Answer 1

So let's say, for arguments sake, you have a class like this:

public MyClass
{
    public string Foo { get; set; }
}

And you have a collection

List<MyClass> myList = new List<MyClass>();

Now you create an instance of MyClass

MyClass obj1 = new MyClass() { Foo = "bar" };

Now if you do this:

myList.Add(obj1);
myList.Add(obj1);

You now have a list with TWO members, but they happen to be the same object. Whats stored in the list is a reference to the object you added, not the object itself. So myList[0] == myList[1]

Now if you did this:

MyClass item = myList[1];

And then:

item.Foo = "something else";

Both the item at index 1 and the item at index 0 will have 'Foo == "something else"' because they are the same item.

Another point that seems to be confusing you is this: myList has two items. If I do this:

MyClass item = myList[0];

myList still has two items. Indexing a collection doesn't remove it and because of that, there is no need to add the item back to the list. It's already there. All I've done is copy the reference from myList to a variable named item.

There are collections (Stack and Queue for example) that do work on the principle that you will remove items and (potentially) add them back, but List doesn't work that way.

So if you wanted to add multiple objects to myList you need to create multiple objects with the new keyword. For example:

List<MyClass> myList = new List<MyClass>();
MyClass obj1 = new MyClass() { Foo = "bar" };
myList.Add(obj1);
obj1 = new MyClass() { Foo = "something else" };    // Note: I've reused the variable, but this is a *new* object
myList.Add(obj1);

Or, if you don't need the new object assigned to a variable, you can simply if to:

List<MyClass> myList = new List<MyClass>();
myList.Add(new MyClass() { Foo = "a" });
myList.Add(new MyClass() { Foo = "b" });

Or even more compactly, you can exploit the collection initialization syntax and simply:

List<MyClass> myList = new List<MyClass>() 
{
    new MyClass() { Foo = "a" },
    new MyClass() { Foo = "b" }
}

If you want to copy an object from your list, then you need to copy each property (and if it contains other objects, you may need to copy them too). There are various ways to do this, IClonable or a copy constructor are examples, but it basically comes down to, at some point, doing something like this:

myCopy.Foo = myOriginal.Foo;
myCopy.Bar = myOriginal.Bar;
// repeat for all properties that you want to copy.

Now assuming that Foo and Bar aren't also reference types, you have a copy. If they are reference types, you have a copy, but myCopy.Foo and myOriginal.Foo are still pointing at the same object.