using System;

using System.Collections.Generic;

using System.Collections;

using System.Text;

using System.Linq;

​

using NUnit.Framework; //NUnit.Framework.AssertionException

​

    //https://stackoverflow.com/questions/53582900/calling-method-with-ienumerablet-sequence-as-argument-if-that-sequence-is-not

​

    class TestClass

    {

        public static void Test()

        {

            var list1 = new int[] { };

            var list2 = new int[] { 1, 2, 3 };

​

            Test(list1);

            Test(list2);

​

            TestNoDoubleEvaluate(list2);

​

            Console.WriteLine("Done");

        }

​

        private static void TestNoDoubleEvaluate(int[] list)

        {

            Action<IEnumerable<int>> action = (e) =>

            {

                e.Count();

                e.Count();

            };

​

            try

            {

                list.IfNonEmpty(action);

                Assert.IsTrue(false);

            }

            catch (InvalidOperationException ex)

            {

                Console.WriteLine("Caught expected exception {0}", ex.Message);

            }

        }

​

        private static void Test(int[] list)

        {

            int callCount = 0;

            int totalCount = 0;

​

            Action<IEnumerable<int>> action = (e) =>

            {

                var count = e.Count();

                Console.WriteLine("Called, count = {0}", count);

                callCount++;

                totalCount += count;

            };

​

            var oldCallCount = callCount;

            var oldTotalCount = totalCount;

            list.IfNonEmpty(action);

            Assert.IsTrue(callCount == (list.Length == 0 ? oldCallCount : oldCallCount + 1));

            Assert.IsTrue(totalCount == oldTotalCount + list.Length);

            if (oldCallCount == callCount)

                Console.WriteLine("Not called, length = {0}", list.Length);

        }

    }

​

    public static partial class EnumerableExtensions

    {

        public static bool IfNonEmpty<T>(this IEnumerable<T> source, Action<IEnumerable<T>> func)

        {

            if (source == null|| func == null)

                throw new ArgumentNullException();

            using (var enumerator = source.GetEnumerator())

            {

                if (!enumerator.MoveNext())

                    return false;

                func(new UsedEnumerator<T>(enumerator));

                return true;

            }

        }

​

        class UsedEnumerator<T> : IEnumerable<T>

        {

            IEnumerator<T> usedEnumerator;

​

            public UsedEnumerator(IEnumerator<T> usedEnumerator)

            {

                if (usedEnumerator == null)

                    throw new ArgumentNullException();

                this.usedEnumerator = usedEnumerator;

            }

​

            public IEnumerator<T> GetEnumerator()

            {

                var localEnumerator = System.Threading.Interlocked.Exchange(ref usedEnumerator, null);

                if (localEnumerator == null)

                    // An attempt has been made to enumerate usedEnumerator more than once; 

                    // throw an exception since this is not allowed.

                    throw new InvalidOperationException();

                yield return localEnumerator.Current;

                while (localEnumerator.MoveNext())

                {

                    yield return localEnumerator.Current;

                }

            }

​

            IEnumerator IEnumerable.GetEnumerator()

            {

                return GetEnumerator();

            }

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Console.WriteLine("Roslyn 2.0 Compiler; Environment version: " + Environment.Version);

            Console.WriteLine();

​

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine("Uncaught exception: ");

                Console.WriteLine(ex);

                throw;

            }

        }

    }

​