.NET struct performance degradation by size

Software

I benchmarked equality, GetHashCode, and HashSet operations across different C# type implementations. The tests compared struct, readonly struct, record, and readonly record struct at various sizes (16-128 bytes).

Why?

The conventional wisdom has been “don’t have more than 16 bytes in a struct” with 32 bit CPU architectures, and no more than 32 bytes on 64 bit CPUs, but mostly the former. I wanted to see what the actual performance degradation was as struct size increases.

I like to use readonly record struct to model aspects of my domain knowing that the compiler will optimize the type away to just the properties it contains, while guaranteeing  domain correctness.

Setup

Tests were run on an Apple M3 using .NET 8 with BenchmarkDotNet’s ShortRun configuration.

  • 16 bytes: 4 int properties
  • 32 bytes: 8 int properties
  • 64 bytes: 16 int properties
  • 128 bytes: 32 int properties

record is a value type, so increasing the number of properties doesn’t change the performance characteristics much, but I did it to keep the basis for comparison as even as possible.

Equality Performance

Type 16-byte (ns) 32-byte (ns) 64-byte (ns) 128-byte (ns)
Struct 7.66 8.06 10.83 16.46
Struct + IEquatable 0.00 1.25 3.61 9.82
Readonly Struct 7.56 8.02 10.91 16.51
Readonly Struct + IEquatable 0.00 1.08 3.21 9.64
Readonly Record Struct 0.00 1.00 2.82 7.57
Record 0.94 1.27 2.55 6.32

GetHashCode Performance

Type 16-byte (ns) 32-byte (ns) 64-byte (ns) 128-byte (ns)
Struct 12.41 12.64 10.88 13.13
Struct + IEquatable 1.90 3.14 9.45 17.71
Readonly Struct 11.14 12.95 10.98 13.22
Readonly Struct + IEquatable 1.73 2.87 8.96 16.82
Readonly Record Struct 0.00 0.43 2.67 9.80
Record 1.33 1.79 4.31 10.82

HashSet.Contains Performance

Type 16-byte (ns) 32-byte (ns) 64-byte (ns) 128-byte (ns)
Struct 20.27 23.59 24.00 34.56
Struct + IEquatable 5.08 6.73 15.90 27.34
Readonly Struct 20.47 23.87 24.08 33.87
Readonly Struct + IEquatable 5.11 6.61 15.50 27.41
Readonly Record Struct 2.42 4.61 9.57 20.65
Record 6.14 6.89 10.51 19.20

Memory Allocations

Type 16-byte 32-byte 64-byte 128-byte
Struct (Equals) 64 B 96 B 160 B 288 B
Struct (GetHashCode) 32 B 48 B 80 B 144 B
Struct (HashSet) 96 B 144 B 240 B 432 B
Readonly Struct (Equals) 64 B 96 B 160 B 288 B
Readonly Struct (GetHashCode) 32 B 48 B 80 B 144 B
Readonly Struct (HashSet) 96 B 144 B 240 B 432 B
All others 0 B 0 B 0 B 0 B

Key Findings

  • Structs without IEquatable<T> use ValueType.Equals, which boxes and allocates,  causing 7-16ns overhead per operation.
  • Records consistently outperform structs for GetHashCode, likely due to compiler-generated optimizations.
  • Readonly record structs combine the benefits of value semantics with record optimizations, showing best overall performance for collection operations.
  • Struct size impacts performance linearly – 128-byte types take 3-5x longer than 16-byte types for most operations.

Recommendations

  • Always implement IEquatable<T> on structs. ValueType.Equals is 3-5x slower.
  • Use readonly record structs for small value types that need equality operations and collection membership tests.
  • Consider regular structs with IEquatable<T> for types larger than 64 bytes where mutability is needed.
  • Records (reference types) remain competitive for GetHashCode but have allocation overhead not shown in these benchmarks.

The most performant way to count substrings in .NET

