CallingTypeBenchmark

CallingTypeBenchmark.cs

using System.Diagnostics;

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

namespace CallingTypeBenchmark;

// NuGet: BenchmarkDotNet

public delegate Int64 AClassicCall(Int64 aLong, String aString, SimulatedPayload aPayload);
public delegate Int64 AClassCall(ParameterClass aParameter);
public delegate Int64 AClassRecordCall(ParameterClassRecord aParameter);
public delegate Int64 AStructCall(ParameterStruct aParameter);
public delegate Int64 AStructRecordCall(ParameterStructRecord aParameter);


[MemoryDiagnoser]
public class Program
{
  public static void Main()
  {
    var summary = BenchmarkRunner.Run<Program>();
    Console.WriteLine(summary);
  }

  [Benchmark(Baseline = true)]
  public void TestClassicCall()
  {
    Int64 total;
    total = 0;
    foreach (var counter in Enumerable.Range(0, 1000))
    {
      var aLong = counter;
      var aString = DateTime.Now.ToString();
      var aPayload = new SimulatedPayload();
      total += ClassicCall(aLong, aString, aPayload);
    }
    Debug.WriteLine(total.ToString());
  }

  [Benchmark]
  public void TestClassCall()
  {
    Int64 total;
    total = 0;
    foreach (var counter in Enumerable.Range(0, 1000))
    {
      var aLong = counter;
      var aString = DateTime.Now.ToString();
      var aPayload = new SimulatedPayload();
      total += ClassCall(new(aLong, aString, aPayload));
    }
    Debug.WriteLine(total.ToString());
  }


  [Benchmark]
  public void TestClassRecordCall()
  {
    Int64 total;
    total = 0;
    foreach (var counter in Enumerable.Range(0, 1000))
    {
      var aLong = counter;
      var aString = DateTime.Now.ToString();
      var aPayload = new SimulatedPayload();
      total += ClassRecordCall(new(aLong, aString, aPayload));
    }
    Debug.WriteLine(total.ToString());
  }


  [Benchmark]
  public void TestStructCall()
  {
    Int64 total;
    total = 0;
    foreach (var counter in Enumerable.Range(0, 1000))
    {
      var aLong = counter;
      var aString = DateTime.Now.ToString();
      var aPayload = new SimulatedPayload();
      total += StructCall(new(aLong, aString, aPayload));
    }
    Debug.WriteLine(total.ToString());
  }


  [Benchmark]
  public void TestStructRecordCall()
  {
    Int64 total;
    total = 0;
    foreach (var counter in Enumerable.Range(0, 1000))
    {
      var aLong = counter;
      var aString = DateTime.Now.ToString();
      var aPayload = new SimulatedPayload();
      total += StructRecordCall(new(aLong, aString, aPayload));
    }
    Debug.WriteLine(total.ToString());
  }


  public static Int64 ClassicCall(Int64 aLong, String aString, SimulatedPayload aPayload)
  {
    // simulate work
    return $"{aLong}{aString}{aPayload.FirstName}{aPayload.LastName}".Length;
  }
  public static Int64 ClassCall(ParameterClass a)
  {
    // simulate work
    return $"{a.ALong}{a.AString}{a.APayload.FirstName}{a.APayload.LastName}".Length;
  }

  public static Int64 ClassRecordCall(ParameterClassRecord a)
  {
    // simulate work
    return $"{a.ALong}{a.AString}{a.APayload.FirstName}{a.APayload.LastName}".Length;
  }

  public static Int64 StructCall(ParameterStruct a)
  {
    // simulate work
    return $"{a.ALong}{a.AString}{a.APayload.FirstName}{a.APayload.LastName}".Length;
  }

  public static Int64 StructRecordCall(ParameterStructRecord a)
  {
    // simulate work
    return $"{a.ALong}{a.AString}{a.APayload.FirstName}{a.APayload.LastName}".Length;
  }


}


//

public class ParameterClass
{
  public ParameterClass(Int64 aLong, String aString, SimulatedPayload aPayload) => (ALong, AString, APayload) = (aLong, aString, aPayload);
  public Int64 ALong { get; private set; }
  public String AString { get; private set; }
  public SimulatedPayload APayload { get; private set; }
}

public record class ParameterClassRecord(Int64 ALong, String AString, SimulatedPayload APayload);

public struct ParameterStruct
{
  public ParameterStruct(Int64 aLong, String aString, SimulatedPayload aPayload) => (ALong, AString, APayload) = (aLong, aString, aPayload);
  public Int64 ALong { get; private set; }
  public String AString { get; private set; }
  public SimulatedPayload APayload { get; private set; }
}

public record struct ParameterStructRecord(Int64 ALong, String AString, SimulatedPayload APayload);

//

public class SimulatedPayload
{
  private static readonly Random _random = new Random();

  public SimulatedPayload() => (FirstName, LastName) = ($"Name {_random.Next(100):3}", $"Surname {_random.Next(100):3}");

  public String FirstName { get; private set; }
  public String LastName { get; private set; }
}