Working with Strings in .NET

Introduction

So, by now you should know all there is to about string concatenation in .NET and the StringBuilder class and the string.Concat method. I'm not going to cover that here, but, instead, some less known functionality around strings that can (also) bring some performance advantages.

Searching

When it comes to searching for values ("needles") inside a string ("haystack"), we have a couple options:

Since .NET 8, we have another one: the SearchValues<T> class. This one is optimised for searching for one or multiple strings (exact values) inside of a string. During its creation, it parses the string and builds a memory model that is suitable for searching. With time, using SearchValues<T> instead of the built-ins (IndexOf, IndexOfAny, Contains) will yield much faster performance. Here is how to use it:

var names = SearchValues.Create([ "fox", "dog" ], StringComparison.OrdinalIgnoreCase); //SearchValues<char>
var text = "The quick brown fox jumps over the lazy dog.";
var containsAny = text.ContainsAny(names); //true
var containsDog = names.Contains("dog"); //true

Notice the comparisonType parameter on the SearchValues.Create method: it allows us to pass one of the SearchComparison values, the most obvious ones are InvariantCultureIgnoreCase and OrdinalIgnoreCase, for ignoring the casing on the strings. ContainsAny takes a collection of arguments, and Contains, only one.

Another usage, for finding the index of the first needle found on the haystack:

var indexOfFirstName = text
    .AsSpan()
    .IndexOfAny(names);

The IndexOfAny method will return the index for the first needle that is found on the haystack, -1 if none was found.

Of course, on a simple usage you likely won't see any benefits, but try it many times, with different needles, and you'll probably start to see them.

Formatting

We've all used string formatting using string.Format. It's a very useful method that allows us to pass index-based tokens (with optional formatting information) and arguments that get then replaced into a target string. It is called composite formatting:

var formattedString = string.Format("Today is {0}", DateTime.Today);

String interpolation was introduced some time ago, and it allows us to build strings from a format string with the arguments already embedded in it, which has the advantage that we cannot mix the indexes, you see exactly what will be added. The class that is responsible for it behind the scenes is FormattableString and here is a simple example:

var formattable = (FormattableString) $"Today is {DateTime.Today}";
var formattedString = $"Today is {DateTime.Today}"; //string
var format = formattable.Format; //"Today is {0}"
var argumentCount = formattable.ArgumentCount; //1

If we don't cast to FormattableString, the result will be a string, which means we lost the Format and ArgumentCount properties, which we may not need anyway. No way to access the actual arguments. ToString returns the formatted string.

A new way to do formatting was introduced recently, by means of the CompositeFormat class. This class takes a format string and internally builds a model that is suitable for formatting actual arguments, which makes it a replacement for string.Format. We can use it like this:

var format = CompositeFormat.Parse("Today is {0}");
var text = string.Format(CultureInfo.InvariantCulture, format, DateTime.Today.DayOfWeek);

Again, this is related to performance: if we run this enough times, the performance gain should be noticeable.

Sub Strings

One recent change with significant importance in recent .NET versions was the introduction of spans and avoiding allocations. A string can now be turned into an immutable span of chars (ReadOnlySpan<T>), and we can slice it to get sub strings with zero memory allocation.

We turn a string into a span of characters using AsSpan and we can get a sub string of it using Slice:

var text = "Hello, World!";
var textSpan = text.AsSpan();
var hello = textSpan.Slice(0, 5);
var world = textSpan.Slice(7, 5);

The behaviour is just the same as Substring, just with less (zero) allocations. Also, with many calls, the gain in memory consumption (at least) should be evident.

Interning Strings

String interning is a process by which .NET stores identical strings in an internal memory pool. If a string passed to the Intern method is already in the pool, then it is returned, otherwise, it is added and a reference to it returned. It has the advantage that no two identical strings are stored - only one instance - with the disadvantage of a slightly longer startup time. Constant strings are automatically interned and we can intern any strings that we construct at runtime.

Have a look at these examples:

var text1 = string.Intern(string.Concat("Hello", ", ", "World!"));
var text2 = "Hello, World!";
var text3 = string.Concat("Hello", ", ", "World!");

var areSameReference1and3 = object.ReferenceEquals(text1, text3); //false
var areEqual1and3 = text1 == text3; //true
var areSameReference1and2 = object.ReferenceEquals(text1, text2); //true
var areEqual1and2 = text1 == text2; //true

So, as we can see:

  • Strings, either interned or otherwise, are always compared by their contents when using the == operator or the Equals or Compare methods
  • Strings that are created (Concat, ToString, +/+= operators, etc) are different in-memory objects
  • Two identical interned strings are always the object

So, does this mean that we should always intern strings? Not quite, there is a tradeoff between memory usage and speed. In programs that create a number of strings, you should benchmark and test to see what are the gains.

Conclusion

All of these are performance or memory-related, so, they may or may not be useful, depending on our use case. Microsoft is making a huge push for perfomance and this includes all of this and more. We should all be aware of these improvements and new APIs and start using them, even if performance or memory consumption it not (immediately) an issue for us. These two should be, in my opinion, always on our minds when implementing applications and services.

As usual, hope you find these useful, and let me know about your thoughts!

Location: Coimbra, Portugal

Comments

Post a Comment

Popular posts from this blog

C# Magical Syntax

Introduction This post is an update to an old one on my  old blog  and it was inspired by my latest posts on C# versus Java . You may not have realized that some of the patterns that you’ve been using for ages in your C# programs are based on conventions, rather than on a specific API. What I mean by this is, some constructs in C# are based on some magical methods with well-defined names which are not defined in any base class or interface, but yet just work. Let’s see what they are. Enumerating Collections You are probably used to iterating through collections using the foreach statement. If you are, you may know that foreach actually wraps a call to a method called GetEnumerator , like the one that is defined by the IEnumerable and IEnumerable<T> interfaces. Thus, you might think, the magic occurs because the collection implements one or the two, but you would be wrong: it turns out that in order to iterate through a class using foreach all it takes is that the c...
Read more

OpenTelemetry with ASP.NET Core

Image
Introduction I wrote a post not too long ago about the building blocks of telemetry , or distributed tracing , with ASP.NET Core. Now I'm going to talk about how we can see it working using an open source bundle, otel-lgtm . Mind you, this may not be 100% suitable for production, but for development purposes, it should be fine, all concepts apply, of course. I won't cover everything about OpenTelemetry here, but should hopefully give you some insights as to what's there and how you can make good use of it. First, lets see what some of the concepts are. If you're interested in learning more about metrics, I suggest having a look at my post on this topic . OpenTelemetry OpenTelemetry  (OTel) provides a single, open-source standard, and a set of technologies to capture and export metrics, traces, and logs from your cloud-native applications and infrastructure. OTel is both a standard and a reference implementation that builds on other standards, such as W3C Distributed Tr...
Read more

ASP.NET Core Middleware

Image
Introduction This post is another of those "back to basics", still, there was one thing or two that I feel were not properly discussed elsewhere, hence this post. The ASP.NET Core Pipeline and Middleware You may know that ASP.NET Core defines a pipeline. This is where the incoming requests are processed and the response submitted. Each component in the pipeline - a middleware - can do things with the message (the request), such as check if it is authenticated and have rights to access the requested resource, turn the request into an MVC-style controller and action invocation, log it, and what not. You can read more about it here . The ASP.NET Core pipeline, from Microsoft The order by which the middleware is added to the pipeline matters. For example, the authorisation middleware must come after the authentication one, static files must come before routing, and exception handling must come before everything. The middleware order, from Microsoft A middleware is just a piece of...
Read more