Software

I benchmarked 14 common approaches to counting substrings in .NET. The approaches differed up to 60-70x in execution time with memory allocations ranging from zero to over 160KB.

Setup

Tests searched for substring “the” in two strings on an Apple M3 using .NET 8 with BenchmarkDotNet’s ShortRun configuration. The big string was the first chapter of The Hobbit, and the small string was the first 100 chars of the big string.

Results

Approach Small (ns) Large (ns) Allocated
Span 17.71 8,227 0 B
IndexOf (Ordinal) 18.93 8,662 0 B
IndexOf (OrdinalIgnoreCase) 20.47 10,463 0 B
String.Replace 37.33 24,645 216 B / 87,963 B
Cached, compiled Regex 127.17 40,968 560 B / 162,880 B
Instantiating a Regex inline 416.44 49,698 2,528 B / 164,848 B
Static Regex (Regex.Match) 154.42 50,996 560 B / 162,880 B
String.Split 145.47 70,195 304 B / 111,058 B
IndexOf (InvariantCulture) 1,216.64 523,154 0 B / 1 B
IndexOf (InvariantCultureIgnoreCase) 1,314.57 534,426 0 B / 1 B
IndexOf (CurrentCultureIgnoreCase) 1,329.19 536,436 0 B / 1 B
IndexOf (CurrentCulture – default) 1,224.49 553,913 0 B / 1 B

Allocated column shows small/large text allocations.

Key Findings

  • Ordinal string operations are 60x faster than culture-aware operations.
  • Span and IndexOf with StringComparison.Ordinal both achieve zero allocations and optimal performance.
  • Regex approaches allocate 160KB+ for large texts despite reasonable performance.
  • Split creates an array of all segments, explaining its 111KB allocation.
    • With larger strings, this creates an object on the Large Object Heap, which has different garbage collection characteristics, and should be avoided.

Recommendation

If you’re a backend or line of business developer modeling your domain, you probably want IndexOf with the Ordinal or OrdinalIgnoreCase comparer, depending on domain semantics.

See also

Dictionary vs FrozenDictionary: when does the extra overhead break-even?

Software

FrozenDictionary offers faster reads but slower creation. Here’s when the trade-off makes sense.

The tl;dr-

Based on benchmark data, here are the break-even points where FrozenDictionary becomes worthwhile:

Collection Size Cache Hits Cache Misses
10 elements 276 reads 125 reads
100 elements 1,831 reads 804 reads
1,000 elements 22,157 reads 9,634 reads
10,000 elements 217,271 reads 104,890 reads

(Based on string keys and OrdinalIgnoreCase comparison.)

  • Cache misses break-even faster – FrozenDictionary is much faster for failed lookups (0.33ns vs 6-7ns), so collections with cache misses justify the switch sooner.
  • Creation cost scales ~linearly with size – Creation cost grows in a fairly linear way, so larger collections will need more reads to justify use.
  • Read performance is consistent – Once created, FrozenDictionary maintains good performance regardless of collection size.

Switch to FrozenDictionary when you expect:

  • Small collections (10-100 elements): Hundreds to low thousands of reads
  • Large collections (1K+ elements): 10K+ reads with cache misses, or 20K+ reads with all hits
  • A high percentage of misses: you can cut the number of reads in ~half if you expect a high percentage of key misses.

Instantiation costs

FrozenDictionary‘s creation penalty is substantial but decreases as collection size increases:

Elements Dictionary FrozenDictionary Overhead
10 90.30 ns 867.24 ns 9.6x
100 900.73 ns 6,285.94 ns 7.0x
1,000 10,597.66 ns 65,989.60 ns 6.2x
10,000 138,642.89 ns 781,551.17 ns 5.6x

Hit + miss costs

