In .Net I have to Iterate records which range from 1000 lines to 300,000. So which Loop will be better

Question

I have read that for loop is faster than foreach and LINQ. So I have created a small Console application to check in which I am passing a list of string of numbers with blank values.

I have use for, foreach, Parallel.ForEach, Parallel.For for the check in which it iterates it and find the Index in which the value is blank and append it to the string. I have set timer before every loop and I found that foreach is much faster than any other. Please Clarify the concept. Here is the code. I have also change List to array and try it but than also foreach is faster.

static void Main(string[] args)
{
    List<string> value = new List<string>() { "1", "2", "3", "4", "5", "6",
        "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18",
        "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29",
        "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40",
        "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51",
        "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62",
        "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73",
        "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84",
        "85", "86", "87", "88", "89", "90", "91", "92", " ", "", "", "",
        "", "", "", "  " };

    string ColName = "EMPNO";

    var timer = new Stopwatch();
    timer.Start();
    string a = BlankDataInColumn(value, ColName);
    timer.Stop();
    TimeSpan timeTaken = timer.Elapsed;
    string foo = "Time taken: " + timeTaken.ToString(@"m\:ss\.fff");
    Console.WriteLine(foo);

    var timer1 = new Stopwatch();
    timer1.Start();
    string b = BlankDataInColumnforeach(value, ColName);
    timer1.Stop();
    TimeSpan timeTaken1 = timer1.Elapsed;
    string foo1 = "Time taken: " + timeTaken1.ToString(@"m\:ss\.fff");
    Console.WriteLine(foo1);

    var timer12 = new Stopwatch();
    timer12.Start();
    string c = BlankDataInColumnforeachParallel(value, ColName);
    timer12.Stop();
    TimeSpan timeTaken12 = timer12.Elapsed;
    string foo12 = "Time taken: " + timeTaken12.ToString(@"m\:ss\.fff");
    Console.WriteLine(foo12);

    var timer123 = new Stopwatch();
    timer123.Start();
    string d = BlankDataInColumnforParallel(value, ColName);
    timer123.Stop();
    TimeSpan timeTaken123 = timer123.Elapsed;
    string foo123 = "Time taken: " + timeTaken123.ToString(@"m\:ss\.fff");
    Console.WriteLine(foo123);
    Console.ReadLine();
}

public static string BlankDataInColumn(List<string> Column, string ColumnName)
    {

        bool isBlank = false;
        StringBuilder rowNumber = new StringBuilder();
        for (int i = 0; i < Column.Count(); i++)
        {
            if (Column[i].HasNothing()) { rowNumber.Append($"{i + 1},"); isBlank = true; }
        }
        string BlankDataExist = isBlank ? $"The {ColumnName} have Blank Values in the following row number {rowNumber}" : null;
        return BlankDataExist;
    }

public static string BlankDataInColumnforeach(List<string> Column,
    string ColumnName)
{
    bool isBlank = false;
    StringBuilder rowNumber = new StringBuilder();
    int i = 0;
    foreach (string col in Column)
    {
        i++;
        if (col.HasNothing()) { rowNumber.Append($"{i},"); isBlank = true; }
    }
    string BlankDataExist = isBlank ?
        $"The {ColumnName} have Blank Values in the following row number {rowNumber}"
        : null;
    return BlankDataExist;
}

public static string BlankDataInColumnforeachParallel(List<string> Column,
    string ColumnName)
{
    bool isBlank = false;
    StringBuilder rowNumber = new StringBuilder();
    int i = 0;
    Parallel.ForEach(Column, col =>
    {
        i++;
        if (col.HasNothing()) { rowNumber.Append($"{i},"); isBlank = true; }
    });
    string BlankDataExist = isBlank ?
        $"The {ColumnName} have Blank Values in the following row number {rowNumber}"
        : null;
    return BlankDataExist;
}

public static string BlankDataInColumnforParallel(List<string> Column,
    string ColumnName)
{
    bool isBlank = false;
    StringBuilder rowNumber = new StringBuilder();
    Parallel.For(0, Column.Count(), i =>
    {
        if (Column[i].HasNothing()) { rowNumber.Append($"{i + 1},"); isBlank = true; }
    });
    string BlankDataExist = isBlank ?
        $"The {ColumnName} have Blank Values in the following row number {rowNumber}"
        : null;
    return BlankDataExist;
}

Answer 1

You likely have far to few items for any parallel loop to make any sense at all.

Running anything in parallel will have some overhead, this overhead will likely completely dominate in this case. You want to ensure that each iteration in a parallel loop is sufficiently heavy that the advantages outweigh this overhead.

You also need to ensure that the code is thread safe, because optimizations are irrelevant if the code does not actually work. Using stringBuilder in that way is not safe. I would recommend staying away from any kind of parallel or concurrent programming until you have spent quite a bit of time reading up on how to write thread safe code.

You also need to be careful when writing benchmarks. The gold standard for this is Benchmark .net. This should take care of most problems. If you want to measure performance yourself you should at the very least ensure the following:

• Use Stopwatch and not DateTime.Now. (not that you do, just for completeness sake)
• Ensure the runtime is at least in the tens of milliseconds.
• Do a warm-up pass before measuring, to ensure all code is compiled.
• Run the code in release, without the debugger attached.

As a final note, use profiling tools to find the actual bottlenecks in your application and only optimize the parts that are actually problematic. And try to prefer high level optimizations (i.e. things like algorithmic improvements or data structures), over micro optimizations. Premature optimizations are the root of all evil:

There is no doubt that the grail of efficiency leads to abuse. Programmers waste enormous amounts of time thinking about, or worrying about, the speed of noncritical parts of their programs, and these attempts at efficiency actually have a strong negative impact when debugging and maintenance are considered. We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil.

Yet we should not pass up our opportunities in that critical 3%. A good programmer will not be lulled into complacency by such reasoning, he will be wise to look carefully at the critical code; but only after that code has been identified. It is often a mistake to make a priori judgements about what parts of a program are really critical, since the universal experience of programmers who have been using measurement tools has been that their intuitive guesses fail. After working with such tools for seven years, I've become convinced that all compilers written from now on should be designed to provide all programmers with feedback indicating what parts of their programs are costing the most; indeed, this feedback should be supplied automatically unless it has been specifically turned off.