An array - the simplest collection. It's just a memory block with elements of one type. Arrays are often used when we need to iterate a collection, to search elements or transform them. C# and .net evolved, many new collections were introduced, interfaces allowed to create generalized algorithms, LINQ simplified the work of programmers, but we continue to use arrays in inappropriate places and perform excess and sometimes harmful transformations. This post begins a series about collections, their features, performance and design. All posts will contain benchmarks, code examples, my opinion and recommendations.

I want to start with a string, some specific collection of .net.

• Part 1: string to array of chars
• Part 2: automatic diagnostics
• Part 3: collections

String

Any large enough project operates with strings. Usually strings store a user input and are used as data for other types. For example, we can read text input and convert it to a number type:

static void Main()
{
    var input = Console.ReadLine();
    var value = int.Parse(input);
}

All we know, user input must be validated. Here we need to check that all chars are digits. It's a very common check. And often the following code is used:

private bool IsDigitString(string str)
{
   return str.ToCharArray().All(char.IsDigit);
}

or

string bik = ...;
if (bik.ToArray().Any(x => !char.IsDigit(x)))
{
   message = "BIK must contain only digits";
   return false;
}

Looks simple: get a collection of chars and call LINQ-method to check every digit. The only unnecessary and harmful thing is transformation of string to array of chars with methods ToCharArray() or ToArray(). We used to use LINQ-methods with collections, but forget that the string is an immutable collection that implements IEnumerable<char> interface:

[Serializable]
public sealed partial class String : IComparable, IEnumerable, IConvertible, IEnumerable<char>, IComparable<string>, IEquatable<string>, ICloneable
{
...
}

So, we can modify our examples and remove excessive calls:

private bool IsDigitString(string str)
{
   return str.All(char.IsDigit);
}

and

string bik = ...;
if (bik.Any(x => !char.IsDigit(x)))
{
   message = "BIK must contain only digits";
   return false;
}

Ok, our code became simpler and more readable. But what do we get besides code quality benefits? Benchmarks can help us. Let's compare three methods: with ToArray(), with ToCharArray() and without additional calls for different string lengths and frameworks:

namespace ToCharArrayBenchmark
{
    using System.Linq;
    using BenchmarkDotNet.Attributes;
    using BenchmarkDotNet.Jobs;

    [SimpleJob(RuntimeMoniker.Net48, baseline: true)]
    [SimpleJob(RuntimeMoniker.NetCoreApp31)]
    [SimpleJob(RuntimeMoniker.Net50)]
    [DisassemblyDiagnoser]
    [MemoryDiagnoser]
    public class IsDigitBenchmark
    {
        [Params(10, 100, 1000)]
        public int N { get; set; }

        private string value;

        [GlobalSetup]
        public void SetUp()
        {
            var chars = new char[N];
            for (int i = 0; i < N; i++)
            {
                chars[i] = (char)(i % 10 + '0');
            }

            value = new string(chars);
        }

        [Benchmark]
        public bool IsDigitString_ToCharArray()
        {
            return value.ToCharArray().All(char.IsDigit);
        }

        [Benchmark]
        public bool IsDigitString_ToArray()
        {
            return value.ToArray().All(char.IsDigit);
        }

        [Benchmark(Baseline = true)]
        public bool IsDigitString()
        {
            return value.All(char.IsDigit);
        }
    }
}

BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19043.1237 (21H1/May2021Update)
AMD Ryzen 7 4700U with Radeon Graphics, 1 CPU, 8 logical and 8 physical cores
  [Host]             : .NET Framework 4.8 (4.8.4400.0), X64 RyuJIT
  .NET 5.0           : .NET 5.0.7 (5.0.721.25508), X64 RyuJIT
  .NET Core 3.1      : .NET Core 3.1.11 (CoreCLR 4.700.20.56602, CoreFX 4.700.20.56604), X64 RyuJIT
  .NET Framework 4.8 : .NET Framework 4.8 (4.8.4400.0), X64 RyuJIT

// * Legends *
  N         : Value of the 'N' parameter
  Mean      : Arithmetic mean of all measurements
  Error     : Half of 99.9% confidence interval
  StdDev    : Standard deviation of all measurements
  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
  Allocated : Allocated memory per single operation (managed only, inclusive, 1KB = 1024B)
  1 us      : 1 Microsecond (0.000001 sec)

Let's examine a diagram with execution times (in microseconds) for strings with 100 chars:

As we see, method IsDigitString is about 5% faster than calling ToCharArray(). ToArray() is up to 3 times slower. Both ToCharArray() and ToArray() do the same, but ToCharArray() is a string class method and very optimized with unsafe code. ToArray() is an extension method for IEnumerable<T> and is not optimized so much.

So, we know, there is no need to transform string to array to use LINQ-methods, this transformation slightly hurts performance and there is one more thing - GC. Every time when we call ToArray() or ToCharArray() we create at least one new object - a new array. We no longer need the source string and GC will collect at some time.

The next diagram shows us memory allocations (in bytes) for strings with 100 chars:

Cons

Should we always always remove ToArray() and ToCharArray() calls? It depends on context. ToArray() generates a lot of overhead, so I can't find a situation where to use it. But as we saw before, ToCharArray() is very fast, and almost does not affect performance. Can you imagine that calling ToCharArray() will save time? But it does! Look at this example:

var convertParameterSymbols = attributes["ConvertParameterSymbols"];
if (convertParameterSymbols != null)
	ConvertParameterSymbols = new List<char>(convertParameterSymbols.ToCharArray());