Elements dict Hit dict Miss Frozen  Hit frozen Miss
10 5.48 ns 6.54 ns 2.66 ns 0.33 ns
100 5.77 ns 7.04 ns 2.83 ns 0.34 ns
1,000 5.45 ns 6.08 ns 2.95 ns 0.33 ns
10,000 5.64 ns 6.49 ns 2.68 ns 0.36 ns

The code

2 minute fix: Ventura + Logitech Brio + dock

Software

My Logitech Brio stopped working after I upgraded from Monterey to Ventura. It’s always been connected to an OWC dock, along with a bunch of other peripherals. Maybe I can save you 15-20 minutes by sharing what I did:

  1. Download the Logitech firmware update for the Brio.
  2. Connect the webcam directly to the computer. In my case, I had to attach a USB-A to USB-C adapter because my MacBook Pro only has USB-C ports. (Contrary to some forum posts, I didn’t need a whole new cable, an adapter worked fine.)
  3. Run the firmware update tool. My firmware was at v1.1, and the latest was 2.9. The update took less than a minute to complete.
  4. Remove the USB-A to USB-C adapter, and reconnect the camera to the dock in the same place it was before.

And that was it. You can use Photo Booth to test at steps 3 and 4 to make sure it’s working along the way. I also rebooted, and everything stayed fixed after the restart.

Circuit breakers in stock market trading

Software

Because I can never remember them.

Level 1 halt (7% drop)

  • Trading will halt for 15 minutes if drop occurs before 3:25 p.m.
  • At or after 3:25 p.m.—trading shall continue, unless there is a Level 3 halt.

Level 2 halt (13% drop)

  • Trading will halt for 15 minutes if drop occurs before 3:25 p.m.
  • At or after 3:25 p.m.—trading shall continue, unless there is a Level 3 halt.

Level 3 halt (20% drop)

  • At any time during the trading day—trading shall halt for the remainder of the trading day.

Backdoor, megabackdoor, and regular Roth IRA conversions

Finance

This is an honest-to-goodness note to my future self.

Backdoor Roth IRA

Definition: Making non-deductible contributions to a traditional IRA, then converting to Roth IRA.

Mechanics: Contribute up to $7,000 ($8,000 if 50+) to a traditional IRA without taking the tax deduction. Then convert this money to a Roth IRA. No additional taxes owed since the contribution was already made with after-tax dollars.

When it can be done: Any time, but primarily useful when your income exceeds direct Roth IRA contribution limits ($153k-$161k for 2025).

Notes: Works best with empty traditional IRA accounts to avoid pro-rata rule complications.

Mega-backdoor Roth IRA

Definition: Converting after-tax 401k contributions to Roth IRA money.

Mechanics: Make after-tax contributions to your 401k beyond the pre-tax/Roth limits. Then either convert directly to Roth IRA (if plan allows) or roll to a rollover IRA first, then convert to Roth IRA. No additional taxes since money was already taxed.

When it can be done: Whenever your 401k plan allows after-tax contributions and in-service distributions or conversions.

Notes: Total 401k contributions (pre-tax + Roth + after-tax) are limited to $71,000 for 2025 ($78,500 if 50+). Not all 401k plans offer this option.

Introducing Haystack – a grab bag of extension methods for .NET

Programming, Software

Like many developers, I have collected a bunch of useful methods over time. Most of the time, these methods don’t have unit tests, nor do they have performance tests. Many of them have origins at StackOverflow — which uses the MIT license — and many of them don’t.

I started collecting them formally about two years ago. Recently I decided to actually turn them into something I could consume via nuget, because I was getting fed up with copying and pasting code everywhere.

Compatibility

Haystack targets .NET Standard 1.3, which means it works with:

  • .NET 4.6+
  • .NET Core 1.0+
  • Mono 4.6+
  • UWP 10+

