ImHashMap<int, SampleClass> vs MemoryOwner<SampleClass>

ImToolsVsMemoryOwner.csproj

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="BenchmarkDotNet" Version="0.13.12" />
    <PackageReference Include="CommunityToolkit.HighPerformance" Version="8.2.2" />
    <PackageReference Include="DotNext.IO" Version="4.15.0" />
    <PackageReference Include="ImTools" Version="4.0.0" />
  </ItemGroup>

</Project>

Program.cs

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Jobs;
using BenchmarkDotNet.Running;
using BenchmarkDotNet.Toolchains.InProcess.NoEmit;

using CommunityToolkit.HighPerformance.Buffers;

using ImTools;

namespace ImToolsVsMemoryOwner
{
    internal class Program
    {
        static void Main(string[] args)
        {
			#if DEBUG
			BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(new []{ "--filter" , "*BenchmarkClass*" }, new DebugInProcessConfig());
			#else
		BenchmarkRunner.Run<BenchmarkClass>();

			#endif
			Console.ReadKey();
		}
    }

	public class AntiVirusFriendlyConfig : ManualConfig
	{
		public AntiVirusFriendlyConfig() {
			AddJob(Job.MediumRun.WithLaunchCount(1)
					  .WithToolchain(InProcessNoEmitToolchain.Instance));
		}
	}
	[Config(typeof(AntiVirusFriendlyConfig)),
	 MemoryDiagnoser, Orderer(BenchmarkDotNet.Order.SummaryOrderPolicy.Declared), RankColumn,]
	public class BenchmarkClass
	{
		[Params(1, 10, 100)]
		public int Count;

		MemoryOwner<SampleClass> MemoryOwner;

		ImHashMap<int, SampleClass> ImTools;

		[GlobalSetup]
		public void Setup() {
			Count       = 100;
			MemoryOwner = MemoryOwner<SampleClass>.Allocate(Count, AllocationMode.Clear);
			ImTools     = ImHashMap<int, SampleClass>.Empty;
			for (int i = 0; i < Count; i++) {
				ImTools             = ImTools.AddSureNotPresent(i, new SampleClass(i));
				MemoryOwner.Span[i] = new SampleClass(i);
			}
		}

		[Benchmark]
		public void MemoryOwner_populate() {
			var mo = MemoryOwner<SampleClass>.Allocate(Count, AllocationMode.Clear);

			for (int i = 0; i < Count; i++) {
				mo.Span[i] = new SampleClass(i);
			}
		}

		[Benchmark]
		public void ImTools_populate() {
			var imt = ImHashMap<int, SampleClass>.Empty;
			for (int i = 0; i < Count; i++) {
				imt = imt.AddSureNotPresent(i, new SampleClass(i));
			}
		}

		[Benchmark]
		public void MemoryOwner_findBy() {
			for (int i = 0; i < Count; i++) {
				if (MemoryOwner.Span[i] is { } fnd) {

					var res = fnd.TargetValue;
				}
			}
		}
		[Benchmark]
		public void ImTools_tryfind() {
			for (int i = 0; i < Count; i++) {
				if (ImTools.TryFind(i, out SampleClass fnd)) {
					
					var res = fnd.TargetValue;
				}
			}
		}
		[Benchmark]
		public void ImTools_GetEntryOrNull() {
			for (int i = 0; i < Count; i++) {
				if (ImTools.GetEntryOrNull(i) is { }  fnd) {

					var res = fnd.GetSurePresent(i).Value.TargetValue;
				}
			}
		}		
	}

	class SampleClass
	{
		public SampleClass(int targetValue) { TargetValue = targetValue; }
		public int TargetValue { get; }

	}
}