It looks like we need to remove ToCharrArray(). But before doing this, we need to go back to the string class definition. As we remember, it implements IEnumerable<char>, but not ICollection<char>. ICollection<T> interface describes the contract for mutable collections (Add, Clear, Remove) that is not suitable for strings. And look at List<T> constructor:

public List(IEnumerable<T> collection)
{
  if (collection == null)
	ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
  if (collection is ICollection<T> objs)
  {
	int count = objs.Count;
	if (count == 0)
	{
	  this._items = List<T>._emptyArray;
	}
	else
	{
	  this._items = new T[count];
	  objs.CopyTo(this._items, 0);
	  this._size = count;
	}
  }
  else
  {
	this._size = 0;
	this._items = List<T>._emptyArray;
	foreach (T obj in collection)
	  this.Add(obj);
  }
}

It's optimized for ICollection<T> objects. Elements are just copied as a block with CopyTo instead of adding one by one that causes resizes of list. What types do implement ICollection<T> interface? You will be surprised, but any array (T[]) can be converted to ICollection<T>. And using new List<char>(convertParameterSymbols.ToCharArray()) is faster than new List<char>(convertParameterSymbols). Benchmarks can prove this.

namespace ToCharArrayBenchmark
{
    using System.Collections.Generic;
    using System.Linq;
    using BenchmarkDotNet.Attributes;
    using BenchmarkDotNet.Jobs;

    [SimpleJob(RuntimeMoniker.Net48, baseline: true)]
    [SimpleJob(RuntimeMoniker.NetCoreApp31)]
    [SimpleJob(RuntimeMoniker.Net50)]
    [DisassemblyDiagnoser]
    [MemoryDiagnoser]
    public class ConstructorBenchmark
    {
        [Params(10, 100, 1000)]
        public int N { get; set; }

        private string value;

        [GlobalSetup]
        public void SetUp()
        {
            var chars = new char[N];
            for (int i = 0; i < N; i++)
            {
                chars[i] = (char)(i % 10 + '0');
            }
            
            value = new string(chars);
        }
        
        [Benchmark(Baseline = true)]
        public List<char> Constructor()
        {
            return new List<char>(value);
        }

        [Benchmark]
        public List<char> Constructor_ToCharArray()
        {
            return new List<char>(value.ToCharArray());
        }

        [Benchmark]
        public List<char> Constructor_ToArray()
        {
            return new List<char>(value.ToArray());
        }
    }
}

BenchmarkDotNet=v0.13.0, OS=Windows 10.0.19043.1288 (21H1/May2021Update)
AMD Ryzen 7 4700U with Radeon Graphics, 1 CPU, 8 logical and 8 physical cores
  [Host]             : .NET Framework 4.8 (4.8.4420.0), X64 RyuJIT
  .NET 5.0           : .NET 5.0.7 (5.0.721.25508), X64 RyuJIT
  .NET Core 3.1      : .NET Core 3.1.20 (CoreCLR 4.700.21.47003, CoreFX 4.700.21.47101), X64 RyuJIT
  .NET Framework 4.8 : .NET Framework 4.8 (4.8.4420.0), X64 RyuJIT

// * Legends *
  N         : Value of the 'N' parameter
  Mean      : Arithmetic mean of all measurements
  Error     : Half of 99.9% confidence interval
  StdDev    : Standard deviation of all measurements
  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
  Allocated : Allocated memory per single operation (managed only, inclusive, 1KB = 1024B)
  1 us      : 1 Microsecond (0.000001 sec)

Time diagram (in microseconds) for strings with 100 chars:

Incredible! A list created from an array is about 10 times faster than created from a source string. And memory usage is more optimal (in bytes):

But we should remember, it's a very specific case.

Conclusion

In common we should be be more attentive and avoid unnecessary transformations for reasons:

• Performance. Such small optimizations can positively influence the processing of big data.
• Additional memory traffic - GC has to collect more data, GC pauses can be longer.
• Code quality. We can reduce code but not lose functionality.

Some cases require special attention and a deeper understanding of the .net platform.

If you really need to convert a string to an array use ToCharArray() instead of ToArray().

More examples

Here are more examples I found.

Lowercase string

There is a very popular way to lowercase the first letter of a string. We remember - strings are immutable and name[0] = char.ToLowerInvariant(name[0]) won't compile. So, we need to create a new string from a char array.

public override string Format(string name)
{
	if (string.IsNullOrEmpty(name) || char.IsLower(name[0])) return name;
	var chars = name.ToCharArray();
	chars[0] = char.ToLowerInvariant(chars[0]);
	return new string(chars);
}

Reverse string

There is no built-in method to reverse a string, so we have to create our own using Array.Reverse method, so we transform a source string to an array.

public static string ReverseString(this string input)
{
	var charArray = input.ToCharArray();
	Array.Reverse(charArray);
	return new string(charArray);
}

Iterate string

public static byte[] ToBytes(string value)
{
	char[] chars = value.ToCharArray();
	byte[] res = new byte[chars.Length / 2];
	for (int i = 0, j = 0; i < chars.Length; i += 2, j++)
		res[j] = (byte)(FromHex((byte)chars[i]) << 4 ^ FromHex((byte)chars[i + 1]));
	return res;
}

We iterate through a string, and no need to create a new array. The code can be simplified:

public static byte[] ToBytes(string value)
{
	byte[] res = new byte[value.Length / 2];
	for (int i = 0, j = 0; i < value.Length; i += 2, j++)
		res[j] = (byte)(FromHex((byte)value[i]) << 4 ^ FromHex((byte)value[i + 1]));
	return res;
}