创建NumberSequence数组的最快方法

Question

I would like to create an array with of length X, and i would like the following 'inteligence'

if , for exemple, X = 6, myArray[x] = [0,1,2,3,4,5]

For the moment, i do

int[] availableIndex = new int[DestructiblesCubes.Count];
for (var i = 0; i < availableIndex.Length; i++)
{
    availableIndex[i] = i;
}

But, i'm curious, is there a better (the faster way to execute it) and/or the faster(the shortest char length) way?

Thanks :)

Answer 1

This is short way to implement this. Not the performance best solution.

Enumerable.Range(0, 10).ToArray()

MSDN description for Enumerable.Range

Answer 2

I think the fastest method uses the unsafe context together with a proper fixed pointer to the array, as demonstrated below:

/*const*/ int availableIndex_Length = 6;
int[] availableIndex = new int[availableIndex_Length];
unsafe {
    fixed(int* p = &availableIndex[0]) {
        for(int i = 0; i < availableIndex_Length; ++i) {
            *(p+i) = i;
        }
    } 
}

This can be refactored to a method, optionally inline d:

[MethodImpl(MethodImplOptions.AggressiveInlining)]
static unsafe void FillRange(ref int[] array) {
      int length = array.Length;
      fixed(int* p = &array[0]) {
          for(int i = 0; i < length; ++i) {
              *(p + i) = i;
          }
      }
}

static void Main(string[] args) {
    // Example usage:
    int[] availableIndices = new int[6];
    FillRange(ref availableIndices);

    // Test if it worked:
    foreach(var availableIndex in availableIndices) {
        Console.WriteLine(availableIndex);
    }
    Console.ReadKey(true);
}

Answer 3

The only optimisation I can see to apply to your code as it stands is to count down to zero, but any increase in performance will be tiny

int[] availableIndex = new int[DestructiblesCubes.Count];
for (var i = availableIndex.Length-1; i >= 0; i--)
{
    availableIndex[i] = i;
}

Otherwise, especially if you're talking large arrays, one thing to try would be to create an array greater than your max envisioned value of DestructiblesCubes.Count and Intialize that array as above, then use Array.Copy when you want the smaller array.
I would be confident that no code we hand roll will be faster than a single call to Array.Copy .

int[] availableIndex = new int[DestructiblesCubes.Count];
Array.Copy(LargeArray, availableIndex, availableIndex.Length);

Otherwise I can't think of anything that might be faster than the code you have.

Answer 4

You could try this:

unsafe
{
    int[] availableIndex = new int[DestructiblesCubes.Count];
    int length = availableIndex.Length;
    int n = 0;
    fixed(int *p = availableIndex) {
        while(n < length) *p++ = n++;
    }
}

may be faster, depending on the optimization stage of your compiler.