In .Net, when if ever should I pass structs by reference for performance reasons?

Question

In my C# application, I have a large struct (176 bytes) that is passed potentially a hundred thousand times per second to a function. This function then simply takes a point

Answer 1

I did some very informal profiling, and the results indicate that, for my particular application, there is a modest performance gain for passing by reference. For by-value I got about 10,050,000 calls per second, whereas for by-reference I got about 11,200,000 calls per second.

Your mileage may vary.

Answer 2

Before you ask whether or not you should pass the struct by reference, you should ask yourself why you've got such an enormous struct in the first place. Does it really need to be a struct? If you need to use a struct at some point for P/Invoke, would it be worth having a struct just for that, and then the equivalent class elsewhere?

A struct that big is very, very unusual...

See the Design Guidelines for Developing Class Libraries section on Choosing Between Classes and Structures for more guidance on this.

Answer 3

Why not just use a class instead, and pass your class to your P/Invoke function?

Using class will pass nicely around in your managed code, and will work the same as passing a struct by reference to a P/Invoke function.

e.g.

// What you have
public struct X
{
   public int data;
}
[DllImport("mylib.dll")]
static extern void Foo( ref X arg);

// What you could do
[StructLayout(LayoutKind.Sequential)]
public class Y
{
    public int data;
}
[DllImport("mylib.dll")]
static extern void Bar( Y arg );

Answer 4

The only way you can get an answer to this question is to code up both and measure the performance.

You mention unmanaged/managed interop. My experience is that it takes a surprisingly long time to to the interop. You could try changing your code from:

void ManagedMethod(MyStruct[] items) {
  foreach (var item in items) {
    unmanagedHandle.ProcessOne(item);
  }
}

To:

void ManagedMethod(MyStruct[] items) {
  unmanagedHandle.ProcessMany(items, items.Count);
}

This technique helped me in a similar case, but only measurements will tell you if it works for your case.