FOREACH Vs. FOR (C#)

public static void TestFor()
       {

           Stopwatch stopwatch = Stopwatch.StartNew();
           int[] myInterger = new int[1];
           int total = 0;
           for (int i = 0; i < myInterger.Length; i++)
           {
               total += myInterger[i];
           }
           stopwatch.Stop();
           Console.WriteLine("for loop Time Elapsed={0}", stopwatch.Elapsed);
       }
       public static void TestForeach()
       {
           Stopwatch stopwatchForeach = Stopwatch.StartNew();
           int[] myInterger1 = new int[1];
           int totall = 0;
           foreach (int i in myInterger1)
           {
               totall += i;
           }

           stopwatchForeach.Stop();
           Console.WriteLine("foreach loop Time Elapsed={0}", stopwatchForeach.Elapsed);
       }

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

namespace ForVsForEach
{
    class Program
    {
        static void Main(string[] args)
        {
            EmployeeCollection<Employee> ec = new EmployeeCollection<Employee>();
            int maxItems = 1000000;
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            Console.WriteLine("Loading employee objects...");
            sw.Start();
            for (int i = 0; i < maxItems; i++)
            {
                ec.Add(new Employee(i.ToString(),i));
            }
            sw.Stop();
            Console.WriteLine(string.Format("Done loading {0} employee objects. Time lapsed {1} Milliseconds.", maxItems.ToString(), sw.Elapsed.TotalMilliseconds.ToString()));
            Console.ReadLine();

            Console.WriteLine("Reading employee objects using for() loop...");
            sw.Restart();//Available in FW 4.0 - for FW3.5 use sw.Reset();sw.Start();
            for (int i = 0; i < maxItems; i++)
            {
                string name = ec.Get(i).Name;
            }
            sw.Stop();
            Console.WriteLine(string.Format("Done reading {0} employee objects using for() loop. Time lapsed {1} Milliseconds.", maxItems.ToString(), sw.Elapsed.TotalMilliseconds.ToString()));
            Console.ReadLine();

            Console.WriteLine("Reading employee objects using ForEach() loop...");
            sw.Restart();//Available in FW 4.0 - for FW3.5 use sw.Reset();sw.Start();
            foreach (Employee e in ec.Items)
            {
                string name = e.Name;
            }
            sw.Stop();
            Console.WriteLine(string.Format("Done reading {0} employee objects using ForEach() loop. Time lapsed {1} Milliseconds.", maxItems.ToString(), sw.Elapsed.TotalMilliseconds.ToString()));
            Console.ReadLine();

            ec.Clear();
        }
    }



    class Employee
    {
        public Employee(string name,int salary)
        {
            this.Name = name;
            this.Salary = salary;
        }

        public string Name { get; set; }
        public int Salary{ get; set; } 
    }

    public class EmployeeCollection<T> 
    {
        private List<T> ar = new List<T>();

        public T Get(int pos)
        { return ar[pos]; }

        public void Add(T c)
        { ar.Add(c); }

        public void Clear()
        { ar.Clear(); }

        public int Count
        { get { return ar.Count; } }

        public List<T> Items
        { get { return ar; } }

    }

}

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Collections;
using System.Threading;
using System.IO;

namespace FOREACHVSFOR
{
    /// <summary>
    /// Checks FOREACH VS FOR.
    /// Code can be ran to check multiple times and take the average or to take the total.
    /// </summary>
    class Program
    {
        #region Array/Collection
        static ArrayList ari1 = null;
        static ArrayList ari2 = null;
        static List<int> ari3 = null;
        static List<int> ari4 = null;
        static int[] ari5 = null;
        static int[] ari6 = null;

        static ArrayList arl1 = null;
        static ArrayList arl2 = null;
        static List<BoringObjectClass> arl3 = null;
        static List<BoringObjectClass> arl4 = null;
        static BoringObjectClass[] arl5 = null;
        static BoringObjectClass[] arl6 = null;
        #endregion

        #region Times
        static long ar1Time = 0;
        static long ar2Time = 0;
        static long ar3Time = 0;
        static long ar4Time = 0;
        static long ar5Time = 0;
        static long ar6Time = 0;
        #endregion

        /// <summary>
        /// Class to test out in collection.
        /// </summary>
        class BoringObjectClass: Object
        {
            /// <summary>
            /// Some int to use.
            /// </summary>
            public int SomeInt = 0;
            public BoringObjectClass(int v)
            {
                SomeInt=v;
            }
        }
        /// <summary>
        /// Set at runtime by user.
        /// </summary>
        static int intsToTest = 0;

        /// <summary>
        /// Set at runtime by user.
        /// </summary>
        static int objectsToTest = 0;

        /// <summary>
        /// Output results to a log file?
        /// </summary>
        static bool SaveToLog = true;

        /// <summary>
        /// Log file name, if you want to log info set SaveToLog to true.
        /// </summary>
        static string LogFileName = "FORVSFOREACH.log";

        /// <summary>
        /// Set to true if you want to append the current log file (if any) otherwise we will overwrite.
        /// </summary>
        static bool AppendLog = false;

        /// <summary>
        /// Let the thread sleep in between runs.
        /// </summary>
        static int SleepTimeInBetween = 5000;

        /// <summary>
        /// Stores results.
        /// </summary>
        static StringBuilder builder;

        /// <summary>
        /// Char array to split new lines.
        /// </summary>
        static char[] sp = new char[] { char.Parse("\n") };

        /// <summary>
        /// Runs the check on arrays of ints.
        /// </summary>
        static void IntCheck()
        {
            Stopwatch sp = new Stopwatch();
            int fill = 0;

            if (ari1 == null || ari1.Count != intsToTest)
            {
                ari1 = null;
                ari1 = new ArrayList(intsToTest);
            }
            if (ari2 == null || ari2.Count != intsToTest)
            {
                ari2 = null;
                ari2 = new ArrayList(intsToTest);
            }
            if (ari3 == null || ari3.Count != intsToTest)
            {
                ari3 = null;
                ari3 = new List<int>(intsToTest);
            }
            if (ari4 == null || ari4.Count != intsToTest)
            {
                ari4 = null;
                ari4 = new List<int>(intsToTest);
            }
            if (ari5 == null || ari5.Length != intsToTest)
            {
                ari5 = null;
                ari5 = new int[intsToTest];
            }
            if (ari6 == null || ari6.Length != intsToTest)
            {
                ari6 = null;
                ari6 = new int[intsToTest];
            }

            while (fill < intsToTest)
            {
                ari1.Add(fill);
                ari2.Add(fill);
                ari3.Add(fill);
                ari4.Add(fill);
                ari5[fill] = fill;
                ari6[fill] = fill;

                fill++;
            }

            fill = 0;
            sp.Reset();
            Thread.Sleep(SleepTimeInBetween);
            sp.Start();
            for (int i = 0; i < ari1.Count; i++)
                fill = (int) ari1[i];
            sp.Stop();
            ar1Time += sp.ElapsedMilliseconds;

            fill = 0;
            sp.Reset();
            Thread.Sleep(SleepTimeInBetween);
            sp.Start();
            foreach (int i in ari2)
                fill = (int) ari2[i];
            sp.Stop();
            ar2Time+= sp.ElapsedMilliseconds;

            fill = 0;
            sp.Reset();
            Thread.Sleep(SleepTimeInBetween);
            sp.Start();
            for (int i = 0; i < ari3.Count; i++)
                fill = ari3[i];
            sp.Stop();
            ar3Time += sp.ElapsedMilliseconds;

            fill = 0;
            sp.Reset();
            Thread.Sleep(SleepTimeInBetween);
            sp.Start();
            foreach (int i in ari4)
                fill = ari4[i];
            sp.Stop();
            ar4Time += sp.ElapsedMilliseconds;

            fill = 0;
            sp.Reset();
            Thread.Sleep(SleepTimeInBetween);
            sp.Start();
            for (int i = 0; i < ari5.Length; i++)
                fill = ari5[i];
            sp.Stop();
            ar5Time += sp.ElapsedMilliseconds;

            fill = 0;
            sp.Reset();
            Thread.Sleep(SleepTimeInBetween);
            sp.Start();
            foreach (int i in ari6)
                fill = ari6[i];
            sp.Stop();
            ar6Time += sp.ElapsedMilliseconds;
            fill = 0;
        }

        /// <summary>
        /// Runs the check on arrays of objects.
        /// </summary>
        static void ObjectCheck()
        {
            Stopwatch sp = new Stopwatch();
            int fill = 0;

            if (arl1 == null || arl1.Count != objectsToTest)
            {
                arl1 = null;
                arl1 = new ArrayList(objectsToTest);
            }
            if (arl2 == null || arl2.Count != objectsToTest)
            {
                arl2 = null;
                arl2 = new ArrayList(objectsToTest);
            }
            if (arl3 == null || arl3.Count != objectsToTest)
            {
                arl3 = null;
                arl3 = new List<BoringObjectClass>(objectsToTest);
            }
            if (arl4 == null || arl4.Count != objectsToTest)
            {
                arl4 = null;
                arl4 = new List<BoringObjectClass>(objectsToTest);
            }
            if (arl5 == null || arl5.Length != objectsToTest)
            {
                arl5 = null;
                arl5 = new BoringObjectClass[objectsToTest];
            }
            if (arl6 == null || arl6.Length != objectsToTest)
            {
                arl6 = null;
                arl6 = new BoringObjectClass[objectsToTest];
            }

            while (fill < objectsToTest)
            {
                arl1.Add(new BoringObjectClass(fill));
                arl2.Add(new BoringObjectClass(fill));
                arl3.Add(new BoringObjectClass(fill));
                arl4.Add(new BoringObjectClass(fill));
                arl5[fill] = new BoringObjectClass(fill);
                arl6[fill] = new BoringObjectClass(fill);

                fill++;
            }

            fill = 0;
            sp.Reset();
            Thread.Sleep(SleepTimeInBetween);
            sp.Start();
            for (int i = 0; i < arl1.Count; i++)
                fill = (arl1[i] as BoringObjectClass).SomeInt;
            sp.Stop();
            ar1Time += sp.ElapsedMilliseconds;

            fill = 0;
            sp.Reset();
            Thread.Sleep(SleepTimeInBetween);
            sp.Start();
            foreach (BoringObjectClass i in arl2)
                fill = i.SomeInt;
            sp.Stop();
            ar2Time+= sp.ElapsedMilliseconds;

            fill = 0;
            sp.Reset();
            Thread.Sleep(SleepTimeInBetween);
            sp.Start();
            for (int i = 0; i < arl3.Count; i++)
                fill = arl3[i].SomeInt;
            sp.Stop();
            ar3Time += sp.ElapsedMilliseconds;

            fill = 0;
            sp.Reset();
            Thread.Sleep(SleepTimeInBetween);
            sp.Start();
            foreach (BoringObjectClass i in arl4)
                fill = i.SomeInt;
            sp.Stop();
            ar4Time += sp.ElapsedMilliseconds;

            fill = 0;
            sp.Reset();
            Thread.Sleep(SleepTimeInBetween);
            sp.Start();
            for (int i = 0; i < arl5.Length; i++)
                fill = arl5[i].SomeInt;
            sp.Stop();
            ar5Time += sp.ElapsedMilliseconds;

            fill = 0;
            sp.Reset();
            Thread.Sleep(SleepTimeInBetween);
            sp.Start();
            foreach (BoringObjectClass i in arl6)
                fill = i.SomeInt;
            sp.Stop();
            ar6Time += sp.ElapsedMilliseconds;
            fill = 0;
        }

        /// <summary>
        /// Starts the check on arrays of ints.
        /// </summary>
        static void BeginIntCheck()
        {
            int illiterations = 0;

            while (true)
            {
                Console.WriteLine();
                Console.WriteLine();
                Console.WriteLine("Integer Test.");
                Console.WriteLine("Press: Enter to run [n] times. R to average [n] times. A to add [n] times. Escape to go back.");
               
                ar1Time = 0;
                ar2Time = 0;
                ar3Time = 0;
                ar4Time = 0;
                ar5Time = 0;
                ar6Time = 0;
                builder = new StringBuilder();

                switch (Console.ReadKey().Key)
                {
                    case ConsoleKey.Enter:
                        intsToTest = GetCount();
                        Console.WriteLine();
                        Console.WriteLine("Running... This may take a few minutes.");

                        IntCheck();

                        builder.AppendLine("Int Test Results");
                        builder.AppendLine("FOR loop time on ArrayList with " + intsToTest + " items:");
                        builder.AppendLine("Elapsed Milliseconds: " + ar1Time);
                        builder.AppendLine("FOREACH loop time on ArrayList with " + intsToTest + " items:");
                        builder.AppendLine("Elapsed Milliseconds: " + ar2Time);
                        builder.AppendLine("FOR loop time on generic collection with " + intsToTest + " items:");
                        builder.AppendLine("Elapsed Milliseconds: " + ar3Time);
                        builder.AppendLine("FOREACH loop time on generic collection with " + intsToTest + " items:");
                        builder.AppendLine("Elapsed Milliseconds: " + ar4Time);
                        builder.AppendLine("FOR loop time on array with " + intsToTest + " items:");
                        builder.AppendLine("Elapsed Milliseconds: " + ar5Time);
                        builder.AppendLine("FOREACH loop time on array with " + intsToTest + " items:");
                        builder.AppendLine("Elapsed Milliseconds: " + ar6Time);
                        LogIt();

                        builder.Remove(0, builder.Length);
                        builder = null;

                        break;
                    case ConsoleKey.A:
                        intsToTest = GetCount();
                        Console.WriteLine();
                        illiterations = GetIlliterations();
                        Console.WriteLine();
                        Console.WriteLine("Running... This may take a few minutes.");

                        for (int i = 0; i < illiterations; i++)
                            IntCheck();

                        builder.AppendLine("Int Test Results");
                        builder.AppendLine("FOR loop time on ArrayList with " + intsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Total Elapsed Milliseconds: " + ar1Time);
                        builder.AppendLine("FOREACH loop time on ArrayList with " + intsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Total Elapsed Milliseconds: " + ar2Time);
                        builder.AppendLine("FOR loop time on generic collection with " + intsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Total Elapsed Milliseconds: " + ar3Time);
                        builder.AppendLine("FOREACH loop time on generic collection with " + intsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Total Elapsed Milliseconds: " + ar4Time);
                        builder.AppendLine("FOR loop time on array with " + intsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Total Elapsed Milliseconds: " + ar5Time);
                        builder.AppendLine("FOREACH loop time on array with " + intsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Total Elapsed Milliseconds: " + ar6Time);
                        LogIt();

                        builder.Remove(0, builder.Length);
                        builder = null;

                        break;
                    case ConsoleKey.R:
                        intsToTest = GetCount();
                        Console.WriteLine();
                        illiterations = GetIlliterations();
                        Console.WriteLine();
                        Console.WriteLine("Running... This may take a few minutes.");

                        for (int i = 0; i < illiterations; i++)
                            IntCheck();

                        builder.AppendLine("Int Test Results");
                        builder.AppendLine("FOR loop time on ArrayList with " + intsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Average Elapsed Milliseconds: " + ( ar1Time / (decimal) illiterations ));
                        builder.AppendLine("FOREACH loop time on ArrayList with " + intsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Average Elapsed Milliseconds: " + ( ar2Time / (decimal) illiterations ));
                        builder.AppendLine("FOR loop time on generic collection with " + intsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Average Elapsed Milliseconds: " + ( ar3Time / (decimal) illiterations ));
                        builder.AppendLine("FOREACH loop time on generic collection with " + intsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Average Elapsed Milliseconds: " + ( ar4Time /(decimal) illiterations ));
                        builder.AppendLine("FOR loop time on array with " + intsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Average Elapsed Milliseconds: " + ( ar5Time / (decimal) illiterations ));
                        builder.AppendLine("FOREACH loop time on array with " + intsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Average Elapsed Milliseconds: " + ( ar6Time / (decimal) illiterations ));
                        builder.AppendLine();
                        LogIt();

                        builder.Remove(0, builder.Length);
                        builder = null;

                        break;
                    case ConsoleKey.Escape:
                        return;
                    default:
                        break;
                }
            }
        }

        /// <summary>
        /// Starts the check on arrays of objects.
        /// </summary>
        static void BeginObjCheck()
        {
            int illiterations = 0;

            while (true)
            {
                Console.WriteLine();
                Console.WriteLine();
                Console.WriteLine("Object Test.");
                Console.WriteLine("Press: Enter to run [n] times. R to average [n] times. A to add [n] times. Escape to go back.");

                ar1Time = 0;
                ar2Time = 0;
                ar3Time = 0;
                ar4Time = 0;
                ar5Time = 0;
                ar6Time = 0;
                builder = new StringBuilder();

                switch (Console.ReadKey().Key)
                {
                    case ConsoleKey.Enter:
                        objectsToTest = GetCount();
                        Console.WriteLine();
                        Console.WriteLine("Running... This may take a few minutes.");

                        ObjectCheck();

                        builder.AppendLine("Object Test Results");
                        builder.AppendLine("FOR loop time on ArrayList with " + objectsToTest + " items:");
                        builder.AppendLine("Elapsed Milliseconds: " + ar1Time);
                        builder.AppendLine("FOREACH loop time on ArrayList with " + objectsToTest + " items:");
                        builder.AppendLine("Elapsed Milliseconds: " + ar2Time);
                        builder.AppendLine("FOR loop time on generic collection with " + objectsToTest + " items:");
                        builder.AppendLine("Elapsed Milliseconds: " + ar3Time);
                        builder.AppendLine("FOREACH loop time on generic collection with " + objectsToTest + " items:");
                        builder.AppendLine("Elapsed Milliseconds: " + ar4Time);
                        builder.AppendLine("FOR loop time on array with " + objectsToTest + " items:");
                        builder.AppendLine("Elapsed Milliseconds: " + ar5Time);
                        builder.AppendLine("FOREACH loop time on array with " + objectsToTest + " items:");
                        builder.AppendLine("Elapsed Milliseconds: " + ar6Time);
                        LogIt();

                        builder.Remove(0, builder.Length);
                        builder = null;

                        break;
                    case ConsoleKey.A:
                        objectsToTest = GetCount();
                        Console.WriteLine();
                        illiterations = GetIlliterations();
                        Console.WriteLine();
                        Console.WriteLine("Running... This may take a few minutes.");

                        for (int i = 0; i < illiterations; i++)
                            ObjectCheck();

                        builder.AppendLine("Object Test Results");
                        builder.AppendLine("FOR loop time on ArrayList with " + objectsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Total Elapsed Milliseconds: " + ar1Time);
                        builder.AppendLine("FOREACH loop time on ArrayList with " + objectsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Total Elapsed Milliseconds: " + ar2Time);
                        builder.AppendLine("FOR loop time on generic collection with " + objectsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Total Elapsed Milliseconds: " + ar3Time);
                        builder.AppendLine("FOREACH loop time on generic collection with " + objectsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Total Elapsed Milliseconds: " + ar4Time);
                        builder.AppendLine("FOR loop time on array with " + objectsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Total Elapsed Milliseconds: " + ar5Time);
                        builder.AppendLine("FOREACH loop time on array with " + objectsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Total Elapsed Milliseconds: " + ar6Time);
                        LogIt();

                        builder.Remove(0, builder.Length);
                        builder = null;

                        break;
                    case ConsoleKey.R:
                        objectsToTest = GetCount();
                        Console.WriteLine();
                        illiterations = GetIlliterations();
                        Console.WriteLine();
                        Console.WriteLine("Running... This may take a few minutes.");

                        for (int i = 0; i < illiterations; i++)
                            ObjectCheck();

                        builder.AppendLine("Object Test Results");
                        builder.AppendLine("FOR loop time on ArrayList with " + objectsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Average Elapsed Milliseconds: " + ( ar1Time / (decimal) illiterations ));
                        builder.AppendLine("FOREACH loop time on ArrayList with " + objectsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Average Elapsed Milliseconds: " + ( ar2Time / (decimal) illiterations ));
                        builder.AppendLine("FOR loop time on generic collection with " + objectsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Average Elapsed Milliseconds: " + ( ar3Time / (decimal) illiterations ));
                        builder.AppendLine("FOREACH loop time on generic collection with " + objectsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Average Elapsed Milliseconds: " + ( ar4Time /(decimal) illiterations ));
                        builder.AppendLine("FOR loop time on array with " + objectsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Average Elapsed Milliseconds: " + ( ar5Time / (decimal) illiterations ));
                        builder.AppendLine("FOREACH loop time on array with " + objectsToTest + " items looped " + illiterations + " times:");
                        builder.AppendLine("Average Elapsed Milliseconds: " + ( ar6Time / (decimal) illiterations ));
                        builder.AppendLine();
                        LogIt();

                        builder.Remove(0, builder.Length);
                        builder = null;

                        break;
                    case ConsoleKey.Escape:
                        return;
                    default:
                        break;
                }
            }
        }

        /// <summary>
        /// Gets the count of elements to use for testing. Too high and your memory will pass 1gb.
        /// </summary>
        /// <returns>Int containing count.</returns>
        static int GetCount()
        {
            while (true)
            {
                Console.WriteLine();
                Console.WriteLine("How many elements to check?");
                Console.WriteLine("Enter 0 to use the default of int.MaxValue / 1000.");

                int iElements = 0;
                if (int.TryParse(Console.ReadLine(), out iElements))
                {
                    if (iElements > 0)
                        return iElements;
                    else if (iElements == 0)
                        return int.MaxValue / 1000;
                }
            }
        }

        /// <summary>
        /// How many times to run the test?
        /// </summary>
        /// <returns>Int holding requested illiterations.</returns>
        static int GetIlliterations()
        {
            while (true)
            {
                Console.WriteLine();
                Console.WriteLine("How many illiterations?");

                int iIlliterations = 0;
                if (int.TryParse(Console.ReadLine(), out iIlliterations))
                {
                    if (iIlliterations > 0)
                        return iIlliterations;
                }
            }
        }

        /// <summary>
        /// Log to file if SaveToLog is true. Print results out to the console.
        /// </summary>
        static void LogIt()
        {
            if (SaveToLog && builder.Length > 0)
            {
                StreamWriter wrt = null;

                try
                {
                    wrt = new StreamWriter(LogFileName, AppendLog);

                    foreach (string L in builder.ToString().Split(sp))
                        if (L.Length > 0)
                        {
                            Console.WriteLine(L);
                            wrt.WriteLine(L);
                        }
                }
                finally
                {
                    if (wrt != null)
                    {
                        wrt.Close();
                        wrt = null;
                    }
                }
            }
            else
                foreach (string L in builder.ToString().Split(sp))
                    if (L.Length > 0)
                        Console.WriteLine(L);
        }

        /// <summary>
        /// FOREACH VS FOR CHECK
        /// </summary>
        /// <param name="args">Nothing</param>
        static void Main(string[] args)
        {
            Console.WriteLine("FOREACH VS FOR CHECK");

            while (true)
            {
                Console.WriteLine();
                Console.WriteLine("Press: O to test with objects. I to test with integers. Escape to exit.");

                switch (Console.ReadKey().Key)
                {
                    case ConsoleKey.O:
                        BeginObjCheck();
                        break;
                    case ConsoleKey.I:
                        BeginIntCheck();
                        break;
                    case ConsoleKey.Escape:
                        return;
                }
            }

        }
    }
}