How to omit a value in a select lambda?

Question

I want to make a simple CSV parser. It should go through a list of comma separated values and put them in a IList<int>. The values are expected to be integer numbers. In case a value is not parseable, I just want to omit it.

This is the code I have so far:

csv.Split(',').Select(item =>
{
    int parsed;
    if (int.TryParse(item, out parsed))
    {
        return parsed;
    }
    continue; //is not allowed here
}).ToList();

However, the use of continue is (of course) not allowed here. How to omit a value in my select implementation?

Note: Of course could I use a foreach or a LINQ expression, but I wonder how to do it with a lambda.

Answer 1

How about:

public static IEnumerable<int> ExtractInt32(this IEnumerable<string> values) {
    foreach(var s in values) {
        int i;
        if(int.TryParse(s, out i)) yield return i;
    }
}

then:

var vals = csv.Split(',').ExtractInt32().ToList();

The nice things here:

• avoids magic "sentinal" numbers (like int.MinValue)
• avoids a separate and disconnected "it is valid" / "parse" step (so no duplication)

Answer 2

Select transforms a value. It doesn't filter. Where is doing that:

csv.Split(',')
   .Select(item =>
           {
               int parsed;
               return new { IsNumber = int.TryParse(item, out parsed), 
                            Value = parsed };
           })
   .Where(x => x.IsNumber)
   .Select(x => x.Value);

Additionally, please see this answer for a clever, short way of doing it. Please note that the meaning of "clever" isn't entirely positive here.

Answer 3

I think you have three options:

1. Use SelectMany instead which will allow you to return as empty enumerable for elements you wish to omit (and an enumerable of length 1 otherwise).
2. Use an int value you are sure won't be in the set (e.g. -1) to represent 'omitted' and filter them out afterwards. This approach is fragile as you may pick a value that subsequently appears in the set which will result in a subtle bug. (You could mitigate this by using a larger data type, e.g. long and picking a value outside the range of int but then you will need to convert back to int subsequently.)
3. Use Nullable<int> (int?) instead and filter out the null values afterwards.

1:

csv.Split(',').SelectMany(item =>
    {
        int parsed;
        if (int.TryParse(item, out parsed))
        {
            return new[] {parsed};
        }

        return Enumerable.Empty<int>();   
    }

3:

csv.Split(',').Select(item =>
    {
        int parsed;
        if (int.TryParse(item, out parsed))
        {
            return (int?) parsed;
        }

        return (int?) null;
     }
    .Where(item => item.HasValue)
    .Select(item => item.Value);

Answer 4

One way is to return some default value and then skip it.

errorInt = int.MinValue;
csv.Split(',').Select(item =>
{
    int parsed;
    if (int.TryParse(item, out parsed))
    {
        return parsed;
    }
    else
    {
        return errorInt;
    }

}).Where(val => val != errorInt).ToList();

Answer 5

Why not to use Where on array and only then select proper ints

csv.Split(',')
    .Where(item => 
          { 
              int parsed; 
              return int.TryParse(item, out parsed); 
          })
    .Select(item => Convert.ToInt32(item));

Answer 6

try this:

int dummy;
sv.Split(',').Where(c => int.TryParse(c,out dummy)).Select(c => int.Parse(c));

The int.TryParse(..) just checks if it is a valid string to be translated into an int. The out parameter is just ignored - we cont need it.

We know that only those string values that "makes-it" to the Select() are values that can be safetly parsed as int's.

Answer 7

I would probably just use:

csv.Split(',').Where(item => isValid(item)).Select(item => TransformationExpression(item));

or,

csv.Split(',').Select(item => ReturnsDummyValueIfInvalid(item)).Where(item => item != DummyValue);

Answer 8

int TempInt;
List<int> StuffIWant = csv.Split(',').Where(item => int.TryParse(item, TempInt)).ToList();