반응형
LINQ 쿼리에서 ToList() 또는 ToArray()를 호출하는 것이 더 나을까요?
나는 종종 내가 선언한 바로 그 쿼리를 평가하고 싶은 경우에 부딪힙니다.일반적으로 여러 번 반복해야 하고 계산 비용이 많이 들기 때문입니다.예:
string raw = "...";
var lines = (from l in raw.Split('\n')
let ll = l.Trim()
where !string.IsNullOrEmpty(ll)
select ll).ToList();
이것은 잘 작동합니다.하지만 제가 결과를 수정하지 않을 거라면, 저는 전화를 하는 것이 나을 것입니다.ToArray()에 ToList().
그러나 나는 그것이ToArray() 첫번 호에의구해현다니됩출째다▁first를 호출하여 합니다.ToList()따라서 단순히 호출하는 것보다 메모리 효율성이 떨어집니다.ToList().
내가 미쳤나요?그냥 전화할까요?ToArray()메모리가 두 번 할당되지 않는다는 것을 알고도 안전하고 안전합니까?
조건을 가 아니라면 다른제조충기하위해단는어필제고경하를 .ToList의 시나리오에서 대분의시에서오나리부▁in서.ToArray이 보더다많니 할합다당를보다 많을 것입니다.ToList.
둘 다 스토리지에 어레이를 사용하지만ToList에는 보다 유연한 제약 조건이 있습니다.배열은 컬렉션의 요소 수만큼 커야 합니다.배열이 더 크면 문제가 되지 않습니다. 지만하ToArray배열의 크기를 요소 수에 맞게 정확하게 조정해야 합니다.
조건을 하려면 이약제조충하기족을건기▁to하충족ToArray종종 하나의 할당을 더 합니다.ToList어레이가 충분히 크면 정확한 크기의 어레이를 할당하고 요소를 해당 어레이로 다시 복사합니다.어레이에 대한 증가 알고리즘이 저장해야 하는 요소의 수와 우연히 일치할 때(분명히 소수) 이러한 문제를 방지할 수 있습니다.
편집
몇 명의 사람들이 사용하지 않은 여분의 메모리를 가지고 있는 것의 결과에 대해 저에게 물었습니다.List<T> 가치.
이것은 타당한 우려 사항입니다.된 후 이 높은 하는 것이 .ToArray전방의
일반적으로 저는 이것이 더 드문 경우라고 생각합니다.많이 보는 것이 훨씬 더 일반적입니다.ToArray 짧은 입니다.ToList확실히 더 낫습니다.
여기서 핵심은 프로파일링, 프로파일링, 그리고 프로파일링입니다.
성능 차이는 미미할 것입니다.List<T>동적 크기의 어레이로 구현됩니다.둘 중 하나를 선택합니다.ToArray()(으)를 함)Buffer<T> 어레를확클래스또장는할이▁class또)ToList()은 (이를통해통▁the)을 부릅니다.List<T>(IEnumerable<T>)생성자)는 이들을 배열에 넣고 배열이 모두 맞을 때까지 배열을 확장하는 문제가 될 것입니다.
이 사실에 대한 구체적인 확인을 원하는 경우 Reflector에서 문제의 방법 구현을 확인하십시오. 거의 동일한 코드로 요약됩니다.
EDIT 2: (이것은 원래 답변에 대한 수정입니다.
벤치마크 사용.NET 성능 측정을 통해 승인된 답변이 실제로 올바른지 확인할 수 있었습니다.ToList할당된 버퍼의 빈 공간을 잘라낼 필요가 없기 때문에 일반적인 경우가 더 빠릅니다. ToArray추가 할당 및 복사 작업을 수행하여 버퍼 크기를 요소 수에 맞게 조정할 수 있습니다.
이를 확인하기 위해 다음 벤치마크가 사용됩니다.
[MemoryDiagnoser]
[ShortRunJob]
public class Benchmarks
{
[Params(0, 1, 6, 10, 42, 100, 1337, 10000)]
public int Count { get; set; }
public IEnumerable<int> Items => Enumerable.Range(0, Count).Where(i => i > 0);
[Benchmark(Baseline = true)]
public int[] ToArray() => Items.ToArray();
[Benchmark]
public List<int> ToList() => Items.ToList();
}
결과는 다음을 확인합니다.ToList대부분의 경우 10% - 15% 더 빠릅니다.
BenchmarkDotNet=v0.13.1, OS=Windows 10.0.22000
Intel Core i9-10885H CPU 2.40GHz, 1 CPU, 16 logical and 8 physical cores
.NET SDK=6.0.302
[Host] : .NET 6.0.7 (6.0.722.32202), X64 RyuJIT
DefaultJob : .NET 6.0.7 (6.0.722.32202), X64 RyuJIT
| Method | Count | Mean | Error | StdDev | Ratio | RatioSD | Gen 0 | Gen 1 | Allocated |
|-------- |------ |-------------:|-----------:|-----------:|------:|--------:|--------:|-------:|----------:|
| ToArray | 0 | 29.73 ns | 0.546 ns | 0.536 ns | 1.00 | 0.00 | 0.0067 | - | 56 B |
| ToList | 0 | 31.51 ns | 0.485 ns | 0.405 ns | 1.06 | 0.02 | 0.0105 | - | 88 B |
| | | | | | | | | | |
| ToArray | 1 | 37.36 ns | 0.314 ns | 0.294 ns | 1.00 | 0.00 | 0.0114 | - | 96 B |
| ToList | 1 | 36.75 ns | 0.605 ns | 0.537 ns | 0.98 | 0.01 | 0.0153 | - | 128 B |
| | | | | | | | | | |
| ToArray | 6 | 100.05 ns | 1.522 ns | 1.349 ns | 1.00 | 0.00 | 0.0286 | - | 240 B |
| ToList | 6 | 85.16 ns | 0.808 ns | 0.756 ns | 0.85 | 0.01 | 0.0267 | - | 224 B |
| | | | | | | | | | |
| ToArray | 10 | 137.20 ns | 2.766 ns | 2.452 ns | 1.00 | 0.00 | 0.0372 | - | 312 B |
| ToList | 10 | 123.05 ns | 2.198 ns | 1.949 ns | 0.90 | 0.01 | 0.0372 | - | 312 B |
| | | | | | | | | | |
| ToArray | 42 | 398.25 ns | 6.583 ns | 5.836 ns | 1.00 | 0.00 | 0.0877 | - | 736 B |
| ToList | 42 | 352.04 ns | 4.976 ns | 4.411 ns | 0.88 | 0.02 | 0.0887 | - | 744 B |
| | | | | | | | | | |
| ToArray | 100 | 730.80 ns | 6.501 ns | 6.081 ns | 1.00 | 0.00 | 0.1488 | - | 1,248 B |
| ToList | 100 | 705.49 ns | 9.947 ns | 9.305 ns | 0.97 | 0.01 | 0.1526 | - | 1,280 B |
| | | | | | | | | | |
| ToArray | 1337 | 8,023.57 ns | 147.388 ns | 137.867 ns | 1.00 | 0.00 | 1.6785 | 0.0458 | 14,056 B |
| ToList | 1337 | 7,980.27 ns | 138.469 ns | 122.749 ns | 1.00 | 0.02 | 1.9989 | 0.1221 | 16,736 B |
| | | | | | | | | | |
| ToArray | 10000 | 57,037.19 ns | 510.492 ns | 452.538 ns | 1.00 | 0.00 | 12.6343 | 1.7700 | 106,280 B |
| ToList | 10000 | 57,728.15 ns | 583.353 ns | 517.127 ns | 1.01 | 0.01 | 15.5640 | 5.1270 | 131,496 B |
참고로, 아래는 유감스럽게도 중간 크기 조정 및 복사 작업을 피할 수 있는 매우 특정한 경우에만 벤치마크를 수행한 원래 답변입니다.
원답:
밖은 2020년이고 모두가 사용하고 있습니다.NET Core 3.1을 사용하여 몇 가지 벤치마크를 실행하기로 결정했습니다.그물.
TL;DR: ToArray()는 컬렉션을 변형할 계획이 없는 경우 성능 면에서 더 우수하고 의도를 전달하는 작업을 더 잘 수행합니다.
편집: 코멘트에서 볼 수 있듯이, 이러한 벤치마크는 다음과 같은 이유로 표시되지 않을 수 있습니다.Enumerable.Range(...)을 합니다.IEnumerable<T> 있으며,이에 시스의크대가있지으며고다사이최, ▁by,▁optim에 의해 됩니다.ToArray()올바른 크기의 배열을 미리 지정합니다.정확한 시나리오에 대해 성능을 수동으로 테스트하는 것을 고려해 보십시오.
[MemoryDiagnoser]
public class Benchmarks
{
[Params(0, 1, 6, 10, 39, 100, 666, 1000, 1337, 10000)]
public int Count { get; set; }
public IEnumerable<int> Items => Enumerable.Range(0, Count);
[Benchmark(Description = "ToArray()", Baseline = true)]
public int[] ToArray() => Items.ToArray();
[Benchmark(Description = "ToList()")]
public List<int> ToList() => Items.ToList();
public static void Main() => BenchmarkRunner.Run<Benchmarks>();
}
결과는 다음과 같습니다.
BenchmarkDotNet=v0.12.0, OS=Windows 10.0.14393.3443 (1607/AnniversaryUpdate/Redstone1)
Intel Core i5-4460 CPU 3.20GHz (Haswell), 1 CPU, 4 logical and 4 physical cores
Frequency=3124994 Hz, Resolution=320.0006 ns, Timer=TSC
.NET Core SDK=3.1.100
[Host] : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT
DefaultJob : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT
| Method | Count | Mean | Error | StdDev | Median | Ratio | RatioSD | Gen 0 | Gen 1 | Gen 2 | Allocated |
|---------- |------ |--------------:|------------:|------------:|--------------:|------:|--------:|--------:|------:|------:|----------:|
| ToArray() | 0 | 7.357 ns | 0.2096 ns | 0.1960 ns | 7.323 ns | 1.00 | 0.00 | - | - | - | - |
| ToList() | 0 | 13.174 ns | 0.2094 ns | 0.1958 ns | 13.084 ns | 1.79 | 0.05 | 0.0102 | - | - | 32 B |
| | | | | | | | | | | | |
| ToArray() | 1 | 23.917 ns | 0.4999 ns | 0.4676 ns | 23.954 ns | 1.00 | 0.00 | 0.0229 | - | - | 72 B |
| ToList() | 1 | 33.867 ns | 0.7350 ns | 0.6876 ns | 34.013 ns | 1.42 | 0.04 | 0.0331 | - | - | 104 B |
| | | | | | | | | | | | |
| ToArray() | 6 | 28.242 ns | 0.5071 ns | 0.4234 ns | 28.196 ns | 1.00 | 0.00 | 0.0280 | - | - | 88 B |
| ToList() | 6 | 43.516 ns | 0.9448 ns | 1.1949 ns | 42.896 ns | 1.56 | 0.06 | 0.0382 | - | - | 120 B |
| | | | | | | | | | | | |
| ToArray() | 10 | 31.636 ns | 0.5408 ns | 0.4516 ns | 31.657 ns | 1.00 | 0.00 | 0.0331 | - | - | 104 B |
| ToList() | 10 | 53.870 ns | 1.2988 ns | 2.2403 ns | 53.415 ns | 1.77 | 0.07 | 0.0433 | - | - | 136 B |
| | | | | | | | | | | | |
| ToArray() | 39 | 58.896 ns | 0.9441 ns | 0.8369 ns | 58.548 ns | 1.00 | 0.00 | 0.0713 | - | - | 224 B |
| ToList() | 39 | 138.054 ns | 2.8185 ns | 3.2458 ns | 138.937 ns | 2.35 | 0.08 | 0.0815 | - | - | 256 B |
| | | | | | | | | | | | |
| ToArray() | 100 | 119.167 ns | 1.6195 ns | 1.4357 ns | 119.120 ns | 1.00 | 0.00 | 0.1478 | - | - | 464 B |
| ToList() | 100 | 274.053 ns | 5.1073 ns | 4.7774 ns | 272.242 ns | 2.30 | 0.06 | 0.1578 | - | - | 496 B |
| | | | | | | | | | | | |
| ToArray() | 666 | 569.920 ns | 11.4496 ns | 11.2450 ns | 571.647 ns | 1.00 | 0.00 | 0.8688 | - | - | 2728 B |
| ToList() | 666 | 1,621.752 ns | 17.1176 ns | 16.0118 ns | 1,623.566 ns | 2.85 | 0.05 | 0.8793 | - | - | 2760 B |
| | | | | | | | | | | | |
| ToArray() | 1000 | 796.705 ns | 16.7091 ns | 19.8910 ns | 796.610 ns | 1.00 | 0.00 | 1.2951 | - | - | 4064 B |
| ToList() | 1000 | 2,453.110 ns | 48.1121 ns | 65.8563 ns | 2,460.190 ns | 3.09 | 0.10 | 1.3046 | - | - | 4096 B |
| | | | | | | | | | | | |
| ToArray() | 1337 | 1,057.983 ns | 20.9810 ns | 41.4145 ns | 1,041.028 ns | 1.00 | 0.00 | 1.7223 | - | - | 5416 B |
| ToList() | 1337 | 3,217.550 ns | 62.3777 ns | 61.2633 ns | 3,203.928 ns | 2.98 | 0.13 | 1.7357 | - | - | 5448 B |
| | | | | | | | | | | | |
| ToArray() | 10000 | 7,309.844 ns | 160.0343 ns | 141.8662 ns | 7,279.387 ns | 1.00 | 0.00 | 12.6572 | - | - | 40064 B |
| ToList() | 10000 | 23,858.032 ns | 389.6592 ns | 364.4874 ns | 23,759.001 ns | 3.26 | 0.08 | 12.6343 | - | - | 40096 B |
// * Hints *
Outliers
Benchmarks.ToArray(): Default -> 2 outliers were removed (35.20 ns, 35.29 ns)
Benchmarks.ToArray(): Default -> 2 outliers were removed (38.51 ns, 38.88 ns)
Benchmarks.ToList(): Default -> 1 outlier was removed (64.69 ns)
Benchmarks.ToArray(): Default -> 1 outlier was removed (67.02 ns)
Benchmarks.ToArray(): Default -> 1 outlier was removed (130.08 ns)
Benchmarks.ToArray(): Default -> 1 outlier was detected (541.82 ns)
Benchmarks.ToArray(): Default -> 1 outlier was removed (7.82 us)
// * Legends *
Count : Value of the 'Count' parameter
Mean : Arithmetic mean of all measurements
Error : Half of 99.9% confidence interval
StdDev : Standard deviation of all measurements
Median : Value separating the higher half of all measurements (50th percentile)
Ratio : Mean of the ratio distribution ([Current]/[Baseline])
RatioSD : Standard deviation of the ratio distribution ([Current]/[Baseline])
Gen 0 : GC Generation 0 collects per 1000 operations
Gen 1 : GC Generation 1 collects per 1000 operations
Gen 2 : GC Generation 2 collects per 1000 operations
Allocated : Allocated memory per single operation (managed only, inclusive, 1KB = 1024B)
1 ns : 1 Nanosecond (0.000000001 sec)
(7년 후...)
몇 가지 다른 (좋은) 답변은 발생할 미세한 성능 차이에 집중되어 있습니다.
이 게시물은 단지 사이에 존재하는 의미론적 차이를 언급하기 위한 보충물일 뿐입니다.IEnumerator<T> T[]에하여 .List<T>.
가장 잘 설명된 예는 다음과 같습니다.
IList<int> source = Enumerable.Range(1, 10).ToArray(); // try changing to .ToList()
foreach (var x in source)
{
if (x == 5)
source[8] *= 100;
Console.WriteLine(x);
}
위의 코드는 예외 없이 실행되며 출력이 생성됩니다.
1234567890010
이것은 그것을 보여줍니다.IEnumarator<int>가한환에 의해 int[]열거자를 만든 후 배열이 수정되었는지 여부를 추적하지 않습니다.
변수를 했습니다.source한 사람으로서IList<int>C# 가 C# 컴파일러를 .foreach에는당▁a▁▁to에 하는 것으로 .for (var idx = 0; idx < source.Length; idx++) { /* ... */ }가 프루를 하면 C# 가 할 수입니다. 이것은 내가 사용한다면 C# 컴파일러가 할 수 있는 것입니다.var source = ...;. .현재 버전의 . NET입니다.System.SZArrayHelper+SZGenericArrayEnumerator`1[System.Int32]물론 이것은 구현 세부사항입니다.
이제, 내가 바뀌면,.ToArray()안으로.ToList()표시되는 항목:
12345
다음과 같은 폭언이 이어집니다.
컬렉션이 수정되었습니다. 열거 작업을 실행할 수 없습니다.
이 경우의 기본 열거자는 공개 변수 값 유형입니다(상자 안에 들어 있음).IEnumerator<int>가 사하기때이경상자우에를 하기 때문입니다.IList<int>).
결론적으로, 다음에 의해 생성된 열거자.List<T>는 열거, 에 의해 에 표시됩니다.T[]하지 않다.따라서 다음 중 하나를 선택할 때 이 차이를 고려하십시오..ToList()그리고..ToArray().
사람들은 종종 하나를 추가합니다. .ToArray()또는.ToList()열거자의 수명 동안 수정되었는지 여부를 추적하는 컬렉션을 우회합니다.
(만약 누군가가 그 방법을 알고 싶다면.List<>수집이 수정되었는지 여부를 추적합니다. 이 클래스에는 매번 변경되는 개인 필드가 있습니다.List<>업데이트되었습니다.사실 이 행동을 바꾸는 것은 가능할 것입니다.List<>단순히 증가하는 선을 제거함으로써_version에 시대에set의 public T this[int index]안에서 한 것처럼Dictionary<,>최근, 다른 답변에서 설명한 것처럼.)
성능 차이가 미미해야 한다는 @mquander의 의견에 동의합니다.하지만, 저는 확실히 하기 위해 그것을 벤치마킹하고 싶었습니다. 그래서 그렇게 했습니다. 그리고 그것은 중요하지 않습니다.
Testing with List<T> source:
ToArray time: 1934 ms (0.01934 ms/call), memory used: 4021 bytes/array
ToList time: 1902 ms (0.01902 ms/call), memory used: 4045 bytes/List
Testing with array source:
ToArray time: 1957 ms (0.01957 ms/call), memory used: 4021 bytes/array
ToList time: 2022 ms (0.02022 ms/call), memory used: 4045 bytes/List
각 원본 배열/목록에 1000개의 요소가 있습니다.따라서 시간과 메모리 차이가 모두 무시할 수 있다는 것을 알 수 있습니다.
내 결론: 당신은 ToList()를 사용하는 것이 좋을 것입니다.List<T>몇 바이트의 메모리가 실제로 중요하지 않은 경우 어레이보다 더 많은 기능을 제공합니다.
ToList()은 적으사경선호다니됩우용할로일반▁you▁it다▁usually▁is▁on▁if에 사용할 때 선호됩니다.IEnumerable<T>(예: ORM에서).를 알 수 , 처에시알수길없다면이를퀀,ToArray()목록과 같은 동적 길이 컬렉션을 만든 다음 이를 배열로 변환하므로 시간이 더 걸립니다.
메모리는 항상 두 번 할당됩니다. 또는 그와 비슷한 수준입니다.배열 크기를 조정할 수 없기 때문에 두 방법 모두 일종의 메커니즘을 사용하여 증가하는 컬렉션에 데이터를 수집합니다.
목록은 어레이를 내부 스토리지로 사용하고 필요할 때 용량을 두 배로 늘립니다.이는 평균적으로 항목의 2/3이 최소 한 번 재할당되었고, 절반은 최소 두 번 재할당되었으며, 절반은 최소 세 번 재할당되었다는 것을 의미합니다.이는 각 항목이 평균적으로 1.3번 재할당되었음을 의미하며, 이는 오버헤드가 매우 크지 않습니다.
또한 문자열을 수집하는 경우에는 컬렉션 자체에 문자열에 대한 참조만 포함되며 문자열 자체는 재할당되지 않습니다.
저는 사람들이 여기서 수행한 다른 벤치마크들이 부족하다는 것을 발견했습니다. 그래서 여기 제가 시도한 것이 있습니다.제 방법론에서 뭔가 잘못된 점이 발견되면 알려주세요.
/* This is a benchmarking template I use in LINQPad when I want to do a
* quick performance test. Just give it a couple of actions to test and
* it will give you a pretty good idea of how long they take compared
* to one another. It's not perfect: You can expect a 3% error margin
* under ideal circumstances. But if you're not going to improve
* performance by more than 3%, you probably don't care anyway.*/
void Main()
{
// Enter setup code here
var values = Enumerable.Range(1, 100000)
.Select(i => i.ToString())
.ToArray()
.Select(i => i);
values.GetType().Dump();
var actions = new[]
{
new TimedAction("ToList", () =>
{
values.ToList();
}),
new TimedAction("ToArray", () =>
{
values.ToArray();
}),
new TimedAction("Control", () =>
{
foreach (var element in values)
{
// do nothing
}
}),
// Add tests as desired
};
const int TimesToRun = 1000; // Tweak this as necessary
TimeActions(TimesToRun, actions);
}
#region timer helper methods
// Define other methods and classes here
public void TimeActions(int iterations, params TimedAction[] actions)
{
Stopwatch s = new Stopwatch();
int length = actions.Length;
var results = new ActionResult[actions.Length];
// Perform the actions in their initial order.
for (int i = 0; i < length; i++)
{
var action = actions[i];
var result = results[i] = new ActionResult { Message = action.Message };
// Do a dry run to get things ramped up/cached
result.DryRun1 = s.Time(action.Action, 10);
result.FullRun1 = s.Time(action.Action, iterations);
}
// Perform the actions in reverse order.
for (int i = length - 1; i >= 0; i--)
{
var action = actions[i];
var result = results[i];
// Do a dry run to get things ramped up/cached
result.DryRun2 = s.Time(action.Action, 10);
result.FullRun2 = s.Time(action.Action, iterations);
}
results.Dump();
}
public class ActionResult
{
public string Message { get; set; }
public double DryRun1 { get; set; }
public double DryRun2 { get; set; }
public double FullRun1 { get; set; }
public double FullRun2 { get; set; }
}
public class TimedAction
{
public TimedAction(string message, Action action)
{
Message = message;
Action = action;
}
public string Message { get; private set; }
public Action Action { get; private set; }
}
public static class StopwatchExtensions
{
public static double Time(this Stopwatch sw, Action action, int iterations)
{
sw.Restart();
for (int i = 0; i < iterations; i++)
{
action();
}
sw.Stop();
return sw.Elapsed.TotalMilliseconds;
}
}
#endregion
LINQPad 스크립트는 여기에서 다운로드할 수 있습니다.
결과:
위의 코드를 조정하면 다음을 확인할 수 있습니다.
- 더 작은 어레이를 다룰 때는 차이가 덜합니다.
- 처리할 때 차이는 덜 중요합니다.
int보다 s.strings의 - 큰것사를 사용합니다.
structsstrings는 일반적으로 훨씬 더 많은 시간이 걸리지만 실제로 비율을 크게 바꾸지는 않습니다.
이는 상위 투표 응답자의 결론과 일치합니다.
- 코드에서 대량의 데이터 목록을 자주 생성하지 않는 한 성능 차이를 발견할 수 없습니다. (각각 100K 문자열 목록을 1000개 만들 때는 200ms만 차이가 있었습니다.)
ToList()지속적으로 더 빨리 실행되며, 결과를 오래 유지할 계획이 없다면 더 나은 선택이 될 것입니다.
갱신하다
는 @JohnHanna의 구현에 따라 다르다고 했습니다.Select▁a▁ToList()또는ToArray()결과 컬렉션의 크기를 사전에 예측하기 위한 구현.교를(를) 대체하는 중.Select(i => i)에서 의위규따라에로Where(i => true) 에서는 현재 매우 유사한 결과를 생성하며, 에 관계없이 결과를 얻을 가능성이 더 높습니다.NET 구현.
이 게시물이 오래된 게시물인 것은 알지만, 같은 질문을 하고 조사를 한 후, 공유할 가치가 있는 흥미로운 것을 발견했습니다.
먼저, 저는 @mquander와 그의 대답에 동의합니다.성능 면에서 두 가지는 동일합니다.
하지만, 저는 리플렉터를 사용하여 다음의 방법을 살펴보았습니다.System.Linq.Enumerable확장 네임스페이스는 매우 일반적인 최적화 기능입니다.
마다, 가할때마다능,다때▁the,IEnumerable<T>는 출는에있다니습처▁to다에 됩니다.IList<T>또는ICollection<T>방법을 최적화합니다.예를 들어, 다음과 같이 봅니다.ElementAt(int).
흥미롭게도, 마이크로소프트는 다음과 같은 용도로만 최적화하기로 결정했습니다.IList<T>하지만 아닙니다.IList마이크로소프트는 다음을 사용하는 것을 선호하는 것으로 보입니다.IList<T>인터페이스
당신은 당신의 결정에 근거를 두어야 합니다.ToList또는ToArray이상적인 설계 선택을 기반으로 합니다. 수 , " 인스로반복액고세수할경원컬우하을는렉션있는덱"를 선택하십시오.ToArray나중에 컬렉션에서 큰 번거로움 없이 추가 및 제거할 수 있는 추가 기능을 원한다면 다음을 수행합니다.ToList(어레이에 추가할 수는 없지만 일반적으로 어레이에 적합한 도구는 아닙니다.)
성능이 중요한 경우에는 어떤 작업을 더 빨리 수행할지도 고려해야 합니다.현실적으로, 당신은 전화하지 않을 것입니다.ToList또는ToArray백만 번, 그러나 획득한 컬렉션에 대해 백만 번 작업할 수도 있습니다.그런 점에서[]더 낫습니다, 왜냐하면.List<>이라[]약간의 비용을 들여서효율성 비교에 대한 자세한 내용은 다음 스레드를 참조하십시오.목록<int>와 int[] 중 어느 것이 더 효율적입니까?
얼마 전에 제가 직접 검사한 결과,ToArrayㅠㅠ. 그리고 되었는지 잘 그리고 저는 시험이 얼마나 왜곡되었는지 확신할 수 없습니다.그러나 성능 차이는 매우 미미하며, 이는 이러한 쿼리를 수백만 번 루프에서 실행하는 경우에만 두드러질 수 있습니다.
답변이 많이 늦었지만 구글 사용자들에게 도움이 될 것 같습니다.
그들은 둘 다 linq를 사용해서 만들었을 때 빨았습니다.둘 다 필요한 경우 버퍼 크기를 조정하기 위해 동일한 코드를 구현합니다. ToArray하여 내적으사변환여합니다용하클부를래스로▁to▁class다▁intern를 변환합니다.IEnumerable<>4개 요소의 배열을 할당하여 배열합니다.이 값으로 충분하지 않은 경우 현재 크기의 두 배인 새 배열을 만들고 현재 배열을 복사하여 크기를 두 배로 늘립니다.마지막에 항목의 새 배열을 할당합니다.쿼리에서 129개의 요소를 반환하는 경우 ToArray는 6개의 할당 및 메모리 복사 작업을 수행하여 256개의 요소 어레이를 생성하고 129개의 다른 어레이보다 더 많이 반환하여 메모리 효율성을 높입니다.
ToList는 동일한 작업을 수행하지만 나중에 항목을 추가할 수 있으므로 마지막 할당을 건너뜁니다.목록은 linq 쿼리에서 생성되었는지 수동으로 생성되었는지 여부에 관계 없습니다.
생성을 위해 목록은 메모리가 더 좋지만 목록은 일반적인 솔루션이기 때문에 모든 작업에는 .net의 어레이에 대한 내부 범위 검사 외에 범위 검사가 추가로 필요합니다.
따라서 결과 집합을 너무 여러 번 반복할 경우 배열은 목록보다 범위 검사가 적으며 컴파일러는 일반적으로 순차적 액세스를 위해 배열을 최적화합니다.
목록을 생성할 때 용량 매개 변수를 지정하면 목록의 초기화 할당이 더 효율적일 수 있습니다.이 경우 사용자가 결과 크기를 알고 있다고 가정하여 어레이를 한 번만 할당합니다. ToList의 경우 다음 linq를 사용하는 .List<>.AddRange.
이 대답을 끝내기 위해 저는 다음 문장을 써야 합니다.
- 마지막으로 ToArray 또는 ToList를 사용하면 성능이 크게 다르지 않습니다(@EMP의 답변 참조).
- C#을 사용하고 있습니다.성능이 필요한 경우 고성능 코드를 작성하는 것에 대해 걱정할 것이 아니라 성능 코드를 잘못 작성하지 않는 것에 대해 걱정할 필요가 있습니다.
- 고성능 코드의 경우 항상 x64를 대상으로 합니다.AFAIK, x64 JIT는 C++ 컴파일러를 기반으로 하며 꼬리 재귀 최적화와 같은 재미있는 작업을 수행합니다.
- 또한 4.5를 사용하면 프로파일 기반 최적화 및 멀티코어 JIT를 즐길 수 있습니다.
- 마지막으로 비동기/대기 패턴을 사용하여 더 빠르게 처리할 수 있습니다.
이것은 오래된 질문이지만 우연히 발견한 사용자의 이익을 위해, ToArray()와 ToList()가 많이 사용되는 Linkq 문의 다중 열거를 캐싱하고 중지하는 효과가 있는 'Memoizing the Enumerable'의 대안도 있습니다.목록 또는 배열의 컬렉션 속성이 사용되지 않는 경우에도 마찬가지입니다.
메모 크기는 RX/시스템에서 사용할 수 있습니다.Interactive lib. 여기서는 설명합니다. 시스템과 함께 LINQ를 더 많이 제공합니다.대화형
(Bart De'SMet의 블로그에서 객체에 대한 링크 작업을 많이 하는 경우 강력 추천하는 읽기)
한 가지 옵션은 읽기 전용을 반환하는 고유한 확장 메서드를 추가하는 것입니다. ICollection<T>이것은 사용하는 것보다 더 나을 수 있습니다.ToList또는ToArray배열/목록의 인덱싱 속성을 사용하지 않거나 목록에서 추가/제거하려는 경우.
public static class EnumerableExtension
{
/// <summary>
/// Causes immediate evaluation of the linq but only if required.
/// As it returns a readonly ICollection, is better than using ToList or ToArray
/// when you do not want to use the indexing properties of an IList, or add to the collection.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="enumerable"></param>
/// <returns>Readonly collection</returns>
public static ICollection<T> Evaluate<T>(this IEnumerable<T> enumerable)
{
//if it's already a readonly collection, use it
var collection = enumerable as ICollection<T>;
if ((collection != null) && collection.IsReadOnly)
{
return collection;
}
//or make a new collection
return enumerable.ToList().AsReadOnly();
}
}
단위 테스트:
[TestClass]
public sealed class EvaluateLinqTests
{
[TestMethod]
public void EvalTest()
{
var list = new List<int> {1, 2, 3};
var linqResult = list.Select(i => i);
var linqResultEvaluated = list.Select(i => i).Evaluate();
list.Clear();
Assert.AreEqual(0, linqResult.Count());
//even though we have cleared the underlying list, the evaluated list does not change
Assert.AreEqual(3, linqResultEvaluated.Count());
}
[TestMethod]
public void DoesNotSaveCreatingListWhenHasListTest()
{
var list = new List<int> {1, 2, 3};
var linqResultEvaluated = list.Evaluate();
//list is not readonly, so we expect a new list
Assert.AreNotSame(list, linqResultEvaluated);
}
[TestMethod]
public void SavesCreatingListWhenHasReadonlyListTest()
{
var list = new List<int> {1, 2, 3}.AsReadOnly();
var linqResultEvaluated = list.Evaluate();
//list is readonly, so we don't expect a new list
Assert.AreSame(list, linqResultEvaluated);
}
[TestMethod]
public void SavesCreatingListWhenHasArrayTest()
{
var list = new[] {1, 2, 3};
var linqResultEvaluated = list.Evaluate();
//arrays are readonly (wrt ICollection<T> interface), so we don't expect a new object
Assert.AreSame(list, linqResultEvaluated);
}
[TestMethod]
[ExpectedException(typeof (NotSupportedException))]
public void CantAddToResultTest()
{
var list = new List<int> {1, 2, 3};
var linqResultEvaluated = list.Evaluate();
Assert.AreNotSame(list, linqResultEvaluated);
linqResultEvaluated.Add(4);
}
[TestMethod]
[ExpectedException(typeof (NotSupportedException))]
public void CantRemoveFromResultTest()
{
var list = new List<int> {1, 2, 3};
var linqResultEvaluated = list.Evaluate();
Assert.AreNotSame(list, linqResultEvaluated);
linqResultEvaluated.Remove(1);
}
}
오래된 질문이지만 항상 새로운 질문자입니다.
시스템의 출처에 따르면.린크, 헤아릴 수 없는ToList그냥 a를 돌려주는 동안ToArraya를 사용하여 a를 반환합니다.T[].
메모리 할당 정보:
하나의 개체에서 실행하는 동안,ToArray은 메모리 할당보다 한 번 더.ToList그러나 대부분의 경우 GC가 필요할 때 가비지 수집을 수행하기 때문에 신경 쓰지 않아도 됩니다.
런타임 효율성 정보:
이 질문에 의문을 제기하는 사람들은 자신의 컴퓨터에서 다음 코드를 실행할 수 있으며, 그러면 당신은 답을 얻을 수 있습니다.
class PersonC
{
public Guid uuid;
public string name;
public int age;
public bool sex;
public DateTime BirthDay;
public double weight;
}
struct PersonS
{
public Guid uuid;
public string name;
public int age;
public bool sex;
public DateTime BirthDay;
public double weight;
}
class PersonT<T> : IEnumerable<T>
{
private List<T> items;
public PersonT(IEnumerable<T> init)
{
items = new List<T>(init);
}
public IEnumerator<T> GetEnumerator() => items.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => items.GetEnumerator();
}
private IEnumerable<PersonC> C(int count)
{
for (var i = 0; i < count; ++i)
{
var guid = Guid.NewGuid();
var guidBytes = guid.ToByteArray(); //16 bytes
yield return new PersonC
{
uuid = guid,
name = guid.ToString(),
age = guidBytes[0] ^ guidBytes[7],
sex = guidBytes[14] % 2 == 0,
BirthDay = DateTime.Now.AddDays(-guidBytes[11] * 18),
weight = guidBytes[12] * 100
};
}
}
private IEnumerable<PersonS> S(int count)
{
for (var i = 0; i < count; ++i)
{
var guid = Guid.NewGuid();
var guidBytes = guid.ToByteArray(); //16 bytes
yield return new PersonS
{
uuid = guid,
name = guid.ToString(),
age = guidBytes[0] ^ guidBytes[7],
sex = guidBytes[14] % 2 == 0,
BirthDay = DateTime.Now.AddDays(-guidBytes[11] * 18),
weight = guidBytes[12] * 100
};
}
}
private void MakeLog(string test, List<long> log) =>
Console.WriteLine("{0} {1} ms -> [{2}]",
test,
log.Average(),
string.Join(", ", log)
);
private void Test1(int times, int count)
{
var test = Enumerable.Range(1, times).ToArray();
MakeLog("C.ToList", test.Select(o =>
{
var sw = new Stopwatch();
GC.Collect();
sw.Start();
var ret = C(count).ToList();
sw.Stop();
return sw.ElapsedMilliseconds;
}).ToList());
MakeLog("C.ToArray", test.Select(o =>
{
var sw = new Stopwatch();
GC.Collect();
sw.Start();
var ret = C(count).ToArray();
sw.Stop();
return sw.ElapsedMilliseconds;
}).ToList());
MakeLog("S.ToList", test.Select(o =>
{
var sw = new Stopwatch();
GC.Collect();
sw.Start();
var ret = S(count).ToList();
sw.Stop();
return sw.ElapsedMilliseconds;
}).ToList());
MakeLog("S.ToArray", test.Select(o =>
{
var sw = new Stopwatch();
GC.Collect();
sw.Start();
var ret = S(count).ToArray();
sw.Stop();
return sw.ElapsedMilliseconds;
}).ToList());
}
private void Test2(int times, int count)
{
var test = Enumerable.Range(1, times).ToArray();
var dataC1 = new PersonT<PersonC>(C(count));
var dataS1 = new PersonT<PersonS>(S(count));
MakeLog("C1.ToList", test.Select(o =>
{
var sw = new Stopwatch();
GC.Collect();
sw.Start();
var ret = dataC1.ToList();
sw.Stop();
return sw.ElapsedMilliseconds;
}).ToList());
MakeLog("C1.ToArray", test.Select(o =>
{
var sw = new Stopwatch();
GC.Collect();
sw.Start();
var ret = dataC1.ToArray();
sw.Stop();
return sw.ElapsedMilliseconds;
}).ToList());
MakeLog("S1.ToList", test.Select(o =>
{
var sw = new Stopwatch();
GC.Collect();
sw.Start();
var ret = dataS1.ToList();
sw.Stop();
return sw.ElapsedMilliseconds;
}).ToList());
MakeLog("S1.ToArray", test.Select(o =>
{
var sw = new Stopwatch();
GC.Collect();
sw.Start();
var ret = dataS1.ToArray();
sw.Stop();
return sw.ElapsedMilliseconds;
}).ToList());
}
private void Test3(int times, int count)
{
var test = Enumerable.Range(1, times).ToArray();
var dataC2 = (ICollection<PersonC>) new List<PersonC>(C(count));
var dataS2 = (ICollection<PersonS>) new List<PersonS>(S(count));
MakeLog("C2.ToList", test.Select(o =>
{
var sw = new Stopwatch();
GC.Collect();
sw.Start();
var ret = dataC2.ToList();
sw.Stop();
return sw.ElapsedMilliseconds;
}).ToList());
MakeLog("C2.ToArray", test.Select(o =>
{
var sw = new Stopwatch();
GC.Collect();
sw.Start();
var ret = dataC2.ToArray();
sw.Stop();
return sw.ElapsedMilliseconds;
}).ToList());
MakeLog("S2.ToList", test.Select(o =>
{
var sw = new Stopwatch();
GC.Collect();
sw.Start();
var ret = dataS2.ToList();
sw.Stop();
return sw.ElapsedMilliseconds;
}).ToList());
MakeLog("S2.ToArray", test.Select(o =>
{
var sw = new Stopwatch();
GC.Collect();
sw.Start();
var ret = dataS2.ToArray();
sw.Stop();
return sw.ElapsedMilliseconds;
}).ToList());
}
private void TestMain()
{
const int times = 100;
const int count = 1_000_000 + 1;
Test1(times, count);
Test2(times, count);
Test3(times, count);
}
제 기계에서 다음과 같은 결과를 얻었습니다.
그룹 1:
C.ToList 761.79 ms -> [775, 755, 759, 759, 756, 759, 765, 750, 757, 762, 759, 754, 757, 753, 763, 753, 759, 756, 768, 754, 763, 757, 757, 777, 780, 758, 754, 758, 762, 754, 758, 757, 763, 758, 760, 754, 761, 755, 764, 847, 952, 755, 747, 763, 760, 758, 754, 763, 761, 758, 750, 764, 757, 763, 762, 756, 753, 759, 759, 757, 758, 779, 765, 760, 760, 756, 760, 756, 755, 764, 759, 753, 757, 760, 752, 764, 758, 760, 758, 760, 755, 761, 751, 753, 761, 762, 761, 758, 759, 752, 765, 756, 760, 755, 757, 753, 760, 751, 755, 779]
C.ToArray 782.56 ms -> [783, 774, 771, 771, 773, 774, 775, 775, 772, 770, 771, 774, 771, 1023, 975, 772, 767, 776, 771, 779, 772, 779, 775, 771, 775, 773, 775, 771, 765, 774, 770, 781, 772, 771, 781, 762, 817, 770, 775, 779, 769, 774, 763, 775, 777, 769, 777, 772, 775, 778, 775, 771, 770, 774, 772, 769, 772, 769, 774, 775, 768, 775, 769, 774, 771, 776, 774, 773, 778, 769, 778, 767, 770, 787, 783, 779, 771, 768, 805, 780, 779, 767, 773, 771, 773, 785, 1044, 853, 775, 774, 775, 771, 770, 769, 770, 776, 770, 780, 821, 770]
S.ToList 704.2 ms -> [687, 702, 709, 691, 694, 710, 696, 698, 700, 694, 701, 719, 706, 694, 702, 699, 699, 703, 704, 701, 703, 705, 697, 707, 691, 697, 707, 692, 721, 698, 695, 700, 704, 700, 701, 710, 700, 705, 697, 711, 694, 700, 695, 698, 701, 692, 696, 702, 690, 699, 708, 700, 703, 714, 701, 697, 700, 699, 694, 701, 697, 696, 699, 694, 709, 1068, 690, 706, 699, 699, 695, 708, 695, 704, 704, 700, 695, 704, 695, 696, 702, 700, 710, 708, 693, 697, 702, 694, 700, 706, 699, 695, 706, 714, 704, 700, 695, 697, 707, 704]
S.ToArray 742.5 ms -> [742, 743, 733, 745, 741, 724, 738, 745, 728, 732, 740, 727, 739, 740, 726, 744, 758, 732, 744, 745, 730, 739, 738, 723, 745, 757, 729, 741, 736, 724, 744, 756, 739, 766, 737, 725, 741, 742, 736, 748, 742, 721, 746, 1043, 806, 747, 731, 727, 742, 742, 726, 738, 746, 727, 739, 743, 730, 744, 753, 741, 739, 746, 728, 740, 744, 734, 734, 738, 731, 747, 736, 731, 765, 735, 726, 740, 743, 730, 746, 742, 725, 731, 757, 734, 738, 741, 732, 747, 744, 721, 742, 741, 727, 745, 740, 730, 747, 760, 737, 740]
C1.ToList 32.34 ms -> [35, 31, 31, 31, 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 33, 32, 31, 31, 31, 31, 30, 32, 31, 31, 31, 31, 32, 30, 31, 31, 31, 30, 32, 31, 31, 31, 36, 31, 31, 31, 32, 30, 31, 32, 31, 31, 31, 31, 31, 32, 31, 31, 31, 31, 33, 32, 31, 32, 31, 31, 33, 31, 31, 31, 31, 31, 32, 31, 32, 31, 34, 38, 68, 42, 79, 33, 31, 31, 31, 31, 31, 30, 30, 30, 30, 31, 31, 31, 31, 32, 31, 32, 31, 31, 31, 32, 33, 33, 31, 31]
C1.ToArray 56.32 ms -> [57, 56, 59, 54, 54, 55, 56, 57, 54, 54, 55, 55, 57, 56, 59, 57, 56, 58, 56, 56, 54, 56, 57, 55, 55, 55, 57, 58, 57, 58, 55, 55, 56, 55, 57, 56, 56, 59, 56, 56, 56, 56, 58, 56, 57, 56, 56, 57, 56, 55, 56, 56, 56, 59, 56, 56, 56, 55, 55, 54, 55, 54, 57, 56, 56, 56, 55, 55, 56, 56, 56, 59, 56, 56, 57, 56, 57, 56, 56, 56, 56, 62, 55, 56, 56, 56, 69, 57, 58, 56, 57, 58, 56, 57, 56, 56, 56, 56, 56, 56]
S1.ToList 88.69 ms -> [96, 90, 90, 89, 91, 88, 89, 90, 96, 89, 89, 89, 90, 90, 90, 89, 90, 90, 89, 90, 89, 91, 89, 91, 89, 91, 89, 90, 90, 89, 87, 88, 87, 88, 87, 87, 87, 87, 88, 88, 87, 87, 89, 87, 87, 87, 91, 88, 87, 86, 89, 87, 90, 89, 89, 90, 89, 87, 87, 87, 86, 87, 88, 90, 88, 87, 87, 92, 87, 87, 88, 88, 88, 86, 86, 87, 88, 87, 87, 87, 89, 87, 89, 87, 90, 89, 89, 89, 91, 89, 90, 89, 90, 88, 90, 90, 90, 88, 89, 89]
S1.ToArray 143.26 ms -> [130, 129, 130, 131, 133, 130, 131, 130, 135, 137, 130, 136, 132, 131, 130, 131, 132, 130, 132, 136, 130, 131, 157, 153, 194, 364, 176, 189, 203, 194, 189, 192, 183, 140, 142, 147, 145, 134, 159, 158, 142, 167, 130, 143, 145, 144, 160, 154, 156, 153, 153, 164, 142, 145, 137, 134, 145, 143, 142, 135, 133, 133, 135, 134, 134, 139, 139, 133, 134, 141, 133, 132, 133, 132, 133, 131, 135, 132, 133, 132, 128, 128, 130, 132, 129, 129, 129, 129, 129, 128, 134, 129, 129, 129, 129, 128, 128, 137, 130, 131]
C2.ToList 3.25 ms -> [5, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 3, 3, 4, 4, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 4, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 3, 3, 4, 3, 3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3]
C2.ToArray 3.37 ms -> [4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 4, 9, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 4, 4, 3, 3, 4, 4, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 4, 4, 3, 4, 4, 3, 3, 4, 3, 3, 4, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 4, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 3]
S2.ToList 37.72 ms -> [38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 40, 38, 38, 39, 39, 38, 38, 38, 38, 37, 37, 37, 37, 39, 37, 37, 39, 38, 37, 37, 37, 37, 39, 38, 37, 37, 38, 37, 38, 37, 37, 38, 37, 37, 37, 38, 37, 37, 36, 37, 38, 37, 39, 37, 39, 38, 37, 38, 38, 38, 38, 38, 38, 37, 38, 38, 38, 38, 38, 37, 38, 37, 37, 38, 37, 37, 39, 41, 37, 38, 38, 37, 37, 37, 37, 38, 37, 37, 37, 40, 37, 37, 37, 37, 39, 38]
S2.ToArray 38.86 ms -> [39, 37, 39, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 38, 39, 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 38, 38, 38, 39, 37, 38, 38, 38, 38, 38, 37, 37, 38, 37, 37, 38, 38, 40, 38, 38, 38, 38, 38, 39, 38, 38, 39, 38, 38, 39, 38, 38, 40, 38, 39, 38, 38, 39, 38, 38, 38, 38, 38, 39, 38, 38, 38, 39, 39, 37, 38, 38, 39, 71, 78, 37, 37, 37, 39, 38, 38, 39, 38, 38, 38, 38, 38, 39, 38, 38, 38, 39, 38, 38, 38]
그룹 2:
C.ToList 756.81 ms
C.ToArray 774.21 ms
S.ToList 709.7 ms
S.ToArray 753.51 ms
C1.ToList 32.06 ms
C1.ToArray 56.58 ms
S1.ToList 89.43 ms
S1.ToArray 132.85 ms
C2.ToList 3.45 ms
C2.ToArray 3.36 ms
S2.ToList 41.43 ms
S2.ToArray 40.84 ms
그룹 3:
C.ToList 756.64 ms
C.ToArray 771.56 ms
S.ToList 705.42 ms
S.ToArray 749.59 ms
C1.ToList 31.45 ms
C1.ToArray 57.03 ms
S1.ToList 91.26 ms
S1.ToArray 129.77 ms
C2.ToList 3.26 ms
C2.ToArray 3.29 ms
S2.ToList 41.57 ms
S2.ToArray 40.69 ms
그룹 4:
C.ToList 729.65 ms -> [749, 730, 721, 719, 723, 743, 721, 724, 727, 722, 716, 725, 723, 726, 718, 722, 731, 722, 723, 725, 723, 722, 728, 726, 728, 718, 726, 1088, 788, 737, 729, 710, 730, 728, 717, 723, 728, 721, 722, 728, 722, 736, 723, 729, 732, 724, 726, 727, 728, 728, 726, 726, 725, 727, 725, 728, 728, 718, 724, 725, 726, 724, 726, 729, 727, 722, 722, 725, 725, 728, 724, 727, 738, 717, 726, 723, 725, 725, 727, 724, 720, 726, 726, 723, 727, 730, 723, 721, 725, 727, 727, 733, 720, 722, 722, 725, 722, 725, 728, 726]
C.ToArray 788.36 ms -> [748, 740, 742, 797, 1090, 774, 781, 787, 784, 786, 786, 782, 781, 781, 784, 783, 783, 781, 783, 787, 783, 784, 775, 789, 784, 785, 778, 774, 781, 783, 786, 781, 780, 788, 778, 785, 777, 781, 786, 782, 781, 787, 782, 787, 784, 773, 783, 782, 781, 777, 783, 781, 785, 788, 777, 776, 784, 784, 783, 789, 778, 781, 791, 768, 779, 783, 781, 787, 786, 781, 784, 781, 785, 781, 780, 809, 1155, 780, 790, 789, 783, 776, 785, 783, 786, 787, 782, 782, 787, 777, 779, 784, 783, 776, 786, 775, 782, 779, 784, 784]
S.ToList 705.54 ms -> [690, 705, 709, 708, 702, 707, 703, 696, 703, 702, 700, 703, 700, 707, 705, 699, 697, 703, 695, 698, 707, 697, 711, 710, 699, 700, 708, 707, 693, 710, 704, 691, 702, 700, 703, 700, 705, 700, 703, 695, 709, 705, 698, 699, 709, 700, 699, 704, 691, 705, 703, 700, 708, 1048, 710, 706, 706, 692, 702, 705, 695, 701, 710, 697, 698, 706, 705, 707, 707, 695, 698, 704, 698, 699, 705, 698, 703, 702, 701, 697, 702, 702, 704, 703, 699, 707, 703, 705, 701, 717, 698, 695, 713, 696, 708, 705, 697, 699, 700, 698]
S.ToArray 745.01 ms -> [751, 743, 727, 734, 736, 745, 739, 750, 739, 750, 758, 739, 744, 738, 730, 744, 745, 739, 744, 750, 733, 735, 743, 731, 749, 748, 727, 746, 749, 731, 737, 803, 1059, 756, 769, 748, 740, 745, 741, 746, 749, 732, 741, 742, 732, 744, 746, 737, 742, 739, 733, 744, 741, 729, 746, 760, 725, 741, 764, 739, 750, 751, 727, 745, 738, 727, 735, 741, 720, 736, 740, 733, 741, 746, 731, 749, 756, 740, 738, 736, 732, 741, 741, 733, 741, 744, 736, 742, 742, 735, 743, 746, 729, 748, 765, 743, 734, 742, 728, 749]
C1.ToList 32.27 ms -> [36, 31, 31, 32, 31, 32, 31, 30, 32, 30, 30, 30, 34, 32, 31, 31, 31, 31, 31, 31, 31, 32, 38, 51, 68, 57, 35, 30, 31, 31, 30, 30, 33, 30, 31, 34, 31, 34, 32, 31, 31, 31, 31, 32, 30, 30, 31, 30, 31, 31, 32, 31, 31, 31, 32, 31, 31, 31, 32, 31, 33, 31, 31, 32, 30, 30, 30, 30, 30, 33, 30, 33, 32, 31, 30, 31, 31, 32, 32, 31, 35, 31, 34, 31, 31, 32, 31, 31, 32, 31, 32, 31, 31, 35, 31, 31, 31, 31, 31, 32]
C1.ToArray 56.72 ms -> [58, 56, 57, 57, 59, 58, 58, 57, 56, 59, 57, 55, 55, 54, 56, 55, 56, 56, 57, 59, 56, 55, 58, 56, 55, 55, 55, 55, 58, 58, 55, 57, 57, 56, 57, 57, 57, 57, 59, 59, 56, 57, 56, 57, 57, 56, 57, 59, 58, 56, 57, 57, 57, 58, 56, 56, 59, 56, 59, 57, 57, 57, 57, 59, 57, 56, 57, 56, 58, 56, 57, 56, 57, 59, 55, 58, 55, 55, 56, 56, 56, 56, 56, 56, 56, 56, 56, 57, 56, 56, 57, 56, 56, 57, 58, 57, 57, 57, 57, 57]
S1.ToList 90.72 ms -> [95, 90, 90, 89, 89, 89, 91, 89, 89, 87, 91, 89, 89, 89, 91, 89, 89, 89, 90, 89, 89, 90, 88, 89, 88, 90, 89, 90, 89, 89, 90, 90, 89, 89, 90, 91, 89, 91, 89, 90, 89, 89, 90, 91, 89, 89, 89, 89, 89, 89, 90, 89, 89, 89, 90, 89, 90, 89, 91, 89, 90, 89, 90, 89, 90, 89, 96, 89, 90, 89, 89, 89, 89, 89, 90, 89, 89, 89, 90, 87, 89, 90, 90, 91, 89, 91, 89, 89, 90, 91, 90, 89, 93, 144, 149, 90, 90, 89, 89, 89]
S1.ToArray 131.4 ms -> [130, 128, 127, 134, 129, 129, 130, 136, 131, 130, 132, 132, 133, 131, 132, 131, 133, 132, 130, 131, 132, 131, 130, 133, 133, 130, 130, 131, 131, 131, 132, 134, 131, 131, 132, 131, 132, 131, 134, 131, 131, 130, 131, 131, 130, 132, 129, 131, 131, 131, 132, 131, 133, 134, 131, 131, 132, 132, 131, 133, 131, 131, 130, 133, 131, 130, 134, 132, 131, 132, 132, 131, 131, 134, 131, 131, 132, 132, 131, 130, 138, 130, 130, 131, 132, 132, 130, 134, 131, 131, 132, 131, 130, 132, 133, 131, 131, 131, 130, 131]
C2.ToList 3.21 ms -> [4, 3, 3, 3, 4, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 3, 3, 3, 4, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 4, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 4, 3, 3, 3]
C2.ToArray 3.22 ms -> [4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 3, 3, 4, 3, 4, 3, 3, 3, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 3, 3, 3, 4, 3, 4, 3, 3, 3, 3, 3, 4, 3, 3, 3, 4, 3, 4, 3, 3, 3, 3, 4]
S2.ToList 41.46 ms -> [42, 40, 41, 40, 42, 40, 40, 40, 40, 40, 40, 40, 40, 41, 40, 40, 41, 40, 40, 40, 39, 41, 41, 39, 40, 40, 43, 40, 39, 40, 40, 40, 40, 40, 40, 41, 40, 40, 40, 43, 40, 43, 75, 76, 47, 39, 40, 40, 40, 40, 42, 40, 41, 40, 40, 40, 44, 41, 40, 42, 42, 40, 41, 41, 41, 41, 41, 40, 41, 41, 41, 41, 42, 41, 40, 41, 41, 42, 42, 41, 40, 41, 41, 41, 41, 41, 40, 42, 40, 42, 41, 41, 41, 43, 41, 41, 41, 41, 42, 41]
S2.ToArray 41.14 ms -> [42, 41, 41, 40, 40, 40, 40, 41, 41, 42, 41, 42, 41, 41, 41, 42, 41, 41, 42, 41, 41, 41, 41, 41, 42, 40, 41, 40, 42, 40, 42, 41, 40, 42, 41, 41, 43, 42, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 40, 40, 41, 41, 41, 40, 42, 41, 41, 41, 41, 41, 40, 41, 41, 42, 41, 41, 41, 42, 41, 41, 41, 41, 41, 41, 42, 42, 42, 41, 45, 46, 41, 40, 41, 41, 42, 41, 41, 41, 41, 41, 41, 40, 41, 43, 40, 40, 40, 40, 43, 41]
그룹 5:
C.ToList 757.06 ms -> [770, 752, 752, 751, 778, 763, 761, 763, 747, 758, 748, 747, 754, 749, 752, 753, 756, 762, 750, 753, 756, 749, 755, 757, 755, 756, 755, 744, 753, 758, 747, 751, 759, 751, 761, 755, 746, 752, 752, 749, 746, 752, 753, 755, 752, 755, 754, 754, 966, 937, 749, 759, 748, 747, 754, 749, 755, 750, 746, 754, 757, 752, 753, 745, 758, 755, 761, 753, 751, 755, 755, 752, 746, 756, 755, 746, 742, 751, 751, 749, 752, 751, 756, 756, 755, 742, 749, 754, 749, 756, 753, 751, 754, 752, 751, 754, 753, 749, 755, 756]
C.ToArray 772.8 ms -> [766, 772, 755, 763, 758, 767, 763, 762, 761, 768, 769, 763, 770, 757, 765, 760, 766, 759, 764, 761, 760, 777, 1102, 881, 759, 765, 758, 762, 772, 761, 758, 757, 765, 769, 769, 761, 762, 762, 763, 760, 770, 764, 760, 768, 758, 766, 763, 770, 769, 761, 764, 761, 761, 767, 761, 762, 764, 757, 765, 766, 767, 771, 753, 762, 769, 768, 759, 764, 764, 760, 763, 763, 763, 763, 763, 767, 761, 771, 760, 765, 760, 758, 768, 770, 751, 771, 767, 771, 765, 763, 760, 765, 765, 769, 767, 767, 1193, 774, 767, 764]
S.ToList 704.73 ms -> [682, 708, 705, 699, 705, 704, 695, 703, 702, 699, 701, 708, 699, 702, 703, 701, 701, 699, 701, 707, 707, 700, 701, 705, 700, 697, 706, 702, 701, 706, 699, 692, 702, 697, 707, 704, 697, 698, 699, 699, 702, 703, 698, 697, 702, 703, 702, 704, 694, 697, 707, 695, 711, 710, 700, 693, 703, 699, 699, 706, 698, 701, 703, 704, 698, 706, 700, 704, 701, 699, 702, 705, 694, 698, 709, 736, 1053, 704, 694, 700, 698, 696, 701, 700, 700, 706, 706, 692, 698, 707, 703, 695, 703, 699, 694, 708, 695, 694, 706, 695]
S.ToArray 744.17 ms -> [746, 740, 725, 740, 739, 731, 746, 760, 735, 738, 740, 734, 744, 748, 737, 744, 745, 727, 736, 738, 728, 743, 745, 735, 748, 760, 739, 748, 762, 742, 741, 747, 733, 746, 758, 742, 742, 741, 724, 744, 747, 727, 740, 740, 729, 742, 757, 741, 740, 742, 726, 739, 746, 1133, 749, 737, 730, 740, 747, 733, 747, 752, 731, 747, 742, 730, 741, 749, 731, 749, 743, 730, 747, 742, 731, 737, 745, 734, 739, 735, 727, 743, 752, 731, 744, 742, 729, 740, 746, 731, 739, 746, 733, 745, 743, 733, 739, 742, 727, 737]
C1.ToList 31.71 ms -> [35, 32, 32, 30, 31, 33, 31, 32, 32, 31, 31, 32, 32, 33, 32, 31, 31, 32, 31, 32, 32, 32, 31, 32, 33, 32, 31, 31, 31, 32, 31, 34, 31, 31, 32, 33, 32, 32, 31, 32, 34, 32, 31, 32, 33, 31, 32, 32, 31, 32, 32, 32, 32, 32, 32, 31, 31, 32, 31, 33, 30, 31, 32, 30, 30, 33, 32, 32, 34, 31, 31, 31, 31, 32, 31, 31, 31, 31, 32, 31, 31, 33, 31, 32, 32, 32, 33, 32, 31, 31, 31, 31, 31, 32, 32, 33, 32, 31, 31, 32]
C1.ToArray 59.53 ms -> [63, 57, 58, 58, 57, 59, 59, 57, 60, 131, 127, 67, 58, 56, 59, 56, 57, 58, 58, 58, 57, 59, 60, 57, 57, 59, 60, 57, 57, 57, 58, 58, 58, 58, 57, 57, 61, 57, 58, 57, 57, 57, 57, 57, 58, 58, 58, 58, 57, 58, 59, 57, 58, 57, 57, 59, 58, 58, 59, 57, 59, 57, 56, 56, 59, 56, 56, 59, 57, 58, 58, 58, 57, 58, 59, 59, 58, 57, 58, 62, 65, 57, 57, 57, 58, 60, 59, 58, 59, 57, 58, 57, 58, 59, 58, 58, 58, 59, 60, 58]
S1.ToList 82.78 ms -> [87, 82, 83, 83, 82, 82, 83, 84, 82, 83, 84, 84, 84, 82, 82, 84, 82, 84, 83, 84, 82, 82, 82, 81, 83, 83, 83, 84, 84, 82, 82, 83, 83, 83, 82, 83, 85, 83, 82, 82, 84, 82, 82, 83, 83, 83, 82, 82, 82, 83, 82, 83, 82, 84, 82, 83, 82, 83, 82, 82, 82, 84, 82, 83, 82, 82, 86, 83, 83, 82, 83, 83, 83, 82, 84, 82, 83, 81, 82, 82, 82, 82, 83, 83, 83, 82, 83, 84, 83, 82, 83, 83, 83, 82, 83, 84, 82, 82, 83, 83]
S1.ToArray 122.3 ms -> [122, 119, 119, 120, 119, 120, 120, 121, 119, 119, 122, 120, 120, 120, 122, 120, 123, 120, 120, 120, 121, 123, 120, 120, 120, 121, 120, 121, 122, 120, 123, 119, 121, 118, 121, 120, 120, 120, 119, 124, 119, 121, 119, 120, 120, 120, 120, 120, 122, 121, 123, 230, 203, 123, 119, 119, 122, 119, 120, 120, 120, 122, 120, 121, 120, 121, 120, 121, 120, 121, 120, 120, 120, 121, 122, 121, 123, 119, 119, 119, 119, 121, 120, 120, 120, 122, 121, 122, 119, 120, 120, 121, 121, 120, 121, 120, 121, 118, 118, 118]
C2.ToList 3.43 ms -> [5, 3, 4, 4, 4, 3, 4, 4, 4, 4, 4, 3, 3, 3, 4, 3, 3, 3, 4, 3, 4, 3, 4, 3, 4, 4, 3, 3, 3, 3, 4, 3, 3, 3, 4, 3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 6, 4, 4, 3, 3, 4, 3, 3, 4, 3, 3, 3, 3, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 4, 3, 4, 4, 4, 3, 4, 4, 3, 4, 4, 4, 4, 4, 4, 3, 3, 3, 4, 4, 3, 3, 3, 3]
C2.ToArray 3.48 ms -> [3, 3, 3, 3, 4, 4, 3, 4, 4, 4, 3, 4, 3, 3, 4, 3, 3, 4, 3, 4, 3, 3, 3, 4, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 4, 3, 3, 4, 3, 4, 3, 3, 3, 3, 4, 3, 3, 3, 3, 4, 3, 4, 3, 3, 4, 3, 3, 4, 3, 3, 4, 4, 3, 3, 4, 3, 4, 4, 3, 4, 4, 4, 4, 4, 3, 3, 3, 4, 4, 3, 4, 4, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 4, 4, 4, 4, 3]
S2.ToList 41.47 ms -> [41, 41, 49, 67, 82, 41, 41, 40, 40, 40, 40, 40, 41, 40, 40, 40, 40, 40, 41, 40, 42, 42, 40, 40, 41, 41, 41, 40, 41, 40, 41, 40, 41, 40, 42, 41, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 42, 41, 41, 41, 42, 40, 41, 40, 40, 40, 42, 40, 41, 42, 41, 42, 41, 42, 40, 41, 41, 41, 41, 41, 41, 41, 41, 40, 41, 40, 41, 41, 41, 40, 41, 41, 40, 40, 41, 41, 41, 41, 41, 43, 40, 40, 41, 42, 41]
S2.ToArray 40.62 ms -> [42, 41, 44, 40, 40, 40, 40, 41, 41, 40, 41, 41, 41, 40, 41, 41, 40, 41, 41, 40, 41, 40, 40, 41, 42, 41, 41, 41, 40, 40, 40, 40, 40, 41, 41, 42, 40, 41, 41, 41, 41, 41, 40, 42, 40, 40, 41, 41, 41, 40, 41, 40, 40, 40, 40, 40, 41, 40, 40, 41, 40, 40, 40, 40, 41, 40, 41, 41, 41, 40, 41, 41, 40, 41, 40, 41, 42, 40, 41, 41, 42, 41, 41, 40, 41, 40, 41, 40, 41, 41, 40, 40, 40, 41, 41, 40, 40, 40, 40, 40]
응답 문자 수에 대한 스택 오버플로 제한으로 인해 그룹 2 및 그룹 3의 샘플 목록이 생략됩니다.
보시다시피, 사용하는 것은 정말 중요하지 않습니다.ToList또는ToArry대개의 경우에
계산을 하는 동안IEnumerable<T>, 에 의한 및 클 ToList그리고.ToArray.C.ToList vs C.ToArray그리고.S.ToList vs S.ToArray).
차이는 계산된 실행 시간이 아닌 경우에만 관찰할 수 있습니다.IEnumerable<T>체만개(만▁only)C1.ToList vs C1.ToArray그리고.S1.ToList vs S1.ToArray 물체에 인 차이가 됩니다.IEnumerable<T>사실, 차이는 다음의 구현에 의해 결정됩니다.Enumerator<T>IEnumerable<T>그래서, 만약 당신의 프로그램이 정말로 이것에 대해 정말로 민감하다면, 당신은 프로필, 프로필, 프로필을 만들어야 합니다!마침내 병목 현상이 발생하지 않음을 알게 될 것입니다.ToList또는ToArray하지만 열거자의 세부 사항.
고리결의 , 그과는.C2.ToList vs C2.ToArray그리고.S2.ToList vs S2.ToArray것을 . 정말 쓸가 없습니다.ToList또는ToArray무임소에서.ICollection<T>물건들.
물론, 이것은 제 기계에 대한 결과일 뿐입니다. 다른 기계에 대한 이러한 작업의 실제 시간은 같지 않을 것입니다. 위의 코드를 사용하여 기계에서 확인할 수 있습니다.
당신이 선택해야 하는 유일한 이유는 당신이 특정한 요구를 가지고 있기 때문입니다.List<T>또는T[]@Jepp Stig Nielsen의 대답에 의해 묘사된 바와 같이.
ToListAsync<T>()선호합니다.
에서 두 모두 방법을 하지만, 엔티에프레 6서두방법 6두모 결국동 일한내 부방호만 ,ToArrayAsync<T>() 출들list.ToArray()마지막에, 이것은 다음과 같이 구현됩니다.
T[] array = new T[_size];
Array.Copy(_items, 0, array, 0, _size);
return array;
그렇게ToArrayAsync<T>()약간의 오버헤드가 있기 때문에ToListAsync<T>()선호합니다.
다음과 같은 다른 Linq-to-sql에서 이 결과를 사용하는 데 관심이 있는 사용자:
from q in context.MyTable
where myListOrArray.Contains(q.someID)
select q;
그러면 myListOrArray에 대해 List 또는 Array를 사용했는지 여부에 관계없이 생성되는 SQL이 동일합니다.이제 일부에서는 이 문 앞에 열거하는 이유를 물을 수 있지만 IQueryable에서 생성된 SQL과 (List 또는 Array) 사이에는 차이가 있습니다.
언급URL : https://stackoverflow.com/questions/1105990/is-it-better-to-call-tolist-or-toarray-in-linq-queries
반응형
'programing' 카테고리의 다른 글
| 명령줄에서 데이터베이스 만들기 (0) | 2023.05.16 |
|---|---|
| POI실적 (0) | 2023.05.16 |
| 프로세스가 lxc/Docker 내부에서 실행되는지 확인하는 방법은 무엇입니까? (0) | 2023.05.11 |
| HTML.ActionLink 메서드 (0) | 2023.05.11 |
| 디렉토리의 모든 파일에 대해 명령 실행 (0) | 2023.05.11 |