Tradeoffs

  • Performance vs maintainability: If I have to choose between maintainability and raw speed, I’ll choose maintainability. To that end, if there were was more than one maintainable approach, I chose the faster of the two, using Benchmark.NET to determine the winner. In some cases, like constant time string comparisons, slower is actually better, so as not to leak information, but only in certain places, so those places where optimizations might leak information are purposely slow, whereas the less security-critical areas use the faster implementation.
  • Correctness: For the most part, each method has unit tests associated with it.

Examples

string.ConstantTimeCompare

Constant time string comparison matter in cryptography for various reasons. To that end, fast string comparisons can leak information, so we want to exhaustively check all the bytes in the string, even if we know the strings aren’t equal early on.

const string here = "Here";
const string there = "There";
 
var areSame = here.ConstantTimeEquals(there);   // false

string.TrimStart and string.TrimEnd

It’s useful to be able to remove substrings from the beginning and/or end of a string. With or without a StringComparer overload.

const string trim = "Hello world";
const string hello = "Hello worldThis is a hello worldHello world";
 
var trimFront = hello.TrimStart(trim);   // This is a hello worldHello world
var trimEnd = hello.TrimEnd(trim);       // Hello worldThis is a hello world
var trimBoth = hello.Trim(trim);         // This is a hello world

The library is growing bit-by-bit, and contributions are welcome!

Productivity fetishism

Happiness

I switched to Firefox recently, which has a “Recommended by Pocket” section on the New Tab page. As I expected, many of the recommendations are productivity fetish articles from Lifehacker and similar rubbish. Their job is not to make you more productive–whatever that means–it’s to keep you reading.

Instead:

  1. Discover what’s valuable. Talk to people with high visibility and the insight to match. That could be an executive, or it could be your spouse.
  2. Do only valuable things. Being busy doesn’t mean you’re doing anything worth doing.
  3. Learn your tools. If something feels like it’s harder than it should be, you’re using the wrong tool, or you don’t know your tools well enough.

If you follow these guidelines, you’ll be happier, less stressed, and deliver more value.

9 observations on 6 months of running a moderately-successful open source project

ical.net, Programming

I’ve run ical.net, an RFC-5545 (icalendar) library for .NET since ~May 2016. It’s basically the only game in town if you need to do anything with icalendar-formatted data. (Those .ics files you get as email attachments are icalendar data.)

A lot of these fall into the “pretty obvious” category of observations.

1) Release notes matter

If nothing else, it serves as a historical reference for your own benefit. It also helps your users understand whether it’s worth upgrading. And when your coworkers ask if a version jump is important weeks after you’ve published it, you can point them to the release notes for that version, and they’ll never ask you again.

2) Automation is important

One of the best things I did when I first figured out how to make a nuget package was push as much into my nuspec file as I could. Everything I learned about various do’s and don’ts was pushed into the code in the moment I learned it.

Not everything in ical.net is automated, and I think I’m OK with that for now. For example, a merge doesn’t trigger a new nuget package version. I think that’s probably a feature rather than a bug.

I suspect I’ll reach a second tipping point where

3) Document in public

Scott Hanselman has the right of this:

Keep your emails to 3-4 sentences, Hanselman says. Anything longer should be on a blog or wiki or on your product’s documentation, FAQ or knowledge base. “Anywhere in the world except email because email is where your keystrokes go to die,” he says.

That means I reply to a lot of emails with a variation of “Please ask this on StackOverflow so I can answer it in public.” And many of those answers are tailored to the question, and then I include a link to a wiki page that answers a more general form of the question. Public redundancy is okay.

Accrete your public documentation.

4) Broken unit tests should be fixed or (possibly) deleted

When I took over dday.ical, there were about 70 (out of maybe 250) unit tests that were failing. There was so much noise that it was impossible to know anything about the state of the code. My primary aim was to improve performance for some production issues that we were having, but I couldn’t safely do that without resolving the crazy number of broken unit tests.

The first thing I did was evaluate each and every broken test, and decide what to do. Having a real, safe baseline was imperative, because you never want to introduce a regression that could have been caught.

