C＃：改變數組中每個項目的值

Question

我想知道是否有內置的.NET功能來根據提供的代表的結果更改數組中的每個值。例如，如果我有一個數組{1,2,3}和一個返回每個值的平方的委託，我希望能夠運行一個採用數組和委託的方法，並返回{1,4,9}。這樣的事情是否已經存在？

Answer 1

不，我知道（替換每個元素，而不是轉換到一個新的數組或序列），但它是非常容易寫：

public static void ConvertInPlace<T>(this IList<T> source, Func<T, T> projection) 
{ 
    for (int i = 0; i < source.Count; i++) 
    { 
     source[i] = projection(source[i]); 
    } 
} 

用途：

int[] values = { 1, 2, 3 }; 
values.ConvertInPlace(x => x * x); 

中當然如果你真的不需要需要來改變現有的數組，那麼使用Select發佈的其他答案會更有用。或從.NET 2現有ConvertAll方法：

int[] values = { 1, 2, 3 }; 
values = Array.ConvertAll(values, x => x * x); 

這是假設所有的單維數組。如果你想包含矩形數組，它會變得更加棘手，特別是如果你想避免裝箱。

Answer 2

LINQ提供了使用Select擴展方法突起支持：

var numbers = new[] {1, 2, 3}; 
var squares = numbers.Select(i => i*i).ToArray(); 

也可以使用稍微不太流利Array.ConvertAll方法：

var squares = Array.ConvertAll(numbers, i => i*i); 

鐵血陣列可通過嵌套突起進行處理：

var numbers = new[] {new[] {1, 2}, new[] {3, 4}}; 
var squares = numbers.Select(i => i.Select(j => j*j).ToArray()).ToArray(); 

多維數組稍微複雜一些。我寫了下面的擴展方法，它將多維數組中的每個元素都進行投影，而不管它的級別如何。

static Array ConvertAll<TSource, TResult>(this Array source, 
              Converter<TSource, TResult> projection) 
{ 
    if (!typeof (TSource).IsAssignableFrom(source.GetType().GetElementType())) 
    { 
     throw new ArgumentException(); 
    } 
    var dims = Enumerable.Range(0, source.Rank) 
     .Select(dim => new {lower = source.GetLowerBound(dim), 
          upper = source.GetUpperBound(dim)}); 
    var result = Array.CreateInstance(typeof (TResult), 
     dims.Select(dim => 1 + dim.upper - dim.lower).ToArray(), 
     dims.Select(dim => dim.lower).ToArray()); 
    var indices = dims 
     .Select(dim => Enumerable.Range(dim.lower, 1 + dim.upper - dim.lower)) 
     .Aggregate(
      (IEnumerable<IEnumerable<int>>) null, 
      (total, current) => total != null 
       ? total.SelectMany(
        item => current, 
        (existing, item) => existing.Concat(new[] {item})) 
       : current.Select(item => (IEnumerable<int>) new[] {item})) 
     .Select(index => index.ToArray()); 
    foreach (var index in indices) 
    { 
     var value = (TSource) source.GetValue(index); 
     result.SetValue(projection(value), index); 
    } 
    return result; 
} 

上述方法可以與秩3的陣列進行測試如下：

var source = new int[2,3,4]; 

for (var i = source.GetLowerBound(0); i <= source.GetUpperBound(0); i++) 
    for (var j = source.GetLowerBound(1); j <= source.GetUpperBound(1); j++) 
     for (var k = source.GetLowerBound(2); k <= source.GetUpperBound(2); k++) 
      source[i, j, k] = i*100 + j*10 + k; 

var result = (int[,,]) source.ConvertAll<int, int>(i => i*i); 

for (var i = source.GetLowerBound(0); i <= source.GetUpperBound(0); i++) 
    for (var j = source.GetLowerBound(1); j <= source.GetUpperBound(1); j++) 
     for (var k = source.GetLowerBound(2); k <= source.GetUpperBound(2); k++) 
     { 
      var value = source[i, j, k]; 
      Debug.Assert(result[i, j, k] == value*value); 
     } 

Answer 3

使用System.Linq的你可以這樣做：

var newArray = arr.Select(x => myMethod(x)).ToArray(); 

Answer 4

LINQ查詢可以很容易地爲你解決這個問題 - 確保你引用了System.Core.dll並且有一個

using System.Linq; 

聲明。例如，如果你在一個名爲numberArray變量有你的陣列，下面的代碼會給你你尋找什麼：

var squares = numberArray.Select(n => n * n).ToArray(); 

，如果你確實需要一個數組時，才需要最後的「ToArray的」呼叫，而不是IEnumerable <int>。

Answer 5

你可以使用linq來簡化它，但要小心，不管怎樣都會發生foreach。

int[] x = {1,2,3}; 
x = x.Select((Y) => { return Y * Y; }).ToArray(); 

Answer 6

這裏是另一種M×N數組的解決方案，其中M和N在編譯時是未知的。

// credit: https://blogs.msdn.microsoft.com/ericlippert/2010/06/28/computing-a-cartesian-product-with-linq/ 
    public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences) 
    { 
     IEnumerable<IEnumerable<T>> result = new[] { Enumerable.Empty<T>() }; 
     foreach (var sequence in sequences) 
     { 
      // got a warning about different compiler behavior 
      // accessing sequence in a closure 
      var s = sequence; 
      result = result.SelectMany(seq => s, (seq, item) => seq.Concat<T>(new[] { item })); 
     } 
     return result; 
    } 


    public static void ConvertInPlace(this Array array, Func<object, object> projection) 
    { 
     if (array == null) 
     { 
      return; 
     } 

     // build up the range for each dimension 
     var dimensions = Enumerable.Range(0, array.Rank).Select(r => Enumerable.Range(0, array.GetLength(r))); 

     // build up a list of all possible indices 
     var indexes = EnumerableHelper.CartesianProduct(dimensions).ToArray(); 

     foreach (var index in indexes) 
     { 
      var currentIndex = index.ToArray(); 
      array.SetValue(projection(array.GetValue(currentIndex)), currentIndex); 
     } 
    }