.NET (Core and Framework)

tijujohn83 wrote:

Parallel processing is supposed to increase performance, not decrease.
Am I missing something???

I are Troll

var primes = from c in Enumerable.Range(1, 10000000).AsParallel Select IsPrime(c)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace IsPrime
{
    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch sw = new Stopwatch();

            var Primes1 = from x in EnumerableForEach.ForEach(1, 10000000, 4).AsParallel()
                          where IsPrime(x)
                          select x;

            var Primes3 = from x in EnumerableForEach.ForEach(3, 10000000, 4).AsParallel()
                          where IsPrime(x)
                          select x;

            sw.Start();
            Console.WriteLine("Primes (1, step 4) collection size: {0}", Primes1.Count());
            sw.Stop();
            Console.WriteLine("Time: {0}\n", sw.Elapsed);

            sw = Stopwatch.StartNew();
            Console.WriteLine("Primes (3, step 4) collection size: {0}", Primes3.Count());
            sw.Stop();
            Console.WriteLine("Time: {0}", sw.Elapsed);
        }

        static bool IsPrime(int x)
        {
            if (x < 2) return false;

            double sqrRoot = Math.Ceiling(Math.Sqrt(x));
            bool isPrime = true;

            for (int i = 2; i < sqrRoot; i++)
            {
                if (x % i == 0)
                {
                    isPrime = false;
                    break;
                }
            }
            return isPrime;
        }
    }
}

public class EnumerableForEach
{
    public static IEnumerable<int> ForEach(int start, int limit, int step)
    {
        return new EnumerableForEach.ForEachIterator(start, limit, step);
    }


    private sealed class ForEachIterator: IEnumerable<int>, IEnumerator<int>, IDisposable
    {
        int _start;
        int _limit;
        int _step;
        int _current;
    
        public ForEachIterator(int start, int limit, int step)
        {
            _start = start;
            _limit = limit;
            _step = step;
            _current = start - step;
        }

        public IEnumerator<int> GetEnumerator()
        {
            return this;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this;
        }

        public int Current()
        {
            return _current;
        }

        public void Dispose()
        {
            
        }

        object IEnumerator.Current
        {
            get { return _current; }
        }

        public bool MoveNext()
        {
            _current += _step;
            return (_current < _limit);
        }

        public void Reset()
        {
            throw new NotImplementedException();
        }

        int IEnumerator<int>.Current
        {
            get { return _current; }
        }
    }
}

Primes (1, step 4) collection size: 332625
Time: 00:00:05.4500960
 
Primes (3, step 4) collection size: 332398
Time: 00:00:05.1003926
Press any key to continue . . .