How to directly access objects in array with C# (without using unsafe)?

Question

I've been doing some rummaging, trying to decide whether or not to use Java or C# for a network.

I ran across this thread from about a year ago: Java vs .NET performance

Basically what can be gathered from this is that java is running much faster because it's directly accessing the values from memory and C# is using get and set which are pointers.

That being said, can I directly access these values with C# is to gain those performance benefits without running unsafe?

Answer 1

All that the benchmark shows is that multi-dimensional arrays are slow in .NET; using jagged arrays as in the Java version (i.e. doing the same thing in C# and Java) brought the C# program to the same level of performance.

This has nothing to do with "directly accesing memory" vs "using get and set which are pointers", whatever that is supposed to mean (I honestly have no idea).

Answer 2

Using an unsafe array in C# allows you to get direct pointers to the elements (if they are of intrinsic types). This should provide a performance benefit because there are no range checks to be done of each access. I know you said no unsafe code, but if you want performance you have to consider this option.

Consider the example below:

public unsafe class PinnedArray : IDisposable
{
    byte[] values;
    byte* pointer;
    GCHandle handle;

    public PinnedArray(int size)
    {
        values=new byte[size];
        handle=GCHandle.Alloc(values, GCHandleType.Pinned);
        pointer=(byte*)handle.AddrOfPinnedObject().ToPointer();
    }
    ~PinnedArray()
    {
        Dispose();
    }

    public void Dispose()
    {
        if(values!=null)
        {
            handle.Free();
            values=null;
        }
    }
    // This is fast because it uses pointers
    public void AddFrom(PinnedArray other)
    {
        if(values.Length!=other.values.Length)
        {
            throw new ArgumentException("other");
        }
        for(int i = 0; i<values.Length; i++)
        {
            pointer[i]+=other.pointer[i];
        }
    }        

    public void FillRandom()
    {
        Random rand = new Random();
        for(int i = 0; i<values.Length; i++)
        {
            values[i]=(byte)(rand.Next()%256);
        }
    }
}
class Program
{
    static void Main(string[] args)
    {
        var A = new PinnedArray(100);
        var B = new PinnedArray(100);

        B.FillRandom();
        A.AddFrom(B);
    }
}

With my testing I see a 20% speedup in doing math using pointers (pointer[i]) as opposed to array access (value[i]).

PS. This declaration comes from Microsoft. In their parallel toolkit examples there is a project named Strassens which benchmarks matrix multiplication and uses the above scheme for quick math.

Answer 3

Please work on your language research. Currently, the C/C++ is considered the language that can produce the most efficient and fastest code, if you know how. And C/C++ is heavily dependent on pointers, that is how these languages gain most of the speed and efficiency.

Please try to understand difference between indexers in .NET/C# and pointers. Pointers in C/C++ sense is just some address in memory and data type of the pointer says how big steps it does when incremented/decremented, the size of the item in the memory. Can not be anything faster.

Indexers are much more complex beasts in C#.

Also the question you have linked made a poor attempt at measuring the real speed. It measured from the start of the program without waiting for the dust to settle after the program starts up. Well, JIT can be still active during that time, thread for the process was just barely constructed etc. It was more like measurement of the runtime environment, its ability to fire up fast some process.

in C# array can be pinned and accessed in the very fast way, not subject of the garbage collection for a moment.

Please do not try to choose a language based on such poor source of the informations. Currently, C# and Java are less or more comparable...

In a good design, you can manage to store data in one-dimensional array...