The corollary to this is that sometimes your unit tests assert the wrong things. So a bugfix in one place may expose an bad assertion in a unit test elsewhere. That happened quite a lot, especially early on.

5) Making code smaller is always the right thing to do

(So long as your unit tests are passing.)

Pinning down what “smaller” means is difficult. Lines of code may be a rough proxy, but I think I mean smaller in the sense of “high semantic density” + “low cognitive load”.

  • Reducing cognitive load can be achieved by simple things like reducing the number of superfluous types; eliminating unnecessary layers of indirection; having descriptive variable and method names; and having a preference for short, pure methods.
  • Semantic density can be increased by moving to a more declarative style of programming. Loops take up a lot of space and aren’t terribly powerful compared to their functional analogs: map, filter, fold, etc. (I personally find that I write more bugs when writing imperative code. YMMV.) You won’t find many loops in ical.net, but you will find a lot of LINQ.

I think a preference for semantic density is a taste that develops over time.

6) Semantic versioning is the bee’s knees

In a nutshell:

Given a version number MAJOR.MINOR.PATCH, increment the:

  1. MAJOR version when you make incompatible API changes,
  2. MINOR version when you add functionality in a backwards-compatible manner, and
  3. PATCH version when you make backwards-compatible bug fixes.

This seems like common sense advice, but by imposing some modest constraints, it frees you from thinking about certain classes of problems:

  • It’s concrete guidance to contributors as to why their pull requests are or are not acceptable, namely: breaking changes are a no-no
  • Maintaining a stable API is a good way to inspire confidence in consumers of your library

And by holding my own feet to the fire, and following my own rules, I’m a better developer.

7) People will want bleeding-edge features, but delivering them might not be the highest-impact thing you can do

.NET Core is an exciting development. I would LOVE for ical.net to have a .NET Core version, and I’ve made some strides in that direction. But the .NET Core tooling is still beta, the progress in VS 2017 RC notwithstanding. I spent some time trying to get a version working–and I did–but I couldn’t see any easy way to automate the compilation of a .NET Core nuget package alongside the normal framework versions without hating my life.

So I abandoned it.

When the tooling is out of beta, I expect maintaining a Core version will be easier and Core adoption will be higher, both of which improve the ROI with respect to development effort.

8) It’s all cumulative

Automation, comprehensive unit test coverage with a mandatory-100% pass rate, lower cognitive load, higher semantic density, etc. All these things help you go faster with a high degree of confidence later on.

9) People are bad at asking questions and opening tickets

And if you’re not okay with that, then being a maintainer might not be a good fit for you.

  • No, I really can’t make sense of your 17,000-line Google Calendar attachment, sorry.
  • No, I won’t debug your application for you, just because it uses ical.net on 2 lines of your 100+ line method, sorry.
  • No, I’m not going to drop everything to help you, no matter how many emails you send me in a 10 minute time interval, sorry.

All of these things are common when you run an open source project that has traction. Ask anyone.

A self-contained, roll-forward schema updater

Programming, Software,

I use Dapper for most of my database interactions. I like it because it’s simple, and does exactly one thing: runs SQL queries, and returns the typed results.

I also like to deploy my schema changes as part of my application itself instead of doing it as a separate data deployment. On application startup, the scripts are loaded and executed in lexical order one by one, where each schema change is idempotent in isolation.

The problem you run into is making destructive changes to schema, which is a reasonable thing to want to do. If script 003 creates a column of UNIQUEIDENTIFIER, and you want to convert that column to NVARCHAR in script 008, you have to go back do some reconciliation between column types. Adding indexes into the mix makes it even hairier. Scripts that are idempotent in isolation are easy to write. Maintaining a series of scripts that can be safely applied in order from beginning to end every time an application starts up is not.

Unless you keep track of which schema alterations have already been applied, and only apply the changes that the application hasn’t seen before. Here’s a short, self-contained implementation:

