.NET (Core and Framework)

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 . . .

dybs wrote:

my goal is to get as much info as I can for unhandled exceptions

dybs wrote:

In my case that won't really work because I need this information in the UnhandledException handler, and by the time I get to this point (the first time I actually have an exception to look at), I no longer have access to the object that threw the exception.

class Program
{
    static Form myForm = new Form();
    static Button myButton = new Button();
	
    [STAThread]
    public static void Main(string[] args)
    {												
        myButton.Click += delegate 
        {
            new MyTextCache().DoLoadStuff();
        };
        myForm.Controls.Add(myButton);
		
        AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(logEx);
        Application.Run(myForm);
    }

    static void logEx(object sender, UnhandledExceptionEventArgs e)
    {
        Exception ex = (Exception)e.ExceptionObject;
        Console.WriteLine("Exception: " + e.ExceptionObject.GetType().ToString());
        if (ex.Data.Count > 0)
        {
            foreach(var item in ex.Data)
            {
                var entry = (System.Collections.DictionaryEntry)item;
                Console.WriteLine("Parameter: " + entry.Value.ToString());
            }
        }
    }
}

using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Windows.Forms;

[Serializable()]
class MyTextCache: ISerializable
{
    #region variables that represent Internal State
    string _filename;
    string _contents;
    #endregion
	
    public MyTextCache()
    {
        _filename = "Q:\\Hello World.txt";
    }
	
    public MyTextCache(SerializationInfo info, StreamingContext ctxt)
    {
        _filename = (String)info.GetValue("filename", typeof(string));
        _contents = (String)info.GetValue("contents", typeof(string));
    }
    
    public void GetObjectData(SerializationInfo info, StreamingContext ctxt)
    {
        info.AddValue("filename", _filename);
        info.AddValue("contents", _contents);
    }
	
    public override string ToString()
    {
        return string.Format("Filename: {0}\nContents: {1}\n",
            _filename, 
            _contents);
    }
	
    internal void DoLoadStuff()
    {
        try
        {
            _contents = System.IO.File.ReadAllText(_filename);
        }
        // for every exception we didn't expect;
        catch(Exception e) 
        {				
            // Add the plaintiff
            e.Data.Add("the object: ", this);

            // Don't handle now, rethrow
            throw e;
        }
    }		
}

internal void DoLoadStuff()
{
    int i = 9; // Number of attempts or somethin' the like
    try
    {
        _contents = System.IO.File.ReadAllText(_filename);
    }
    catch(Exception e)
    {				
        e.Data.Add("the object: ", this);
        e.Data.Add("local i: ", i);
        throw e;
    }
}

I are Troll