C# 循环和LINQ方法非常相似（循环稍微少一点）。IMO LINQ也在内部实例化一个一次性缓冲区。这不是正确的方法。使用异常作为控制流是一种不好的做法。在出现错误的情况下尝试捕获（我们肯定会有）会大大降低性能。是的，坦白说，这也一直困扰着我。有没有合适的方法可

---

---

循环和LINQ方法非常相似（循环稍微少一点）。IMO LINQ也在内部实例化一个一次性缓冲区。这不是正确的方法。使用异常作为控制流是一种不好的做法。在出现错误的情况下尝试捕获（我们肯定会有）会大大降低性能。是的，坦白说，这也一直困扰着我。有没有合适的方法可以忽略异常？+1现在它是我最喜欢的解决方案，比任何其他LINQ解决方案都要短（可能更快）k，我在发布模式下测试了它，需要解析20.000.000个数字，这就是结果（以记号表示）：[循环：11572190 | LINQ（DAN PAO）：13959216 | LINQ（JARED）：15543572]。此外，我还粗略地测试了每个方法的内存使用情况（通过GC.GetTotalMemory和粗暴地增加迭代次数直到OutOfMemoryException），循环和LINQ方法的内存使用情况非常相似（循环稍微少一点）。IMO LINQ也在内部实例化了一个一次性缓冲区。我不会这样做，因为你必须解析整数两次。我同意@Chaos。解析整数是这个操作中最昂贵的部分，你故意要做两次。我不会这样做，因为你必须解析整数两次。我同意@Chaos。解析整数是这个操作中最昂贵的部分，你故意做了两次。你真的需要LINQ吗？也许在这种情况下，一个非常简单的循环会更短更快…@digEmAll，不，我不需要使用LINQ。我想这将是最简单的解决方案（明白了；）。IMO在本例中，LINQ并没有使代码更干净、更短、甚至更快。许多良好的响应。我不需要可重用的东西，因为我很少会有一个

字符串[]

，需要将有效整数去掉成

int[]

，因此我选择了答案。你真的需要LINQ吗？也许在这种情况下，一个非常简单的循环会更短更快…@digEmAll，不，我不需要使用LINQ。我想这将是最简单的解决方案（明白了；）。IMO在本例中，LINQ并没有使代码更干净、更短、甚至更快。许多良好的响应。我不需要可重用的东西，因为我很少会有一个

字符串[]

，需要将有效的整数去掉成

int[]

，因此我选择了答案。我喜欢这样，但名称可能需要修改。确实，这会试图转换所有内容，但也会过滤掉失败的尝试。@ChaosPandion：是的，我想名字的“Try”部分可以用多种方式解释。我考虑过类似于

convertWhere-mably

，但我必须承认我对长方法名有偏见。我喜欢这样，但名称可能需要修改。确实，这会试图转换所有内容，但也会过滤掉失败的尝试。@ChaosPandion：是的，我想名字的“Try”部分可以用多种方式解释。我考虑了一些类似于

的东西，但我必须承认我对长方法名有偏见。我最喜欢这个答案。你必须真的眯着眼睛看不见它在做什么。这是一个问题，我不认为LINQ是最好的答案。我最喜欢这个答案。你必须真的眯着眼睛看不见它在做什么。+1这是一个问题，我认为LINQ不是最好的答案。优雅的表达，但与公认的答案不同，如果有符号字符，这不起作用。它也不会忽略空格。优雅的表达方式，但与公认的答案不同，如果有符号字符，则不起作用。它也不会忽略空白。
var values = new [] {"", "1", "2", "a", "3"};

var numbers = new [] {1, 2, 3};

public static IEnumerable<int> Convert(this IEnumerable<string> enumerable) {
  Func<string,int?> convertFunc = x => {
    int value ;
    bool ret = Int32.TryParse(x, out value);
    return ret ? (int?)value : null;
  };
  return enumerable
    .Select(convertFunc)
    .Where(x => x.HasValue)
    .Select(x => x.Value);
}

var numbers = values.Convert().ToArray();

var numbers = values.Select(
    s => {
        int n;
        if (!int.TryParse((s ?? string.Empty), out n)) 
        {
            return (int?)null;
        }
        return (int?)n;
    }
)
.Where(n => n != null)
.Select(n => n.Value)
.ToArray();

var numbers = values.Where(x => { int num = 0; return Int32.TryParse(x, out num); })
                    .Select(num => Int32.Parse(num));

public static IEnumerable<int> TryCastToInt<T>(this IEnumerable<T> values)
  int num = 0;
  foreach (object item in values) {
    if (Int32.TryParse(item.ToString(), num)) {
      yield return num;
    }
  }
}

var values = new[] { "", "1", "2", "a", "3" };
List<int> numeric_list = new List();
int num_try = 0;
foreach (string string_value in values)
{
    if (Int32.TryParse(string_value, out num_try) {
        numeric_list.Add(num_try);
    }

    /* BAD PRACTICE (as noted by other StackOverflow users)
    try
    {
        numeric_list.Add(Convert.ToInt32(string_value));
    }
    catch (Exception)
    {
        // Do nothing, since we want to skip.
    }
    */
}

return numeric_list.ToArray();

int n;
var values = new[] { "", "1", "2", "a", "3" };
var intsonly = values.Where (v=> Int32.TryParse(v, out n)).Select(x => Int32.Parse(x));

var numbers = values
    .Select(c => { int i; return int.TryParse(c, out i) ? i : (int?)null; })
    .Where(c => c.HasValue)
    .Select(c => c.Value)
    .ToArray();

public delegate bool WeakConverter<TSource, TResult>(TSource source, out TResult result);

public static IEnumerable<TResult> TryConvertAll<TSource, TResult>(this IEnumerable<TSource> source, WeakConverter<TSource, TResult> converter)
{
    foreach (TSource original in source)
    {
        TResult converted;
        if (converter(original, out converted))
        {
            yield return converted;
        }
    }
}

string[] strings = new[] { "1", "2", "abc", "3", "", "123" };

int[] ints = strings.TryConvertAll<string, int>(int.TryParse).ToArray();

foreach (int x in ints)
{
    Console.WriteLine(x);
}

1
2
3
123
private static IEnumerable<int> ParseInt32s(IEnumerable<string> value)
{
    foreach(var value in values)
    {
        int n;

        if(Int32.TryParse(value, out n))
        {
            yield return n;
        }
    }
}

string[] values;

var parsedValues = ParseInt32s(values).ToArray();

var numbers = values
    .Where(x => !String.IsNullOrEmpty(x))
    .Where(x => x.All(Char.IsDigit))
    .Select(x => Convert.ToInt32(x))
    .ToArray();