在linq中使用out类型[重复]

Question

可能重复：
LINQ: Select parsed int, if string was parseable to int

这可能是一个基本问题，但我想不出解决办法。我有一个字符串数组，我试图用整数解析它们。正如预期的那样，我得到了格式异常。

我怎样才能跳过“3a”并继续解析剩余的数组并使用 Linq 将整数存储到输出中。？这是更好的方法还是不做的做法？请说明在这种情况下如何使用 TryParse

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] values = { "1", "2", "3a","4" };
            List<int> output = new List<int>();

            try{
                output = values.Select(i => int.Parse(i)).ToList<int>();
            }
            catch(FormatException)
            {
                foreach (int i in output)
                    Console.WriteLine(i);
            }

            foreach (int i in output)
                Console.WriteLine(i);

            Console.ReadLine();
        }

    }
}

Answer 1

你可以使用int.TryParse

string[] values = { "1", "2", "3a","4" };
int i = int.MinValue;
List<int> output = values.Where(s => int.TryParse(s, out i))
                         .Select(s => i)
                         .ToList();

Demo

但是，Eric Lippert would not be amused。因此，如果您不想（ab）使用副作用，这将是最佳实践方法：

创建一个扩展方法，如：

public static class NumericExtensions
{
    public static int? TryGetInt(this string item)
    {
        int i;
        bool success = int.TryParse(item, out i);
        return success ? (int?)i : (int?)null;
    }
}

那么你就可以这样写了：

List<int> output = values.Select(s => s.TryGetInt())
             .Where(nullableInt => nullableInt.HasValue)
             .Select(nullableInt => nullableInt.Value)
             .ToList();

Answer 2

虽然我完全同意在 Tim Schmelter 的回答中使用 int.TryParse，但我认为他的回答依赖于未记录的实现细节，而更安全的替代方案可能是

List<int> output =
    values
    .Select(s => {
        int i;
        return int.TryParse(s, out i) ? i : default(int?);
    })
    .Where(i => i != null)
    .Select(i => i.Value)
    .ToList();

您也许可以将.Where(...).Select(...) 替换为.OfType<int>()。

您也可以将第一个 .Select(...) lambda 与明确的可重用函数放在一起：

int? MyTryParse(string s)
{
    int i;
    return int.TryParse(s, out i) ? i : default(int?);
}

List<int> output =
    values
    .Select(MyTryParse)
    .Where(i => i != null)
    .Select(i => i.Value)
    .ToList();

Answer 3

来自Tim Schmelter 答案的linq 版本

        string[] values = { "1", "2", "3a", "4" };
        int i = int.MinValue;
        var output = (from c in values
                      where int.TryParse(c, out i) 
                      select c).Select(s => int.Parse(s)).ToList();
        foreach (var item in output)
        {
            Console.WriteLine(item.ToString());
        }

Answer 4

为什么要使用 LINQ？

试试这个：

foreach(string str in values)
{
   int val;
   if(int.TryParse(str, out val))
   {
      output.Add(val);
   }
}

Answer 5

这个怎么样？受 Tim 的回答启发，但临时变量在循环内移动，因此它是并行安全的（假设字符串集合 values 是 ParallelEnumerable）。

values.Select(s =>
    {int i; return int.TryParse(s, out i) ? (int?)i : null;})
    .Where(x=>x!=null).Select(x=>x.Value);

所以给定["1", "two", "3"] 它返回[1,3]

Answer 6

List<string> output = values.Where(v => Regex.Match(v, "^(0|[1-9][0-9]*)$").Success)
                                        .ToList();

示例使用正则表达式进行更多控制，以指示哪些值被视为有效。