【C#】配列のDeepCopyを高速化するベンチマーク調査結果

以下のような操作を最も高速で行える方法はなにかを調べたメモ。

// 文字列の配列（ないしList）があったとして
List<string> original = ["a", "b", "c", "d", /* ... */];
// これをDeepCopy(DeepClone)する。
List<string> copy = new(original.Count);
foreach (var item in original)
{
    copy.Add(item);
}
// これを最速で行う方法を調べる。

環境は以下の通り。

BenchmarkDotNet v0.15.8, Windows 11 (10.0.26200.7623/25H2/2025Update/HudsonValley2)
Intel Core i7-14700F 2.10GHz, 1 CPU, 28 logical and 20 physical cores
.NET SDK 10.0.101
  [Host]    : .NET 6.0.28 (6.0.28, 6.0.2824.12007), X64 RyuJIT x86-64-v3
  .NET 6.0  : .NET 6.0.28 (6.0.28, 6.0.2824.12007), X64 RyuJIT x86-64-v3
  .NET 8.0  : .NET 8.0.22 (8.0.22, 8.0.2225.52707), X64 RyuJIT x86-64-v3
  .NET 10.0 : .NET 10.0.1 (10.0.1, 10.0.125.57005), X64 RyuJIT x86-64-v3

配列(string)の場合

とりあえず思いつく方法を列挙。

1. Array.Copy
2. forループで1要素ずつコピー
3. Clone
4. Enumerable.ToArray(original)
5. original.AsSpan().ToArray()
6. [.. original]

[MemoryDiagnoser]
[SimpleJob(RuntimeMoniker.Net60)]
[SimpleJob(RuntimeMoniker.Net80)]
[SimpleJob(RuntimeMoniker.Net10_0)]
[Orderer(SummaryOrderPolicy.FastestToSlowest)]
public class ArrayCopy
{
    private string[] SampleArray { get; set; } = [];

    [Params(100)]
    public int ArraySize { get; set; }

    [GlobalSetup]
    public void Setup()
    {
        SampleArray = new string[ArraySize];
        for (int i = 0; i < ArraySize; i++)
        {
            SampleArray[i] = "SampleString" + i;
        }
    }

    [Benchmark]
    public string[] CopyUsingArrayCopy()
    {
        var a = SampleArray.Length;
        var destinationArray = new string[a];
        Array.Copy(SampleArray, destinationArray, a);
        return destinationArray;
    }

    [Benchmark]
    public string[] CopyFor()
    {
        var a = SampleArray.Length;
        var destinationArray = new string[a];
        for (int i = 0; i < a; i++)
        {
            destinationArray[i] = SampleArray[i];
        }
        return destinationArray;
    }

    [Benchmark]
    public string[] CopyUsingClone()
    {
        return (string[])SampleArray.Clone();
    }

    [Benchmark]
    public string[] CopyWithLinq()
    {
        return System.Linq.Enumerable.ToArray(SampleArray);
    }

    [Benchmark]
    public string[] CopyUsingSpan()
    {
        return SampleArray.AsSpan().ToArray();
    }

    [Benchmark]
    public string[] CopyUsingCollectionExpr()
    {
        return [.. SampleArray];
    }
}

結果

うーん、謎…。
とりあえずSpanを使えば悪くなさそう。

配列(クラス)の場合

以下のようなクラスをディープコピーすることを考える。

public class SampleSubClass
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public bool Flag { get; set; } = false;

    public SampleSubClass Clone()
    {
        return new SampleSubClass()
        {
            Id = this.Id,
            Name = this.Name,
            Flag = this.Flag,
        };
    }
}

方法としては

1. forループで1要素ずつCloneしてコピー
2. Enumerable.ToArray(original.Select(x => x.Clone()))
3. original.AsSpan()+forループで1要素ずつCloneしてコピー

[MemoryDiagnoser]
[SimpleJob(RuntimeMoniker.Net60)]
[SimpleJob(RuntimeMoniker.Net80)]
[SimpleJob(RuntimeMoniker.Net10_0)]
[Orderer(SummaryOrderPolicy.FastestToSlowest)]
public class ArrayCopyWithClass
{
    private SampleSubClass[] SampleArray { get; set; } = [];

    [Params(5)]
    public int ArraySize { get; set; }

    [GlobalSetup]
    public void Setup()
    {
        SampleArray = new SampleSubClass[ArraySize];
        for (int i = 0; i < ArraySize; i++)
        {
            SampleArray[i] = new()
            {
                Id = i,
                Name = "Sample_" + i.ToString(),
                Flag = (i % 2 == 0),
            };
        }
    }

    [Benchmark]
    public SampleSubClass[] CopyForAdd()
    {
        var a = SampleArray.Length;
        var c = new SampleSubClass[a];
        for (int i = 0; i < a; i++)
        {
            c[i] = SampleArray[i].Clone();
        }
        return c;
    }

    [Benchmark]
    public SampleSubClass[] CopyUsingLinq()
    {
        return System.Linq.Enumerable.ToArray(SampleArray.Select(item => item.Clone()));
    }

    [Benchmark]
    public SampleSubClass[] CopyUsingSpan()
    {
        var a = SampleArray.Length;
        var r = new SampleSubClass[a];
        var c = r.AsSpan();
        for (var i = 0; i < a; i++)
        {
            c[i] = SampleArray[i].Clone();
        }
        return r;
    }
}

結果

とりあえずSpan経由で良さげ。

List(string)の場合

思いつく範囲で。

1. コンストラクタ経由でコピー
2. foreachで1要素ずつコピー
3. forループで1要素ずつコピー
4. Enumerable.ToList(original)
5. CollectionsMarshal.AsSpan(original).ToArray()
6. CollectionsMarshal.AsSpan+一つずつコピー
7. [.. original]

