I&#39;m interested in how efficient low-level algorithms can be in .net. I would like to enable us to choose to write more of our code in C# rather than C++ in the future, but one stumbling block is the bounds checking in .net that occurs with looping and random access to arrays.

A motivating example is a function that calculates the sum of products of corresponding elements in two arrays (this is the dot product of two vectors).

    static void SumProduct(double[] X, double[] Y)
    {
        double sum = 0;
        int length = X.Length;
        if (length != Y.Length)
            throw new ArgumentException(&quot;X and Y must be same size&quot;);
        for (int i = 0; i &lt; length; i++) // Check X.Length instead? See below
            sum += X[i] * Y[i];
    }

From what I can tell, and don&#39;t know enough IL or x86 to check, the compiler won&#39;t optimize out bounds checking of `X` _and_ `Y`. Am I wrong and/or is there a way to write my code to allow the compiler to help me out?

***Further details***

There are many efficiency-arguments for and against using particular languages, not least that it is better to concentrate on &quot;big O&quot; algorithmic cost rather than the constant of proportionality, and higher level languages help you to do this. On the subject of bounds checking in .net, the best article I found is [Array Bounds Check Elimination in the CLR][1] on MSDN (also referenced in a [stack overflow answer][2] on the importance of enabling optimization).

This dates from 2009, so I wonder whether things have changed significantly since then. Also, the article reveals some real subtleties that would have caught me out so for this reason alone I would welcome some expert advice.

For example it appears that in my code above I would have better off writing `i&lt; X.Length` rather than `i &lt; length`. Also, I had also naively assumed that for an algorithm with a single array, writing a `foreach` loop would better declare your intent to the compiler and give it the best chance of optimizing out the bounds checking.

According to the MSDN article, `SumForBAD`, below, which I thought was sure to be optimized, would not be. Whereas `SumFor` would be straightforwardly optimized, and `SumForEach` would also be optimized, but not trivially (and might not be optimized at all if the array were passed into a function as `IEnumerable&lt;int&gt;`)?

    static double SumForBAD(double[] X)
    {
        double sum = 0;
        int length = X.Length; // better to use i &lt; X.length in loop
        for (int i = 0; i &lt; length; i++)
            sum += X[i];
        return sum;
    }

    static double SumFor(double[] X)
    {
        double sum = 0;
        for (int i = 0; i &lt; X.Length; i++)
            sum += X[i];
        return sum;
    }

    static double SumForEach(double[] X)
    {
        double sum = 0;
        foreach (int element in X)
            sum += element;
        return sum;
    }

---

I did some investigation based on doug65536&#39;s answer. In C++, I compared the times of a SumProduct that does one bounds-check

    for(int i=0; i&lt;n; ++i) sum += v1[i]*v2[i];

against another version that does two bounds-checks

    for(int i=0; i&lt;n1 &amp;&amp; i &lt;n2; ++i) sum += v1[i]*v2[i];

I found that the second version was slower, but only by about 3.5% (Visual Studio 2010, optimized build, default options). However it occurred to me that in C#, there might be three bounds checks. One explicit (`i &lt; length` in the function `static void SumProduct(double[] X, double[] Y)` at the start of this question), and two implicit (`X[i]` and `Y[i]`). So I tested a third C++ function, with three bounds checks

    for(int i=0; i&lt;n1 &amp;&amp; i &lt;n2 &amp;&amp; i &lt;n3; ++i) sum += v1[i]*v2[i];

This came in 35% slower than the first, which is worth caring about. I did some more investigation in this question, https://stackoverflow.com/questions/17070607/why-does-adding-extra-check-in-loop-make-big-difference-on-some-machines-and-sm. Interestingly, it seems as though the cost of bounds checking varies significantly on different machines.

  [1]: http://blogs.msdn.com/b/clrcodegeneration/archive/2009/08/13/array-bounds-check-elimination-in-the-clr.aspx
  [2]: https://stackoverflow.com/questions/9304726/array-bounds-check-elimination-in-the-clr

All Bounds Check-Elimination Solutions on Gang of Coders

Total of 1 Bounds Check-Elimination Solutions

Array bounds check efficiency in .net 4 and above