what is the best practice to change the element of IEnuerable?

Question

I have IEnumerable<XY> and how to change all the elements in it?

class XY
{
   public int X{get;set;}
public int Y{get;set;}
}

what I want is to adding 1 of the X

I have to change it to array ?

var arr=xys.ToArray();
for(int i=0;i<arr.Length;i++)
{
      arr[i].X+=1;
}

Answer 1

Hi @mc ,

Thanks for reaching out.

IEnumerable<T> only describes how you read items, not how they are stored. It means you can iterate through the items, but you can’t add, remove, or replace elements in the collection itself.

However, in your case, XY is a class (a reference type). That means the objects inside the IEnumerable<XY> are real instances, not copies. So while you can’t change the collection, you can safely modify the properties of each XY object.

You don’t need to convert it to an array or list just to update X. A simple iteration is enough:

foreach (var xy in xys)
{
    xy.X += 1;
}

Converting to an array with ToArray() only makes sense if you need indexed access or want to change which elements are in the collection. For just updating properties, it adds unnecessary overhead.

The only time this would not work is if XY were a struct. In that case, each iteration would give you a copy, and changes wouldn’t persist. Since XY is a class here, you’re good.

Hope this helps! If my answer was helpful - kindly follow the instructions here so others with the same problem can benefit as well.

Answer 2

Your enumerable is a collection of objects, and you are updating a property value of the objects, not replacing the object in the collection, so as suggested the most efficient approach is a foreach().

Answer 3

IEnumerable means that the elements can be enumerated:

IEnumerable<XY> elements = . . .

foreach( XY element in elements ) ++element.X;

Using LINQ extensions:

elements.All( e => { ++e.X; return true; } );

Answer 4

To modify elements in an IEnumerable<T>, you typically need to convert it to a mutable collection, such as an array or a list, because IEnumerable<T> itself does not support direct modification of its elements. Your approach of converting the IEnumerable<XY> to an array using ToArray() is a valid method to achieve this. Once you have the array, you can iterate through it and modify the properties of the objects as needed.

Here’s a concise way to do it:

var arr = xys.ToArray();  // Convert IEnumerable<XY> to an array
for (int i = 0; i < arr.Length; i++)
{
    arr[i].X += 1;  // Increment the X property of each XY object
}

Alternatively, if you want to keep the original IEnumerable<XY> intact and create a new collection with the modified values, you could use LINQ to project the changes into a new collection:

var modifiedXys = xys.Select(xy => new XY { X = xy.X + 1, Y = xy.Y });

This way, you maintain immutability of the original collection while creating a new one with the desired modifications.

---

References:

• How to: Add custom methods for LINQ queries (Visual Basic)
• Iterators