3D array to 2D array - ignoring a dimension

There is a way, but I won't recomment it. This will copy using unsafe pointers. (tested)

int[,,] myArray = new int[2, 1000, 400];
int[,] myArray2 = new int[1000, 400];

var i = myArray.GetLength(1);
var j = myArray.GetLength(2);
var pageIndex = 0;

unsafe
{
    fixed (void* source = &myArray[pageIndex, 0, 0])
    fixed (void* dest = &myArray2[0, 0])
    {
        CopyMemory((IntPtr)dest, (IntPtr)source, (uint)(i*j*sizeof(int)));
    }
}


[DllImport("kernel32.dll", EntryPoint = "CopyMemory", SetLastError = false)]
public static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);

I see that you're creating a json, this method is way overkill when generating json. Don't make it too hard on yourself. Use a loop instead.

I used to create a console command for full arrays, No idea how it will turn out for jagged arrays.

You can try though.

Code snippet:

float[,] f = new float[3,3] { {1, 2, 3},
                              {4, 5, 6},
                              {7, 8, 9}  };
float[,] g = new float[3,3];

Array.Copy(f, 0, g, 0, f.Length); 


Console.WriteLine("{0} {1} {2}", f[0, 0], f[0, 1], f[0, 2]);
Console.WriteLine("{0} {1} {2}", f[1, 0], f[1, 1], f[1, 2]);
Console.WriteLine("{0} {1} {2}", f[2, 0], f[2, 1], f[2, 2]);
Console.WriteLine();
Console.WriteLine("{0} {1} {2}", g[0, 0], g[0, 1], g[0, 2]);
Console.WriteLine("{0} {1} {2}", g[1, 0], g[1, 1], g[1, 2]);
Console.WriteLine("{0} {1} {2}", g[2, 0], g[2, 1], g[2, 2]);

If your operation is read-only, you could select the dimension using a function argument. Let your array be like this:

float[,,] f = new float[2,10000,4000];

Let your operator be like this:

void myOperation(float[,,] pArray, int p1stDimensionSelector) {
  for (int i = ...; i < ...; i++) {
    for (int j = ...; j < ...; j++) {
      // do fancy stuff with pArray[p1stDimensionSelector, i, j]
    }
  }
}

If you need to write in it, you are on the right way with a copy of a part of the array. In this case there is no way out of copying with loops.

If your array has some special structure, that you can be sure of (like, half of it is zero or it resembles a symmetric matrix) you could save some iterations by seizing these properties.