ValueEnumerableBenchmarks.cs

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Configs;
using System;

namespace Benchmarks
{
    [MemoryDiagnoser]
    [MarkdownExporterAttribute.GitHub]
    public class ValueEnumerableBenchmarks2
    {
        RangeEnumerable source;

        [Params(0, 1_000, 100_000)]
        public int Count { get; set; }

        [GlobalSetup]
        public void GlobalSetup()
        {
            source = new RangeEnumerable(Count);
        }

        [Benchmark(Baseline = true)]
        public int Enumerable() => 
            CountEnumerable<RangeEnumerable, RangeEnumerable.Enumerator, int>(source);

        [Benchmark]
        public int ValueEnumerable() => 
            CountValueEnumerable<RangeEnumerable, RangeEnumerable.Enumerator, int>(source);


        public interface IMyEnumerator<T> : IDisposable
        {
            bool MoveNext();
        }

        public interface IMyEnumerable<T>
        {
            IMyEnumerator<T> GetEnumerator();
        }

        public interface IMyValueEnumerable<T, TEnumerator>
            where TEnumerator : struct, IMyEnumerator<T>
        {
            TEnumerator GetValueEnumerator();
        }     
              
        public readonly struct RangeEnumerable
            : IMyEnumerable<int>
            , IMyValueEnumerable<int, RangeEnumerable.Enumerator>
        {
            readonly int count;

            internal RangeEnumerable(int count)
            {
                this.count = count;
            }

            public IMyEnumerator<int> GetEnumerator() => new Enumerator(count);
            public Enumerator GetValueEnumerator() => new Enumerator(count);

            public struct Enumerator : IMyEnumerator<int>
            {
                readonly int count;
                int current;

                internal Enumerator(int count)
                {
                    this.count = count;
                    current = -1;
                }

                public bool MoveNext() => ++current < count;

                public void Dispose() { }
            }
        }


        static int CountEnumerable<TEnumerable, TEnumerator, TSource>(TEnumerable source)
            where TEnumerable : IMyEnumerable<TSource>
            where TEnumerator : IMyEnumerator<TSource>
        {
            var count = 0;
            var enumerator = (TEnumerator)source.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                    count++;
            }
            finally
            {
                enumerator.Dispose();
            }
            return count;
        }        

        static int CountValueEnumerable<TEnumerable, TEnumerator, TSource>(TEnumerable source)
            where TEnumerable : IMyValueEnumerable<TSource, TEnumerator>
            where TEnumerator : struct, IMyEnumerator<TSource>
        {
            var count = 0;
            using(var enumerator = source.GetValueEnumerator())
            {
                while (enumerator.MoveNext())
                    count++;
            }
            return count;
        }

    }
}