更改可枚举集合中的对象

Question

I have a collection that cannot be iterated through (via index), but it does implement IEnumerable .

Is there a way to replace objects in that collection when enumerating though it? I know that this is not possible in a foreach loop, but it seems like a reasonable thing to want to do.

I went so far as to consider using C#'s pointers, but those don't work with managed types.

I know that I can populate an array with all of the data, and then edit it that way, but

1. That seems very wasteful
2. Far more importantly, it loses the entire structure.

For example purposes:

public void Example(object a,object b, object c)
{
    object[] ex = {a,b,c};
    object d = new MyCustomType();
}

Without using any indexers, how can I make ex hold {a,d,c} ? Assume that the only way that I can access ex is through an enumerator. There are no Add or AddAt methods in the type (played here by object[] . Assume that the underlying structure is unknown/highly complex.

How can I do this?

Answer 1

As payo said, your statement conflict with each other. You cannot iterate through an IEnumerable yet you are in a foreach loop, which is iteration. And IEnumerable pretty much says you can enumerate through the collection. But here is my input on your question:

When enumerating through a collection you are limited on any attempt to change the data you are enumerating through. And you definitely cannot delete anything. In part this is due to the potential of changing the enumeration.

A possible approach is to create a list of items, enumerate through the list and put what you want into the list. Then reload the IEnumerable assuming they expose .Add(IEnumerable list).

In one situation I had items I wanted to delete from an IEnumerable, so I did a foreach, tracked each object I wanted to remove, then after the enumeration I did a Remove of each object that I had saved.

Nowadays, with linq, you can more easily do something like removing objects if you can phrase a well define query of what you want (leaving out what you do not want) then process against the IQueriable result set.

Answer 2

In a word: linked lists .

You haven't said whether you need to implement IEnumerable (such as for use with LINQ), or how much control you have over the mysterious collection you refer to. But if your question is fundamentally, "how can I modify some kind of collection while iterating through it in C#?"...well, this is what linked lists are actually good (and extremely efficient) at. For example:

var intList = new LinkedList<int>(new []{ 1, 4, 5, 7, 12 });
var node = intList.First;
do {
    // do stuff with node
    if (node.Value < 3){
        node.List.AddAfter(node, node.Value + 1);
    } else if(node.Value == 7) {
        var prevNode = node.Previous;
        node.List.Remove(node);
        node = prevNode;
    }

    // Get the next node
    node = node.Next;
} while (node != null);

I'm not saying you should copy your source collecting into a linked list since we don't have enough information from you. But perhaps this can show you and future readers what linked lists are for -- namely, modifying while enumerating without an index accessor.

And note, if this collection you refer to is completely hypothetical, then there is no answer with the information you have provided: IEnumerable does not require any methods for modifying the "underlying collection." In fact, IEnumerable does not require there to even be an underlying collection. For example, here's a method that returns an IEnumerable<int> with no underlying collection:

public static IEnumerable<int> Range(int minValue, int maxValue) {
    int current = minValue;
    while (current <= maxValue) {
        yield return current;
        current++;
    }
}

Answer 3

The way you describe it, theres no way I can think of to replace the items easily.
You claim that:

• There are no add/remove methods - no simple way to change
• The underlying collection's format is unkown - makes the reflection option harder to use
• You have only the enumerator exposed to you - meaning you can only foreach

The possible solutions are:

• reflect the underlying type, to learn its format and to change anything you want by means of reflection
• If possible, use deep copy,as ive already suggested. Deep copy, if you are not familiar with the term, means you will update the object you want to replace and its properties in a recursion, as deep as needed, with the parallel values from the object you want to put instead of the replaced one. This solution wont work, of course, if you care for the reference and not for the data/values of each object. There are dozens of threads which explain how to use deep copy on SO, so it shouldnt be problematic to find a sample

Answer 4

What methods of mutation does the original collection have? If it supports the removal or replacement of items, by what means does it identify items to be removed or replaced?

Some classes which implement IEnumerable or IEnumerable<T> will allow enumeration to work sensibly even when the underlying collection is modified (items which are in the collection throughout the enumeration will be returned exactly ones, those which are in the collection for part of the enumeration will be returned at most once, and those which are not the collection at all during enumeration will not be returned at all). If the class you're using behaves that way, great.

Otherwise, your best bet is probably to build a list of "edits" while you're enumerating the class, and then apply those edits after enumeration is complete.