Parsing string into int[] using Linq [closed]

If using C# 7.0 then you can use the var out feature:

var result = input.Split(';').Select(s => (int.TryParse(s, out int v), v))
                  .Where(pair => pair.Item1)
                  .Select(pair => pair.v);

Don't know if this is more or less readable but I personally prefer avoiding these side effected temp variables. As for the comment about it being longer and perhaps just having int.TryParse(s, out int v) ? v : null - then this will result in a collection of Nullable<int> instead of integers so depends what you prefer.

The main problem with using TryParse() style methods is, of course, that they use out parameters which don't play nice with Linq.

Because of that we actually use simple helper methods for parsing, which return tuples rather than using out parameters.

For example:

public static class Parse
{
    public static (bool wasSuccessful, int value) TryParse(string text)
    {
        bool success = int.TryParse(text, out var value);
        return (success, value);
    }
}

Then you can use Parse.TryParse rather than the int.TryParse() which IMO often makes the code more readable (although not any shorter).

Using the sample above, you can write your code like this:

var r = input.Split(';')
   .Select(Parse.TryParse)
   .Where(parse => parse.wasSuccessful)
   .Select(parse => parse.value)
   .ToArray();

Or if you prefer Linq Query Syntax (which I sometimes find more readable, but YMMV):

var s = (
    from   item in input.Split(';')
    let    parse = Parse.TryParse(item)
    where  parse.wasSuccessful
    select parse.value
).ToArray();

(Although I do feel that the ToArray() at the end there is a bit ugly...)

Here's an alternate solution using Regex.

The pattern ((?<=;)|^)[0-9]*((?=;)|$) matches numbers that are surrounded by ;;

Try it out

string i = "1;2;3;4;5;6x;7;8;9;1x0";
string pattern = "((?<=;)|^)[0-9]*((?=;)|$)";
int[] r = Regex.Matches(i, pattern).Cast<Match>().Select(x => int.Parse(x.Value)).ToArray();

Here is an alternate version using nullables:

string i = "1;2;3;4;5;6x;7;8;9;1x0";
int[] r = i.Split(';')
   .Select(s => int.TryParse(s, out int v) ? (int?) v : null)
   .Where(j => j.HasValue) 
   .Select(j => j.Value)  
   .ToArray();            

Which is more readable is a matter of personal taste. Some would prefer an loop instead of the linq.

A modified & more readable version of Gilad's excellent answer, using ValueTuples:

var integers = input.Split(';')
                    .Select(_ => (Success: int.TryParse(_, out var n), IntegerValue: n))
                    .Where(_ => _.Success)
                    .Select(_ => _.IntegerValue);