How do I change my new list without changing the original list?

Question

I have a list that gets filled in with some data from an operation and I am storing it in the memory cache. Now I want another list which contains some sub data from the list based on some condition.

As can be seen in the below code I am doing some operation on the target list. The problem is that whatever changes I am doing to the target list is also being done to the mainList. I think its because of the reference is same or something.

All I need is that operation on the target list not affect data inside the main list.

List<Item> target = mainList;
SomeOperationFunction(target);

 void List<Item> SomeOperationFunction(List<Item> target)
{
  target.removeat(3);
  return target;
}

Answer 1

You need to clone your list in your method, because List<T> is a class, so it's reference-type and is passed by reference.

For example:

List<Item> SomeOperationFunction(List<Item> target)
{
  List<Item> tmp = target.ToList();
  tmp.RemoveAt(3);
  return tmp;
}

Or

List<Item> SomeOperationFunction(List<Item> target)
{
  List<Item> tmp = new List<Item>(target);
  tmp.RemoveAt(3);
  return tmp;
}

or

List<Item> SomeOperationFunction(List<Item> target)
{
  List<Item> tmp = new List<Item>();
  tmp.AddRange(target);
  tmp.RemoveAt(3);
  return tmp;
}

Answer 2

You need to make a copy of the list so that changes to the copy won't affect the original. The easiest way to do that is to use the ToList extension method in System.Linq.

var newList = SomeOperationFunction(target.ToList());

Answer 3

Build a new list first and operate on that, because List is a reference type, i.e. when you pass it in a function, you do not just pass the value but the actual object itself.

If you just assign target to mainList, both variables point to the same object, so you need to create a new List:

List<Item> target = new List<Item>(mainList);

void List<Item> SomeOperationFunction() makes no sense, because either you return nothing (void) or you return a List<T>. So either remove the return statement from your method or return a new List<Item>. In the latter case, I would rewrite this as:

List<Item> target = SomeOperationFunction(mainList);

List<Item> SomeOperationFunction(List<Item> target)
{
    var newList = new List<Item>(target);
    newList.RemoveAt(3);
    return newList;
}

Answer 4

I tried many of the answers above. On all the ones I tested, an update to the new list modifies the original. this is what works for me.

var newList = JsonConvert.DeserializeObject<List<object>>(JsonConvert.SerializeObject(originalList));
return newlist.RemoveAt(3);

Answer 5

Even if you create a new list, the references to the items in the new list will still point to the items in the old list, so I like to use this extension method if I need a new list with new references...

public static IEnumerable<T> Clone<T>(this IEnumerable<T> target) where T : ICloneable
{
    If (target.IsNull())
        throw new ArgumentException();

    List<T> retVal = new List<T>();

    foreach (T currentItem in target)
        retVal.Add((T)(currentItem.Clone()));

    return retVal.AsEnumerable();
}

Answer 6

Your target variable is a reference type. This means that anything you do to it will be reflected in the list you pass into it.

To not do that, you are going to need to create a new list in the method, copy target contents to it, and then perform the remove at operation on the new list.

About Reference and Value Types

Answer 7

Since a List is a reference type, what is passed to the function is a reference to the original list.

See this MSDN article for more information about how parameters are passed in C#.

In order to achieve what you want, you should create a copy of the list in SomeOperationFunction and return this instead. A simple example:

void List<Item> SomeOperationFunction(List<Item> target)
{
  var newList = new List<Item>(target);
  newList.RemoveAt(3);
  return newList; // return copy of list
}

As pointed out by Olivier Jacot-Descombes in the comments to another answer, it is important to bear in mind that

[...] the list still holds references to the same items if the items are of a reference type. So changes to the items themselves will still affect the items in both lists.

Answer 8

Your are seeing the original list being modified because, by default, any non-primitive objects, are passed by reference (It is actually pass by value, the value being the reference, but that is a different matter).

What you need to do is clone the object. This question will help you with some code to clone a List in C#: How do I clone a generic list in C#?

Answer 9

Instead of assigning mainList to target, I would do: target.AddRange(mainList);

Then you will have a copy of the items instead of a reference to the list.

Answer 10

Just make sure that you initialize the new list with a list created by copying the elements of the source list.

List<Item> target = mainList; Should be List<item> target = new List<Item>(mainList);

Answer 11

You'll need to make a copy of the list since in your original code what you're doing is just passing around, as you correctly suspected, a reference (someone would call it a pointer).

You could either call the constructor on the new list, passing the original list as parameter:

List<Item> SomeOperationFunction(List<Item> target)
{
    List<Item> result = new List<Item>(target);
    result.removeat(3);
    return result;
}

Or create a MemberWiseClone:

List<Item> SomeOperationFunction(List<Item> target)
{
    List<Item> result = target.MemberWiseClone();
    result.removeat(3);
    return result;
}

Also, you are not storing the return of SomeOperationFunction anywhere, so you might want to revise that part as well (you declared the method as void, which should not return anything, but inside it you're returning an object). You should call the method this way:

List<Item> target = SomeOperationFunction(mainList);

Note: the elements of the list will not be copied (only their reference is copied), so modifying the internal state of the elements will affect both lists.