C# ToList Extension Method

Use and benchmark the ToList extension method from System.Linq. Convert IEnumerables to Lists.
ToList. This extension method converts collections (IEnumerables) to List instances. It is fast and easy-to-remember. It returns a List instance with the appropriate elements.ListIEnumerable
ToList creates a new List internally, with the List constructor. So we can replace its usage (for converting an array) with the constructor directly.
First example. This program creates an array with an array initializer. It then converts that object data into a List instance. The System.Linq namespace is included.Array

Tip: System.Linq allows us to invoke the ToList extension method on the array reference.

4 elements: The program uses an array initializer to specify that the array has 4 elements.

Initialize Array

Next: The ToList extension method is called on that array reference. ToList is an extension method from the System.Linq namespace.


And: It is called in the same way as an instance method is called. It returns a new List of string instances.

C# program that uses ToList extension method using System; using System.Collections.Generic; using System.Linq; class Program { static void Main() { // // Use this input string[] array. // ... Convert it to a List with the ToList extension. // string[] array = new string[] { "A", "B", "C", "D" }; List<string> list = array.ToList(); // // Display the list. // Console.WriteLine(list.Count); foreach (string value in list) { Console.WriteLine(value); } } } Output 4 A B C D
Internals. The ToList method internally checks its parameter for null, which will occur if you try to use ToList on a null reference.

Then: ToList invokes the List type constructor with the instance parameter. So it is a wrapper method for the List constructor.


Tip: This means that using "instance.ToList()" is similar to using "new List<T>(instance)" where T is the type.

Benchmark. We can compare the performance of ToList and the List() constructor. ToList has some extra indirection, so this will likely cause a small performance penalty.

Result: The List() constructor performs slightly faster on an int array. When possible, it is worth using the List constructor.

C# program that benchmarks ToList using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; class Program { const int _max = 1000000; static void Main() { int[] array = new int[] { 10, 20, 30, 40, int.MaxValue, int.MinValue }; var s1 = Stopwatch.StartNew(); for (int i = 0; i < _max; i++) { // Version 1: use ToList. var list = array.ToList(); if (list.Count != 6) { return; } } s1.Stop(); var s2 = Stopwatch.StartNew(); for (int i = 0; i < _max; i++) { // Version 2: use List constructor. var list = new List<int>(array); if (list.Count != 6) { return; } } s2.Stop(); Console.WriteLine(((double)(s1.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns")); Console.WriteLine(((double)(s2.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns")); Console.Read(); } } Output 108.43 ns ToList 102.45 ns List constructor (new List)
A summary. We examined the ToList extension method. We noted its usage in a trivial program. We evaluated the method's implementation.
Some final notes. Internally the ToList extension method invokes the List type constructor. Its performance characteristics are about the same.
© 2007-2019 Sam Allen. Every person is special and unique. Send bug reports to info@dotnetperls.com.
Dot Net Perls