using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

​

public class Program

{

    // Enum to simulate your FusionConsoleUserRole

    public enum FusionConsoleUserRole

    {

        ConsoleManager,

        StandardUser,

        Administrator

    }

​

    // Simple class to simulate your data structure

    public class FusionConsoleAccount

    {

        public MetaVendor MetaVendor { get; set; }

    }

​

    public class MetaVendor

    {

        public FusionConsoleUserRole SsoUserRole { get; set; }

    }

​

    public static void Main()

    {

        // Create test data with different sizes

        var tinyList = CreateTestData(5);

        var smallList = CreateTestData(1000);

        var mediumList = CreateTestData(100000);

        var largeList = CreateTestData(1000000);

​

        // Warm up the JIT compiler

        WarmUp(tinyList);

        Console.WriteLine("Performance Test Results:\n");

        RunTest("Tiny List (5 items)", tinyList);

        RunTest("Small List (1,000 items)", smallList);

        RunTest("Medium List (100,000 items)", mediumList);

        RunTest("Large List (1,000,000 items)", largeList);

    }

​

    private static List<FusionConsoleAccount> CreateTestData(int size)

    {

        var list = new List<FusionConsoleAccount>();

        for (int i = 0; i < size; i++)

        {

            list.Add(new FusionConsoleAccount

            {

                MetaVendor = new MetaVendor

                {

                    SsoUserRole = i == 0 ? FusionConsoleUserRole.ConsoleManager : FusionConsoleUserRole.StandardUser

                }

            });

        }

        return list;

    }

    private static void WarmUp(List<FusionConsoleAccount> list)

    {

        for(int i = 0; i < 1000; i++)

        {

            var result1 = list.Contains(list.First());

            var result2 = list.Single(x => x.MetaVendor.SsoUserRole == FusionConsoleUserRole.ConsoleManager);

        }

    }

    private static void RunTest(string testName, List<FusionConsoleAccount> list)

    {

        const int iterations = 10000; // Reduced iterations as these operations are more complex

        var containsTimes = new List<double>();

        var singleTimes = new List<double>();

        Console.WriteLine($"=== {testName} ===");

        // Run multiple samples

        for(int sample = 0; sample < 10; sample++)

        {

            var sw = Stopwatch.StartNew();

            // Test Contains()

            for(int i = 0; i < iterations; i++)

            {

                var result = list.Any(x => x.MetaVendor.SsoUserRole == FusionConsoleUserRole.ConsoleManager);

            }

            sw.Stop();

            containsTimes.Add(sw.Elapsed.TotalMilliseconds);

            sw.Reset();

            sw.Start();

            // Test Single()

            for(int i = 0; i < iterations; i++)

            {

                try

                {

                    var result = list.Single(x => x.MetaVendor.SsoUserRole == FusionConsoleUserRole.ConsoleManager);

                }

                catch { } // Handle potential InvalidOperationException

            }

            sw.Stop();

            singleTimes.Add(sw.Elapsed.TotalMilliseconds);

        }

        // Calculate and display statistics

        DisplayStatistics("Contains()", containsTimes);

        DisplayStatistics("Single()", singleTimes);

        // Compare results

        CompareResults(containsTimes.Average(), singleTimes.Average());

    }

    private static void DisplayStatistics(string methodName, List<double> times)

    {

        double avg = times.Average();

        double median = CalculateMedian(times);

        double stdDev = CalculateStdDev(times);

        Console.WriteLine($"\n{methodName} Results:");

        Console.WriteLine($"  Average: {avg:F3}ms");

        Console.WriteLine($"  Median: {median:F3}ms");

        Console.WriteLine($"  Std Dev: {stdDev:F3}ms");

    }

    private static void CompareResults(double containsAvg, double singleAvg)

    {

        double difference = Math.Abs(containsAvg - singleAvg);

        string faster = containsAvg < singleAvg ? "Contains()" : "Single()";

        Console.WriteLine($"\nWinner: {faster}");

        Console.WriteLine($"Time Difference: {difference:F3}ms");

        Console.WriteLine($"Percentage difference: {(difference / Math.Max(containsAvg, singleAvg) * 100):F2}%\n");

    }

    private static double CalculateMedian(List<double> values)

    {

        var sortedValues = values.OrderBy(x => x).ToList();

        int count = sortedValues.Count;

        if (count % 2 == 0)

            return (sortedValues[count / 2 - 1] + sortedValues[count / 2]) / 2;

        return sortedValues[count / 2];

    }

    private static double CalculateStdDev(List<double> values)

    {

        double avg = values.Average();

        double sumOfSquaresOfDifferences = values.Select(val => (val - avg) * (val - avg)).Sum();

        return Math.Sqrt(sumOfSquaresOfDifferences / (values.Count - 1));

    }

}