public class SchemaUpdater
{
  private readonly string _connectionString;
  private readonly ILog _logger;
  private readonly string _environment;
 
  public SchemaUpdater(string connectionString, string environment)
    : this(connectionString, environment, LogManager.GetLogger(typeof(SchemaUpdater))) { }
 
  internal SchemaUpdater(string connectionString, string environment, ILog logger)
  {
    _connectionString = connectionString;
    _environment = environment;
    _logger = logger;
  }
 
  public void UpdateSchema()
  {
    MaybeCreateAuditTable();
    var previousUpdates = GetPreviousSchemaUpdates();
 
    var assemblyPath = Uri.UnescapeDataString(new UriBuilder(typeof(SchemaUpdater).GetTypeInfo().Assembly.CodeBase).Path);
    var schemaDirectory = Path.Combine(Path.GetDirectoryName(assemblyPath), "schema-updates");
 
    var schemaUpdates = Directory.EnumerateFiles(schemaDirectory, "*.sql", SearchOption.TopDirectoryOnly)
      .Select(fn => new { FullPath = fn, Filename = Path.GetFileName(fn) })
      .Where(file => !previousUpdates.Contains(file.Filename))
      .OrderBy(file => file.Filename)
      .Select(file => new { file.Filename, Query = File.ReadAllText(file.FullPath) })
      .ToList();
 
    foreach (var update in schemaUpdates)
    {
      using (var connection = new SqlConnection(_connectionString))
      {
        try
        {
          var splitOnGo = SplitOnGo(update.Query);
          foreach (var statement in splitOnGo)
          {
            try
            {
              connection.Execute(statement);
            }
            catch (Exception exception)
            {
              Console.WriteLine(exception);
              throw;
            }
          }
 
          connection.Execute("INSERT INTO SchemaRevision (Filename, FileContents) VALUES (@filename, @fileContent)",
            new { filename = update.Filename, fileContent = update.Query });
        }
        catch (Exception e)
        {
          _logger.Fatal(new { Message = "Unable to apply schema change", update.Filename, update.Query, Environment = _environment }, e);
          throw;
        }
      }
    }
  }
 
  public static ICollection<string> SplitOnGo(string sqlScript)
  {
    // Split by "GO" statements
    var statements = Regex.Split(
      sqlScript,
      @"^[\t\r\n]*GO[\t\r\n]*\d*[\t\r\n]*(?:--.*)?$",
      RegexOptions.Multiline |
      RegexOptions.IgnorePatternWhitespace |
      RegexOptions.IgnoreCase);
 
    // Remove empties, trim, and return
    var materialized = statements
      .Where(x => !string.IsNullOrWhiteSpace(x))
      .Select(x => x.Trim(' ', '\r', '\n'))
      .ToList();
 
    return materialized;
  }
 
  internal void MaybeCreateAuditTable()
  {
    const string createAuditTable =
@"IF NOT EXISTS(SELECT 1 FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'SchemaRevision')
BEGIN
CREATE TABLE [dbo].[SchemaRevision]
(
[SchemaRevisionNbr] BIGINT IDENTITY(1,1),
[Filename] VARCHAR(256),
[FileContents] VARCHAR(MAX),
CONSTRAINT PK_SchemaRevision PRIMARY KEY (SchemaRevisionNbr),
)
END";
 
    using (var connection = new SqlConnection(_connectionString))
    {
      connection.Execute(createAuditTable);
    }
  }
 
  internal HashSet<string> GetPreviousSchemaUpdates()
  {
    using (var connection = new SqlConnection(_connectionString))
    {
      var results = connection.Query<string>(@"SELECT Filename FROM SchemaRevision");
      return new HashSet<string>(results, StringComparer.OrdinalIgnoreCase);
    }
  }
}

Update 2017-09-05: I added the SplitOnGo() method to support the GO delimiter, since I’ve had occasion to need it recently. It’s adapted from Matt Johnson’s answer on StackOverflow.