C# 在linq中使用out类型

可能重复：

        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());
        }

这可能是一个基本问题，但我无法找到解决办法。我有一个字符串数组，我试图用整数解析它们。正如所料，我得到了格式异常

        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());
        }

我如何跳过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();
        }

    }
}

        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());
        }

您可以使用int.TryParse

        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());
        }

然后你可以写下：

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

        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());
        }

---

为什么要使用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());
        }

试试这个：

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

        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());
        }

---

示例使用Regex进行更多控制，以指示哪些值被视为有效

尽管我完全同意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();

        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());
        }

---

这个怎么样？受Tim答案的启发，但由于临时变量在循环中移动，因此假设字符串值的集合是可并行枚举的，这是并行安全的

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

        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());
        }

---

给定[1,2,3]，它会从

        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());
        }

---

这保证有效吗？我认为在Select读取第一个值之前，Where不能用第二个值覆盖I是没有技术原因的。@hvd：是的，至少在Linq To对象中是这样。虽然我目前没有可用的链接。@hvd：这个答案依赖于延迟执行LINQ到对象的实现细节。在它当前的实现中，当使用LINQ到对象时，它保证工作。我在中看到的是，这个方法是通过使用延迟执行来实现的。立即返回值是存储执行操作所需的所有信息的对象。在通过直接调用对象的GetEnumerator方法或使用Visual C中的foreach或Visual Basic中的foreach枚举对象之前，不会执行此方法表示的查询。但这允许过滤器一次对所有记录进行评估，即使当前的实现没有这样做。我最初对这段代码感到惊讶，但在稍微考虑一下“延迟执行”后，我现在明白了。这是可行的，但我想知道我的方法在LINQ中是否有效。谢谢你的回答。并非所有的解决方法都是最好使用LINQ。这对我很有帮助。但我想看看并理解如何在LINQ中使用out类型。非常感谢您的回答这也是我在回答中所做的，因此LGTM:+1用于创造性思维：只使用int.TryParse的布尔结果，忽略它的输出参数，显然是正确的。我从@Tim Schmelter先生那里得到了这个想法，谢谢你：谢谢你的回答。教了我一些东西。linq版本适合像我们这样的初学者：D@spajce：我们都在使用linq，您在使用query-而我在使用synatx方法。除此之外，这是个好主意，尽管它需要解析字符串两次。谢谢你的回答。了解了显式可重用函数