C#-Code

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Security.Cryptography;
using System.Threading.Tasks;

namespace UE13Parallel
{
	internal class Program
	{
		private static List<int> Moeglichkeiten;
		private static readonly object mylock = new object();
		private static readonly clsLotto Lotto = new clsLotto();

		internal static void Main(string[] args)
		{
			const int minZahl = 1;
			const int maxZahl = 49;
			//Lottokugeln anlegen
			Moeglichkeiten = Enumerable.Range(minZahl, maxZahl).ToList();

			List<int> tipps = new List<int>();
			while (tipps.Count < 6)
			{
				Console.Write("Bitte die {0}. Zahl des Tipps eingeben: ", tipps.Count + 1);
				int tipp;
				if (int.TryParse(Console.ReadLine(), out tipp))
				{
					if (tipp >= minZahl && tipp <= maxZahl)
					{
						tipps.Add(tipp);
					}
				}
			}
			Console.WriteLine("Lotto wird simuliert. Bitte warten.");

			Stopwatch sw = new Stopwatch();
			sw.Start();
			//Parallele "While"-Schleife mit den unten beschriebenen Methoden
			Parallel.ForEach(Extensions.Infinite(), () => new clsLotto(tipps, Moeglichkeiten), RunIteration, FinishThread);
			sw.Stop();

			Console.WriteLine("Simulation beendet nach {0:#,##0.000} Sekunden.", sw.ElapsedMilliseconds / 1000m);
			Console.WriteLine("Nach {0} Spielen wurde ein 6er erziehlt", Lotto.Durchlaeufe);
			Console.WriteLine("Die Chance auf einer 3er lag bei {0:#0.000}%", Lotto.Dreier / (decimal)Lotto.Durchlaeufe * 100m);
			Console.WriteLine("Die Chance auf einer 4er lag bei {0:#0.000}%", Lotto.Vierer / (decimal)Lotto.Durchlaeufe * 100m);
			Console.WriteLine("Die Chance auf einer 5er lag bei {0:#0.000}%", Lotto.Fuenfer / (decimal)Lotto.Durchlaeufe * 100m);
			Console.ReadKey();
		}

		/// <summary>
		/// Methode für einen Schleifendurchlauf
		/// </summary>
		/// <param name="i"></param>
		/// <param name="state">Wird zum Abbrechen der Schleife bei 6er benötigt</param>
		/// <param name="localLotto">das lokale Objekt - muss am Ende noch weiterverarbeitet werden</param>
		/// <returns></returns>
		private static clsLotto RunIteration(bool i, ParallelLoopState state, clsLotto localLotto)
		{
			var ziehung = localLotto.Moeglichkeiten.ToList().Shuffle().Take(6);
			//Anzahl der Übereinstimmungen zählen
			int gleiche = localLotto.Tipps.Intersect(ziehung).Count();
			switch (gleiche)
			{
				case 3: { localLotto.Dreier++; break; }
				case 4: { localLotto.Vierer++; break; }
				case 5: { localLotto.Fuenfer++; break; }
				case 6: { state.Break(); break; }
			}
			localLotto.Durchlaeufe++;
			return localLotto;
		}

		/// <summary>
		/// Abschlussmethode des SchleifenThreads. Addition der Teilergebnisse.
		/// </summary>
		/// <param name="localLotto"></param>
		private static void FinishThread(clsLotto localLotto)
		{
			lock (mylock)
			{
				Lotto.Dreier += localLotto.Dreier;
				Lotto.Vierer += localLotto.Vierer;
				Lotto.Fuenfer += localLotto.Fuenfer;
				Lotto.Durchlaeufe += localLotto.Durchlaeufe;
			}
		}
	}

	/// <summary>
	/// Hilfsklasse, bei paralleler Ausführung kann nur ein Objekt übergeben werden.
	/// </summary>
	internal class clsLotto
	{
		public clsLotto() 
		{}
		public clsLotto(List<int> tipps, List<int> moeglichkeiten) 
		{ 
			Tipps = tipps;
			Moeglichkeiten = moeglichkeiten;
		}
		public List<int> Tipps { get; set; }
		public List<int> Moeglichkeiten { get; set; }
		public int Durchlaeufe { get; set; }
		public int Dreier { get; set; }
		public int Vierer { get; set; }
		public int Fuenfer { get; set; }
	}

	internal static class Extensions
	{
		/// <summary>
		/// Random ordering of a list.
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="list"></param>
		internal static List<T> Shuffle<T>(this List<T> list)
		{
			var provider = new RNGCryptoServiceProvider();
			int n = list.Count;
			while (n > 1)
			{
				var box = new byte[1];
				do
				{
					provider.GetBytes(box);
				}
				while (!(box[0] < n * (Byte.MaxValue / n)));
				var k = (box[0] % n);
				n--;

				var value = list[k];
				list[k] = list[n];
				list[n] = value;
			}
			return list;
		}

		/// <summary>
		/// Hilfsmethode um von einer ForEach zu einer While-Schleife zu kommen.
		/// Bemerkung: in TPL gibts keine While-Schleife
		/// </summary>
		/// <returns></returns>
		internal static IEnumerable<bool> Infinite()
		{
			while (true) yield return true;
		}
	}
}