using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

​

namespace SampleCore

{

   public class Program

   {

      private static Random Rnd = new Random();

​

      public static void Main(string[] args)

      {

         HashSet<int> hash = new HashSet<int>(Generate(3000000, 10));

         List<int> list = new List<int>(Generate(300000, 100));

​

         Console.WriteLine("Linq Intersect");

         Measure(LinqIntersect, hash, list);

         Console.WriteLine("HashSet Contains");

         Measure(HashSetContains, hash, list);

         Console.WriteLine("HashSet Contains Parallel");

         Measure(HashSetContainsParallel, hash, list);

         Console.WriteLine("HashSet IntersectWith");

         Measure(HashSetIntersectWith, hash, list);

      }

​

      private static IEnumerable<int> Generate(int count, int step)

      {

         int current = 0;

​

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

         {

            current = Rnd.Next(current + 1, current + step);

            yield return current;

         }

      }

​

      private static void Measure(

         Func<HashSet<int>, List<int>, IEnumerable<int>> method,

         HashSet<int> hash, List<int> list)

      {

         List<long> times = new List<long>();

​

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

         {

            Stopwatch s = Stopwatch.StartNew();

            var result = method(hash, list).ToArray();

            times.Add(s.ElapsedMilliseconds);

         }

​

         Console.WriteLine(

            "Min={0}, Max={1}, Avg={2}, StdDev={3}",

            times.Min(), times.Max(), times.Average(), StdDev(times));

      }

​

      private static double StdDev(List<long> values)

      {

         double stddev = 0;

​

         if (values.Any())

         {

            double avg = values.Average();

            double sum = values.Sum(d => Math.Pow(d - avg, 2)); 

            stddev = Math.Sqrt((sum) / (values.Count() - 1));

         }

​

         return stddev;

      }

​

      private static IEnumerable<int> LinqIntersect(HashSet<int> hash, List<int> list)

      {

         return hash.Intersect(list);

      }

​

      private static IEnumerable<int> HashSetContains(HashSet<int> hash, List<int> list)

      {

         foreach (int i in list)

         {

            if (hash.Contains(i))

               yield return i;

         }

      }

​

      private static IEnumerable<int> HashSetContainsParallel(HashSet<int> hash, List<int> list)

      {

         return list.AsParallel().Where(x => hash.Contains(x));

      }

​

      private static IEnumerable<int> HashSetIntersectWith(HashSet<int> hash, List<int> list)

      {

         HashSet<int> intersect = new HashSet<int>(list);

         intersect.IntersectWith(hash);

         return intersect;

      }

   }

}

​