Elegant C# method to return an IEnumerable from a function which is bool TryParse(Input, out T) and an input[,]

Question

Is there an elegant way to build an IEnumerable<T> from

bool TryParse<T>(Input, out T)

and an input of type

Input[,]

Basically I have a 2D array of Input and would like to call TryParse on each Input, if TryParse<T> returns true I will append the return value in 'out' to an IEnumerable<T>.

I can do this easily in a for loop but I wanted something more elegant. This is what I use at the moment:

        var marketInputColl = new Collection<MarketInput>();
        foreach (object o in marketInputs)
        {
            MarketInput mktInput;
            if (ExcelCache.TryGetCache<MarketInput>(o.ToString(), out mktInput))
                marketInputColl.Add(mktInput);
        }

There are "elegant" ways to do what you want, but they'll be more convoluted and harder to understand than a simple `foreach` loop. — Justin Niessner, Aug 29 '14 at 19:00
I realize that this is not a 100% duplicate, but it's a trivial extension from iterating through a 2D array. — Heinzi, Aug 29 '14 at 19:01
@Heinzi yes but using addition operator on generics is not that easy — Selman Genç, Aug 29 '14 at 19:01
`Input` is a type, I am fine using a for loop, I do not know how to add to the Enum selectively in function of the return value of TryParse in a LINQ expression. — BlueTrin, Aug 29 '14 at 19:03
@BlueTrin it would help if you show the declaration of Input and how do you plan to use it with linq with an example, — Selman Genç, Aug 29 '14 at 19:09

score 2 · Accepted Answer · answered Aug 29 '14 at 19:15

out/ref parameters don't exactly play all that well with LINQ. You can do it, but it's messy. The preferable option is to use a parsing tool that will return a nullable int (with null if the value cannot be parsed) instead of using out:

public static int? TryParse(string s)
{
    int output;
    if (int.TryParse(s, out output))
        return output;
    else
        return null;
}

You can make a comparable function for your attempts to fetch the value from the cache, so long as you don't also need to store actual null values.

This allows you to write:

var query = data.Select(item => TryGetCache(item.ToString()))
    .Where(n => n != null);

score 2 · Answer 2 · 2014-08-29T20:02:33.393

You can do it in a generic way:

static class Extensions
{
    public delegate bool TryParseDelegate<TSource>(string s, out TSource source);

    public static IEnumerable<TResult> WhereParsed<TSource, TResult>(
                                               this IEnumerable<TSource> source,
                                               TryParseDelegate<TResult> tryParse)
    {
        // check arguments against null first

        foreach (var item in source)
        {
            TResult result;
            if (tryParse(item.ToString(), out result))
            {
                yield return result;
            }
        }
    } 
}

Usage:

var result = marketInputs.Cast<object>()
                         .WhereParsed<object, MarketInput> 
                                     // need to specify explicit,
                                    // out param type cannot be inferred from usage
                              (ExcelCache.TryGetCache).ToList();

Nicholas Carey · Answer 3 · 2014-08-29T19:53:11.103

The problem with TryParse() is that it's not an implementation of any interface: you'll either need to use reflection to find the method, or (simpler), just provide a conversion delegate.

Then you can do something like this, with a 2D array (or actually, arrays of any number of dimensions:

string[,] raw = { { "1" , "2" , } ,
                  { "3" , "X" , } ,
                  { "5" , "6" , } ,
                } ;
int?[] converted = raw.Cast<string>()
                   .Select( s => {
                     int value ;
                     bool parsed = int.TryParse( s , out value ) ;
                     return parsed ? (int?) value : (int?)null ;
                   })
                   .ToArray()
                   ;

If your array is jagged, you'll need one more step:

string[][] raw = { new string[]{"1","2",} ,
                   new string[]{"3","X",} ,
                   new string[]{"5","6",} ,
                 } ;
int?[] converted = raw.Cast<string[]>()
                   .SelectMany( s => s )
                   .Select( s => {
                     int  value ;
                     bool parsed = int.TryParse( s , out value ) ;
                     return parsed ? (int?) value : (int?)null ;
                   })
                   .ToArray()
                   ;

Given your example:

var marketInputColl = new Collection<MarketInput>();

foreach (object o in marketInputs)
{
  MarketInput mktInput;
  if (ExcelCache.TryGetCache<MarketInput>(o.ToString(), out mktInput))
    marketInputColl.Add(mktInput);
}

We can take the same basic approach:

Collection<MarketInput> collection = new Collection<MarketInput>(
  marketInputs
  .Cast<object>()
  .Select( o => o.ToString() )
  .Select( s => {
    MarketInput v ;
    bool parsed = ExcelCache.TryGetCache<MarketInput>( s , out v ) ;
    return parsed ? v : null ;
  })
  .Where( x => x != null )
  .ToList()
  ) ;

Elegant C# method to return an IEnumerable from a function which is bool TryParse(Input, out T) and an input[,]

3 Answers3