dictionary in while loop and removing items in dictionary

Question

I have a dictionary where if the item in the dictionary passes through all the processing I want to remove it.

            var dictEnum = dictObj.GetEnumerator();
            while (dictEnum.MoveNext())
            {
                 Parallel.ForEach(dictObj, pOpt, (KVP, loopState) =>
                 {
                      processAndRemove(KVP.Key);
                 });
            }

            private void processAndRemove(string keyId)
            {
               try
               {
               <does stuff>
               dictObj.Remove(keyId);
               } catch(exception ex) {
                 ...
                 <does not remove anything, wants to retry until it doesn't fail>
               }
            }

I'd like for the loop to continue processing with all the remaining items (non-removed) in the dictionary.

However, I'm getting an error. When I run a simpler version of this code I get a message stating:

Collection was modified; enumeration operation may not execute

Is there a way to do this using a dictionary?

Update:

Just to give more context. The idea behind this is so the loop continues to run if there are items left in the dictObj. So if I start with 10 and 8 pass I want to re-run the 2 that didn't pass until they do.

Answer 1

As Jalayn says, you can't remove from a collection whilst you're enumerating it. You'd have to rewrite your code so that it added to another collection, then enumerated that collection and deleted the items from the original collection.

Something like:

var toRemove = new Dictionary<int, string>() //whatever type it is

Parallel.ForEach(dictObj, pOpt, (KVP, loopState) =>
{
    toRemove.Add(KVP);
});

foreach (var item in toRemove)
{
    dictObject.Remove(item.Key);
}

Answer 2

You cannot remove an item from a collection if you are iterating over it in the same time. What you can do however is to store all elements you want to remove in a separate collection.

Then, when you're done enumerating you can iterate over your list to remove each item from the original collection.

Alternatively, check out Best way to remove multiple items matching a predicate from a c# Dictionary?. It's pretty. The accepted answer excerpt, courtesy of user @JaredPar is:

foreach ( var s in MyCollection.Where(p => p.Value.Member == foo).ToList() ) {
  MyCollection.Remove(s.Key);
}

Answer 3

I don't think you can do it using a dictionary. Instead you can do something like Dictionary.Values.ToList(), remove what you want there then reconcile the differences.

This question has more information on it Collection was modified; enumeration operation may not execute

Answer 4

Start a second collection and add values into it that you want to keep.

Answer 5

Why do you call GetEnumerator() explicitly instead of using foreach? The foreach statement is there to help you. In this case, you use MoveNext() in a loop, but you never read the Current property.

It looks like you try to use Parallel.ForEach on your dictObj, but are you sure it is of a type that is thread-safe? Probably not. What is its type?

Finally, the error text speaks for itself. You can't modify the same collection you are iterating through.

Answer 6

From the conversation that I had from: Jeppe Stig Nielsen spawned an idea to try the ConcurrentDictionary

This is my test code where I was able to remove the items from the Dictionary (from within the Parallel.Foreach loop) and the while loop continues until the count == 0 or the retryAttempts > 5

    public static ConcurrentDictionary<string, myRule> ccDict= new ConcurrentDictionary<string, myRule>();
       try
        {
            while (ccDict.Count > 0)
            {
                Parallel.ForEach(ccDict, pOptions, (KVP, loopState) =>
                {
                    //This is the flag that tells the loop do exit out of loop if a cancellation has been requested
                    pOptions.CancellationToken.ThrowIfCancellationRequested();
                    processRule(KVP.Key, KVP.Value, loopState);
                }); //End of Parallel.ForEach loop
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message.ToString());
            Console.ReadLine();
        }

    public static int processRule(string rId, myRule rule, ParallelLoopState loopState)
    {
        try
        {
            if (rId == "001" || rId == "002")
            {
                if (rId == "001" && ccDict[rId].RetryAttempts == 2)
                {
                    operationPassed(rId);
                    return 0;
                }
                operationFailed(rId);
            }
            else
            {
                operationPassed(rId);
            }
            return 0;
        }
        catch (Exception ex)
        {
            Console.WriteLine("failed : " + ex.Message.ToString());
            return -99;
        }
    }

    private static void operationPassed(string rId)
    {
        //Normal Operation
        ccDict[rId].RulePassed = true;
        ccDict[rId].ExceptionMessage = "";
        ccDict[rId].ReturnCode = 0;

        Console.WriteLine("passed: " + rId + " Retry Attempts : " + ccDict[rId].RetryAttempts.ToString());

        rule value;
        ccDict.TryRemove(rId, out value);
    }

    private static void operationFailed(string ruleId)
    {
        //This acts as if an EXCEPTION has OCCURED
        int retryCount = 0;

            ccDict[rId].RulePassed = false;
            ccDict[rId].RetryAttempts = ccDict[rId].RetryAttempts + 1;
            ccDict[rId].ExceptionMessage = "Forced Fail";
            ccDict[rId].ReturnCode = -99;

            ccDict.TryUpdate(rId, ccDict[rId], ccDict[rId]);

            if (ccDict[rId].RetryAttempts >= 5)
            {
                Console.WriteLine("Failed: " + rId + " Retry Attempts : " + ccDict[rId].RetryAttempts.ToString() + " : " + ccDict[rId].ExceptionMessage.ToString());
                cancelToken.Cancel();
            }
    }

    public class myRule
    {
        public Boolean RulePassed = true;
        public string ExceptionMessage = "";
        public int RetryAttempts = 0;
        public int ReturnCode = 0;


        public myRule()
        {
            RulePassed = false;
            ExceptionMessage = "";
            RetryAttempts = 0;
            ReturnCode = 0;
        }
    }