How to avoid heap allocation when calling interface methods on multiple struct types in a shared list [closed]

Question

Closed. This question needs to be more focused. It is not currently accepting answers.

Want to improve this question? Guide the asker to update the question so it focuses on a single, specific problem. Narrowing the question will help others answer the question concisely. You may edit the question if you feel you can improve it yourself. If edited, the question will be reviewed and might be reopened.

Closed 3 months ago.

Improve this question

I'm writing a program that is very sensitive to garbage collection so I'm trying to avoid allocating to the heap after initialization.

In the example below, calling Run() will allocate to the heap when it calls DoThing() on any of the elements in the list. This is due to things being backed by structs (Thing1, Thing2, etc).

I want to avoid this allocation, but I also don't want to have to specify multiple lists (one per struct type). Is there a way to do this cleanly and efficiently?

interface IThing
{
  void DoThing();
}

struct Thing1 : IThing
{
  public void DoThing(){}
}

struct Thing2 : IThing
{
  public void DoThing(){}
}

List<IThing> things;

void Initialize()
{
  things = new List<IThing>();

  things.Add(new Thing1());
  things.Add(new Thing2());
}

void Run()
{
  foreach(IThing thing in things)
  {
    thing.DoThing(); //this allocates to the heap due underlying type being a struct 
  }
}

You can see in the image below that there are memory allocations from Line 38.

Another example with memory allocations on Line 43.

The heap allocation actually happens when you add things to the list, as this is when the structs get boxed. There is no going around it: converting any struct instance to one of its interface types will box it. — Etienne de Martel
– Etienne de Martel, Commented Aug 27 at 23:05
What mutable state does the structs have? If you are only using them for calling interface methods, they can be readonly structs right? — Sweeper
– Sweeper, Commented Aug 27 at 23:29
Internally a List<Thing> will be backed by an array of structures. This array would still be stored on the heap. Though it would be a contiguous block of memory. The only way to avoid that is to stackalloc a Span<Thing>. — Jeremy Lakeman
– Jeremy Lakeman, Commented Aug 28 at 1:53
why are these types structs in the first place? When you add them to lists and you're afraid of allocations, which is by boxing them using any of their interfaces, then use a datastructure that doesn't have the notion of boxing - namely a class. — MakePeaceGreatAgain
– MakePeaceGreatAgain, Commented Aug 28 at 5:32
Thank you for the clarification. Then nothing is allocated in the loop. I don't know what you found related to the memory usage, but keep in mind that most methods of tracking heap memory usage are not reliable and cannot be taken into account is such a simple way. This is a big separate topic. Just don't trust them. — Sergey A Kryukov
– Sergey A Kryukov, Commented Aug 28 at 13:08

Marc Gravell · Accepted Answer · 2025-08-28 12:02:42Z

1

The short answer is "you can't" - however, as with most things there's a huge dose of "well actually" that can be employed in some niche edge cases, for example if the list only ever contains some structurally identical types - for example Memory<T> and ReadOnlyMemory<T>; in that very small family of cases, there is some evil you can apply to discriminate and "pun" at runtime, instead of using naked polymorphism.

answered Aug 28 at 12:02

Marc Gravell

1.1m273 gold badges2.6k silver badges3k bronze badges

Sign up to request clarification or add additional context in comments.

Comments

ATD · Accepted Answer · 2025-08-29 16:51:28Z

It seems I was mistaken and it does not allocate when calling the interface method.

using System;
using System.Collections.Generic;

interface IThing
{
    void DoThing();
}

struct ThingStruct : IThing
{
    public void DoThing() { }
}

class ThingClass : IThing
{
    public void DoThing() { }
}

class Program
{
    static void Main()
    {
        var thingsWithStructs = new List<IThing>();
        var thingsWithClasses = new List<IThing>();

        // Measure boxing when adding structs
        long before = GC.GetAllocatedBytesForCurrentThread();
        for (int i = 0; i < 1000; i++)
        {
            thingsWithStructs.Add(new ThingStruct()); // boxing happens here
        }
        long after = GC.GetAllocatedBytesForCurrentThread();
        Console.WriteLine($"Adding structs: {after - before} bytes allocated");

        // Measure adding classes
        before = GC.GetAllocatedBytesForCurrentThread();
        for (int i = 0; i < 1000; i++)
        {
            thingsWithClasses.Add(new ThingClass()); // no boxing
        }
        after = GC.GetAllocatedBytesForCurrentThread();
        Console.WriteLine($"Adding classes: {after - before} bytes allocated");

        // Measure calling methods on boxed structs
        before = GC.GetAllocatedBytesForCurrentThread();
        foreach (var thing in thingsWithStructs)
        {
            thing.DoThing(); // no allocation
        }
        after = GC.GetAllocatedBytesForCurrentThread();
        Console.WriteLine($"Calling DoThing() on structs: {after - before} bytes allocated");

        // Measure calling methods on classes
        before = GC.GetAllocatedBytesForCurrentThread();
        foreach (var thing in thingsWithClasses)
        {
            thing.DoThing(); // no allocation
        }
        after = GC.GetAllocatedBytesForCurrentThread();
        Console.WriteLine($"Calling DoThing() on classes: {after - before} bytes allocated");
    }
}

Output:

Adding structs: 40568 bytes allocated
Adding classes: 40568 bytes allocated
Calling DoThing() on structs: 0 bytes allocated
Calling DoThing() on classes: 0 bytes allocated

Collectives™ on Stack Overflow

How to avoid heap allocation when calling interface methods on multiple struct types in a shared list [closed]

2 Answers 2

Comments

Comments

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Related