List newList new List Unexpected Behavior

Question

 private void SomeVoid(){
      ......
      List<myClass> newList = new List<myClass> ;
      newList = someList;
      ......
      ......logic
      List<myClass> newList2 = new List<myClass> ;
      newList2 = newList;
      ......
      ...... logic
      List<myClass> newList3 = new List<myClass> ;
      newList3 = newList2;
      ...... more logic
     someList[cnt]._points = newList3[cnt]._points;
      ......
 }

**At this point in the program someList[cnt] is not only receiving that one particular variable but all other variables associated with newList3[cnt] .

 public class myClass{
     public int _memberNo;
     public int _points;
     public int _rank;
     public string _name;
     public int[] _games;
 }

Good Evening All: Above I have an example of my code {as an example} that is currently, completely befuddling me.

Expected Behavior: Well, how I understand it to be. The first line is meant to "create" and "reference" a new List<> of type myClass, newList. The second line of code is meant to set the values of newList = to the values of someList which is of the same type myClass. This works, this behavior is fine. Changing or assigning value to only one variable in someList[] should not affect the other variables in someList[].

Observed Behavior: Tum tum tum!! Assigning a single variable in someList[] from newList3[] assigns all other variables found in newlist3[]

Questions: Yes, 5 of them. Please Note that Q1 to Q3 has been answered by @incorrect 's comment. I would please still like an answer to accept.

Am I expecting the wrong Behavior from my declarations/script?
Is the Observed Behavior = Intended Behavior?
Additionally Is the Observed Behavior - A Reference as Apposed to a new Declaration thing?
If so, How would I achieve the Expected Behavior? That is create a newList that only holds the same values as someList, that can be used to only change, affect the intended variable as above.
If you would be so kind, please reference some material that i could understand this better? If an explanation would be considered a far to daunting task :) . {I honestly don't mind reading up on this myself. I'm just not finding any documentation at this time.}

Additional Information: --Unity Science!!-- {Why so many newList*{I have been informed of this, see comments}*? Round Robin Calculator :/ Rankings :/ Points :/ Tie breaker :/ Unity Noob :/ etc.}

C# {or OOP programming in general} is not my 'first language', so please mind the lingo |:0. Classically Trained in Pascal.

Unity Personal 5.0.2f1, Mono 4.0.1, Win 7 Ultimate Service Pack none ^.

Yes I have looked for similar questions, Google, Unity Answers, stack exchange and Bing {at this point I was willing to try anything}. I must be looking for the wrong thing.

Barring all of this, my program works perfectly fine, no bugs, no nothing. I just want to make sure I'm understanding this before moving on to new projects. If I'm honest the behavior is a little of a bonus. But it is for the most part not the Behavior I was looking for.

this As I understand it: temporary declaration List<> of Type Class Declaration in void/function.

Edit: Typo and Some Declarations, moved to help at some point as I was unaware that Default was not the place for this Q.

Answer 1

Since Q1 through Q3 have been answered by @incorrect, I'll answer the fourth (hopefully my explanation does enough to answer the fifth too).

If so, How would I achieve the Expected Behavior? That is create a newList that only holds the same values as someList, that can be used to only change, affect the intended variable as above.

To copy or clone a List into another List (or shallow copy), you can use the new List<T>(IEnumerable<T> collection) constructor. It copies the elements of collection into the List being instantiated. Thus to copy the elements of someList into newList, you will use

 newList = new List<myClass>(someList);

If you go ahead and use this code in your method, you'll still notice the same problems. Even though the Lists are two different instances, changes made in newList are still reflected in someList. Why?

This is because objects of a class in C# are stored and called by reference, which is why although newList and someList have different copies of the reference to each object initially added to someList, both the references still point to the same object in memory. Which is why you can say that both the Lists indirectly contain the same objects.

To get around this problem, you could either implement a Clone() method or a copy constructor in myClass. For this case, I'd use the latter, which would be implemented as follows:

 public myClass(myClass other) 
 {
     _memberNo = other._memberNo;
      _points = other._points;
     // And so on
 }

Since you need to do what is called a deep copy, you can't use the new List<T>(IEnumerable<T> collection) constructor, since it performs just a shallow copy of the collection. Instead, you will have to instantiate each object yourself. The code to do that:

 // We're instantiating the list to the desired capacity beforehand so that
 // newList doesn't have to be resized
 newList = new List<myClass>(someList.Count);
 
 foreach(myClass item in someList)
     newList.Add(new myClass(item));

You can also refer to this question on Stackoverflow, which shows you many more methods (mostly including Linq, which I didn't use because I don't know whether you know about it).

EDIT: Code conventions tip: class and method names in C# use PascalCase, so the name of the class should be MyClass instead of myClass.

List newList new List Unexpected Behavior

1 Reply

@Evil Tak , Thanks for great explanation and example. I will be accepting your answer :D. Now I can move on to the next project!

Your answer

Follow this Question

Related Questions