Enumeration already finished

The only thing that strikes me there is that there's plenty of scope for the regular expression to go wrong.

For example, if the string contained 'on' or 'ON' rather than 'On'.

If there was more than one occurrence (or no occurrences) of 'On' and 'Off' in the same string.

If 'On' or 'Off' was not preceded by a space etc.

As long as you're comparing two enum values of the same type (which I can now see is the case), then there's no need to cast to int first. So this should work OK as both operands are of type ColorTimeType:

if (prevColorOn.Type != ColorTimeType.On)
{
   throw new ArgumentException("prevColorOn.Type", "Did not recieved expected ColorTimeType 'prevColorOn'.");
}




 

Vuples here a code snippet of what I am doing. I cut a lot of code out, so some code is missing. But this will answer your question of what I am doing in the function or what the Color object I created is below.

    private static Color GetColorInfo(string colorInfo)
      {
          try
          {
    
              const string FORMAT_SEQUENCE = "(^.+) (On|Off)";
              Regex r = new Regex(FORMAT_SEQUENCE);

              Match match = r.Match(colorInfo);

              Color color = new Color();
              color.ColorDateTime = dt;
              color.ColorType = (match.Groups[2].ToString() == "On") ? ColorTimeType.On : ColorTimeType.Off;
              return cycle;
          }
          catch( Exception)
          {
              throw;
          }
      }


---------------------------------------------------

This enumeration comparison below works, is there another way to do it without using the integer value of the enumeration type.

prevColorOn = GetColorInfo((string)en.Current);

                      if ((int)prevColorOn.Type != (int)ColorTimeType.On)
                      {
                          throw new ArgumentException("prevColorOn.Type", "Did not recieved expected ColorTimeType 'prevColorOn'.");
                      }

Ok. I am going to try that right now. Also below I am try to compare Enumeration value, for some reason the statement is dropping into the condition which is not valid. Because the value equal each when I step into the code.

if (prevColorOn.Type != ColorType.ColorOn)
              {
                  throw new ArgumentException("prevColorOn", "Did not recieved expected ColorType'prevColorOn'.");
              }

Well, I can't see any signs of the collection being modified in that snippet so it looks like the exception is being thrown when you attempt to access en.Current after the enumeration has finished.

Usually, this property is left undefined and no exception is thrown but it looks like this particular enumerator has been coded to thrown an exception instead.

If the snippet is within a void method, then you could prevent the Current property being accessed when the enumeration has finished by replacing (wherever it occurs):

  en.MoveNext();

with:

  if (!en.MoveNext()) return;

However, you may want to take some further action before the method returns.

Below is a snippet of what I am doing. Basically when I enumerate to go information is not there I get the error below in red. Vuples how to know if the enumeration has not finished or finished so I can do something when I get a response?

Color prevColorOn;
              Color prevColorOff;

              IEnumerator en = dataSetList.GetEnumerator();
              en.MoveNext();
              prevOn = GetCycleInfo((string)en.Current);

              if (prevColorOn.Type != ColorType.On)
              {
                  throw new ArgumentException("prevColorOn.Type");
              }

              en.MoveNext();
              prevColorOff = GetCycleInfo((string)en.Current); //Enumeration already finished

              if (prevColorOff.Type != ColorType.Off)
              {
                  throw new ArgumentException("prevColorOff.Type");
              }

              double ColorTimeUsed = (prevColor1.TimeTag - prevColor2.TimeTag).TotalSeconds;

              for (int i = 0; i < (dataSetList.Count() / 2) - 1; ++i)
              {
                  en.MoveNext();
                  Color newColorOn = GetColorInfo((string)en.Current);

                  en.MoveNext();
                  Color newColorOff = GetColorInfo((string)en.Current);
              }

Well, normally you'd know if the collection were being modified (by adding, changing or deleting elements) whilst you were enumerating it and could therefore refrain from doing so.

Is it therefore possible that the collection is being modified on a different thread or by some process which you can't control directly?

When an enumeration finishes, MoveNext will return false and will keep on returning false if you call it again.

However, if you're getting an InvalidOperationException, that suggests that the collection is being modified in some way while it's being enumerated which is not allowed.

IEnumerator en = dataSetList.GetEnumerator();
 en.MoveNext();


Just an example, if I keep trying to MoveNext, I will eventually get an Enumeration has already finished error.