using BenchmarkDotNet.Running;

using BenchmarkDotNet.Attributes;

using System;

using System.Linq;

using System.Collections.Generic;

using System.Collections;

​

using ConsoleApp2.B;

using ConsoleApp2.C;

​

namespace ConsoleApp2

{

    class Program

    {

        public static void Main()

        {

            BenchmarkRunner.Run<Benchmarks>();

        }

    }

​

    public class Benchmarks

    {

        [Params(1, 10, 100, 1000, 10000, 100000)]

        public int N;

​

        A.IDataStructure<int> a;

        B.IDataStructure<int> b;

        C.IDataStructure<int> c;

​

        [IterationSetup]

        public void IterationSetup()

        {

            int[] values = Enumerable.Range(0, N).ToArray();

            a = new A.SomeDataStructure<int>() { values = values.ToArray() };

            b = new B.SomeDataStructure<int>() { values = values.ToArray() };

            c = new C.SomeDataStructure<int>() { values = values.ToArray() };

        }

​

        [Benchmark]

        public void A()

        {

            int sum = 0;

            foreach (int value in a)

            {

                sum += value;

            }

        }

​

        [Benchmark]

        public void B()

        {

            int sum = 0;

            b.Stepper(x => { sum += x; });

        }

​

        [Benchmark]

        public void C1()

        {

            SumStatic sum = default;

            c.Stepper<int, SumStatic>(sum);

        }

​

        struct SumStatic : IAction<int>

        {

            public static int sum;

​

            public void Do(int arg1)

            {

                sum += arg1;

            }

        }

​

        [Benchmark]

        public void C2()

        {

            Ref<int> sumValue = new();

            SumNonStatic sum = new(sumValue);

            c.Stepper<int, SumNonStatic>(sum);

        }

​

        struct SumNonStatic : IAction<int>

        {

            public Ref<int> sum;

​

            public SumNonStatic(Ref<int> value) => sum = value;

​

            public void Do(int arg1)

            {

                sum.value += arg1;

            }

        }

​

        class Ref<T>

        {

            public T value;

        }

​

        [Benchmark]

        public void C3()

        {

            int sum = 0;

            c.Stepper(x => { sum += x; });

            Console.WriteLine($"BLAH BLAH N{N} sum{sum}");

        }

    }

​

    namespace A

    {

        interface IDataStructure<T> : IEnumerable<T> { }

​

        class SomeDataStructure<T> : IDataStructure<T>

        {

            internal T[] values;

​

            public IEnumerator<T> GetEnumerator()

            {

                foreach (T value in values)

                {

                    yield return value;

                }

            }

​

            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

        }

    }

​

    namespace B

    {

        interface IDataStructure<T>

        {

            bool Stepper(Func<T, bool> func);

        }

​

        class SomeDataStructure<T> : IDataStructure<T>

        {

            internal T[] values;

​

            public bool Stepper(Func<T, bool> func)

            {

                foreach (T value in values)

                {

                    if (func(value))

                    {

                        return true;

                    }

                }

                return false;

            }

        }

​

        static class Extensions

        {

            public static void Stepper<T>(this IDataStructure<T> dataStructure, Action<T> action)

            {

                dataStructure.Stepper(x => { action(x); return false; });

            }

        }

    }

​

    namespace C

    {

        public interface IAction<T1>

        {

            void Do(T1 arg1);

        }

​

        public interface IFunc<T1, TResult>

        {

            TResult Do(T1 arg1);

        }

​

        interface IDataStructure<T>

        {

            bool Stepper<Step>(Step step)

                where Step : struct, IFunc<T, bool>;

        }

​

        class SomeDataStructure<T> : IDataStructure<T>

        {

            internal T[] values;

​

            public bool Stepper<Step>(Step step = default)

                where Step : struct, IFunc<T, bool>

            {

                foreach (T value in values)

                {

                    if (step.Do(value))

                    {

                        return true;

                    }

                }

                return false;

            }

        }

​

        static class Extensions

        {

            public static void Stepper<T, Step>(this IDataStructure<T> dataStructure, Step step)

                where Step : struct, IAction<T>

            {

                StepBreakFromAction<T, Step> breakableStep = new() { StepFunction = step };

                dataStructure.Stepper<StepBreakFromAction<T, Step>>(breakableStep);

            }

​

            public struct StepBreakFromAction<T, Step> : IFunc<T, bool>

                where Step : struct, IAction<T>

            {

                internal Step StepFunction;

                public bool Do(T value) { StepFunction.Do(value); return false; }

            }

​

            public static void Stepper<T>(this IDataStructure<T> dataStructure, Action<T> step)

            {

                StepBreakFromAction<T, ActionRuntime<T>> breakableStep = new() { StepFunction = step };

                dataStructure.Stepper<StepBreakFromAction<T, ActionRuntime<T>>>(breakableStep);

            }

​

            public struct ActionRuntime<T1> : IAction<T1>

            {

                /// <summary>The delegate instance.</summary>

                internal Action<T1> _delegate;

                /// <summary>Invocation of the delegate.</summary>

                public void Do(T1 arg1) => _delegate(arg1);

                /// <summary>Implicit caster from a delegate.</summary>

                public static implicit operator ActionRuntime<T1>(Action<T1> @delegate) => new() { _delegate = @delegate, };

            }

        }

    }

}

​