HomeSearch

C# Count Elements in Array and List

Compare ways of getting the count of elements in collections. Count array and list elements.
Count elements. Think of an array. It has many elements. But how can we get this number? An array's elements can be counted in several ways.
Collections in the C# language store their count in a field. This influences the performance of counting. There are some complexities with the syntax and speed of counting.
ArrayList. Here we get the number of elements in an ArrayList, which is a non-generic collection that stores its length in a property called Count.

Tip: This is identical to the List collection, which we will see next. This property access is fast.

ArrayList

Tip 2: If you can avoid naming your variables things like "ar," that is usually a good decision.

C# program that uses ArrayList using System; using System.Collections; class Program { static void Main() { ArrayList ar = new ArrayList(); ar.Add("One"); ar.Add("Two"); // Count the elements in the ArrayList. int c = ar.Count; Console.WriteLine(c); } } Output 2
List. Here we use List, a generic collection. You must specify its type in the sharp angle brackets <T>. These collections have superior performance and usually preferable.List

Tip: List has a property called Count that is fast to access. When possible, access Count.

Property

Assign: Please look at the 2 int assignments (to the "c" variable). The list.Count accesses a property and is fast. It will return 2.

Also: The code shows Count() with parentheses. This is a LINQ extension method—it can be confusing if you don't know the difference.

CountIEnumerable
C# program that uses List using System; using System.Collections.Generic; using System.Linq; class Program { static void Main() { List<int> list = new List<int>(); list.Add(1); list.Add(2); // Count with the Count property. int c = list.Count; Console.WriteLine(c); // Count with the extension method. This is different! c = list.Count(); // BE CAREFUL! Console.WriteLine(c); } } Output 2 2
Arrays. For an array, we need to use Length (not Count). In programs, an array's size is set differently than List or ArrayList. The size does not grow dynamically.Array LengthArray

Last element: We use the Length property on arrays, and also the Count property on ArrayList and List, to access the final element.

Tip: The final element is located at the count minus one, except when the length of the array is 0.

Count extension. You can use the Count() extension method when you have an IEnumerable collection or are using LINQ statements. But be careful with this method.

Tip: Enumerations in C# are collections that haven't been determined exactly yet, and they can use yield and foreach keywords.

C# program that uses LINQ using System; using System.Linq; class Program { static void Main() { string[] arr = new string[] { "One", "Two", "Three" }; // An enumerable collection, not in memory yet. var e = from s in arr select s; int c = e.Count(); // Extension method. Console.WriteLine(c); // ... does a lot of work to get the count. } } Output 3
Benchmark, Count. Let us benchmark the Count() method. In my benchmark, where I took the Count of an array many times, the Count() extension performed worse.

Note: The Count() method was iterating through the collection each time. This has poor algorithmic performance.

Version 1: This version uses the Count() extension method on the 100-element integer array.

Version 2: This version of the code uses the Length property on the array. It performs much faster and is the preferable code.

Benchmark
C# program that benchmarks Count using System; using System.Diagnostics; using System.Linq; class Program { const int _max = 1000000; static void Main() { var array = new int[100]; // Version 1: access Count() on array. var s1 = Stopwatch.StartNew(); for (int i = 0; i < _max; i++) { if (array.Count() != 100) { return; } } s1.Stop(); // Version 2: access Length on array. var s2 = Stopwatch.StartNew(); for (int i = 0; i < _max; i++) { if (array.Length != 100) { 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")); } } Output 32.49 ns Count() 0.79 ns Length
Hoist. In the C# language, the Length or Count property is often evaluated each time a for-loop is run. It can be faster to hoist the Count or Length check out of the loop.

Note: Occasionally the JIT compiler can optimize loops that include the Count or Length in the for statement.

Note 2: Hoisting is sometimes faster. For optimal performance, you will need to test your program. Not hoisting can be faster.

C# program that shows Count hoisting using System; using System.Collections.Generic; class Program { static void Main() { var values = new List<int>() { 10, 20 }; // Version 1: loop over values, no hoisting. for (int i = 0; i < values.Count; i++) { Console.WriteLine($"VALUE: {values[i]}"); } // Version 2: loop over values, with hoisting of max. int max = values.Count; for (int i = 0; i < max; i++) { Console.WriteLine($"VALUE: {values[i]}"); } } } Output VALUE: 10 VALUE: 20 VALUE: 10 VALUE: 20
A summary. We computed the element count of a List or array. And we saw some benchmarks of the extension method that also is named Count. You will need to use Count in most for-loops.
© 2007-2019 Sam Allen. Every person is special and unique. Send bug reports to info@dotnetperls.com.
Home
Dot Net Perls