[MemoryDiagnoser]
[SimpleJob(RuntimeMoniker.Net60)]
[SimpleJob(RuntimeMoniker.Net80)]
[SimpleJob(RuntimeMoniker.Net10_0)]
[Orderer(SummaryOrderPolicy.FastestToSlowest)]
public class ListCopy
{
    private List<string> SampleList { get; set; } = [];

    [Params(100)]
    public int ArraySize { get; set; }

    [GlobalSetup]
    public void Setup()
    {
        SampleList = new(ArraySize);
        for (int i = 0; i < ArraySize; i++)
        {
            SampleList.Add("SampleString" + i);
        }
    }

    [Benchmark]
    public List<string> CopyUsingConstructor()
    {
        return new List<string>(SampleList);
    }

    [Benchmark]
    public List<string> CopyForeachAdd()
    {
        var a = SampleList.Count;
        var c = new List<string>(a);
        foreach (var item in SampleList)
        {
            c.Add(item);
        }
        return c;
    }

    [Benchmark]
    public List<string> CopyForAdd()
    {
        var a = SampleList.Count;
        var c = new List<string>(a);
        for (int i = 0; i < SampleList.Count; i++)
        {
            c.Add(SampleList[i]);
        }
        return c;
    }

    [Benchmark]
    public List<string> CopyUsingLinq()
    {
        return System.Linq.Enumerable.ToList(SampleList);
    }

    [Benchmark]
    public List<string> CopyUsingSpan1()
    {
        var c = CollectionsMarshal.AsSpan(SampleList).ToArray();
        return new List<string>(c);
    }

    [Benchmark]
    public List<string> CopyUsingSpan2()
    {
#if NET7_0_OR_GREATER
        var a = SampleList.Count;
        var r = new List<string>(a);
        CollectionsMarshal.SetCount(r, a);
        var c = CollectionsMarshal.AsSpan(r);
        for (var i = 0; i < SampleList.Count; i++)
        {
            c[i] = SampleList[i];
        }
        return r;
#endif
        throw new NotSupportedException(
            "CollectionsMarshal.SetCount is not supported in this .NET version."
        );
    }

    [Benchmark]
    public List<string> CopyUsingCollectionExpr()
    {
        return [.. SampleList];
    }
}

結果

どの環境でもnew List<string>(original)で良さそう。

List(クラス)の場合

Arrayと同様に、SampleSubClassをディープコピー(Clone関数の呼び出し)することを考える。
方法としては

1. foreachで1要素ずつCloneしてAdd
2. forループで1要素ずつCloneしてAdd
3. SetCount+forループで1要素ずつCloneして代入
4. Enumerable.ToList(original.Select(x => x.Clone()))
5. CollectionsMarshal.AsSpan(original)+forループでCloneしてAdd

[MemoryDiagnoser]
[SimpleJob(RuntimeMoniker.Net60)]
[SimpleJob(RuntimeMoniker.Net80)]
[SimpleJob(RuntimeMoniker.Net10_0)]
[Orderer(SummaryOrderPolicy.FastestToSlowest)]
public class ListCopyWithClass
{
    private List<SampleSubClass> SampleList { get; set; } = [];

    [Params(5)]
    public int ArraySize { get; set; }

    [GlobalSetup]
    public void Setup()
    {
        SampleList = new(ArraySize);
        for (int i = 0; i < ArraySize; i++)
        {
            SampleList.Add(
                new()
                {
                    Id = i,
                    Name = "Sample_" + i.ToString(),
                    Flag = (i % 2 == 0),
                }
            );
        }
    }

    [Benchmark]
    public List<SampleSubClass> CopyForeachAdd()
    {
        var a = SampleList.Count;
        var c = new List<SampleSubClass>(a);
        foreach (var i in SampleList)
        {
            c.Add(i.Clone());
        }
        return c;
    }

    [Benchmark]
    public List<SampleSubClass> CopyForAdd()
    {
        var a = SampleList.Count;
        var c = new List<SampleSubClass>(a);
        for (int i = 0; i < a; i++)
        {
            c.Add(SampleList[i].Clone());
        }
        return c;
    }

    [Benchmark]
    public List<SampleSubClass> CopyForIndex()
    {
#if NET7_0_OR_GREATER
        var a = SampleList.Count;
        var c = new List<SampleSubClass>(a);
        CollectionsMarshal.SetCount(c, a);
        for (int i = 0; i < a; i++)
        {
            c[i] = SampleList[i].Clone();
        }
        return c;
#endif
        throw new NotSupportedException(
            "CollectionsMarshal.SetCount is not supported in this .NET version."
        );
    }

    [Benchmark]
    public List<SampleSubClass> CopyUsingLinq()
    {
        return System.Linq.Enumerable.ToList(SampleList.Select(item => item.Clone()));
    }

    [Benchmark]
    public List<SampleSubClass> CopyUsingSpan()
    {
#if NET7_0_OR_GREATER
        var a = SampleList.Count;
        var r = new List<SampleSubClass>(a);
        CollectionsMarshal.SetCount(r, a);
        var c = CollectionsMarshal.AsSpan(r);
        for (var i = 0; i < a; i++)
        {
            c[i] = SampleList[i].Clone();
        }
        return r;
#endif
        throw new NotSupportedException(
            "CollectionsMarshal.SetCount is not supported in this .NET version."
        );
    }
}

結果

.NET7以降であればSetCountを使う(Span or Index指定追加)が最速。
.NET6の場合はforeachかforで良さそう。