Necesito ayuda con la lógica en un bucle extraño

Question

Estoy tratando de hacer un bucle que recurrirá a través de una variedad de bytes y compararlos con el siguiente en la matriz (presumiblemente usando un bucle for para iterar a través de cada entrada). Si los dos son los mismos, lo necesito para incrementar una variable int y luego continuar. Si los dos no son lo mismo, necesita agregar la variable int a una lista seguida de su propio valor de byte y luego necesita "adoptar" este nuevo valor como propio y comenzar todo nuevamente hasta el final de la matriz. Es algo muy extraño, pero debe hacerse de esta manera para que pueda escribir los pares de int/byte en un archivo en el orden correcto y con los valores correctos.

La preocupación aquí es obtener el número de entradas consecutivas que son las mismas, tomar nota de ella y luego pasar al siguiente valor y repetir. Si, por ejemplo, el valor 3 que encontramos es el mismo que el valor 1 que no nos preocupa. Mientras obtengamos el número de entradas consecutivas para el valor 3, hemos hecho nuestro trabajo.

Un par de otros puntos posiblemente útiles.

• Los valores de los bytes podrían en este caso abarcar el rango completo 0-255.
  
• El tamaño de la matriz puede ser de hasta 150 millones de entradas de bytes, por lo que la eficiencia es importante.
  
• El tamaño de la matriz es accesible de antemano.
  
• Por último, la matriz de bytes es una variable de byte en una estructura.
  

Espero que esto tenga sentido. Gracias por adelantado.

EDITAR: Lo siento si no estaba del todo claro antes y tal vez debería volver a tocar la pregunta.

Para aclarar, entiendo lo que necesito hacer aquí, simplemente no cómo hacerlo. Entonces, la pregunta, supongo que sería cómo hacer esta comparación y luego cambiar lo que estoy comparando cuando obtengo un retorno falso. Lo más importante es cómo hago eso cuando lo que estoy comparando podría tener 255 valores y no estoy al tanto de ellos. Realmente no puedo imaginar cómo codificar esto, así que sigo sentado allí mirando vs :)

¿Eso tiene más sentido? Si no, me disculpo :)

Editar 2: Aquí está el resultado final que se me ocurrió si a alguien le importa mirarlo. Fue inspirado en el código de Aligray a continuación.

            int count = 0;
            byte previous = tiles[0].TileTypeId;
            List<int> typeCount = new List<int>();
            List<byte> type = new List<byte>();
            for (int i = 0; i < worldSize; i++)
            {
                byte current = tiles[i].TileTypeId;
                if (previous == current)
                {
                    count++;
                }
                else
                {
                    typeCount.Add(count);
                    type.Add(previous);
                    previous = current;
                    count = 1;
                }
            } 

Answer 1

Si entendí la pregunta correctamente, espero que esto lo haga comenzar:

int count = 0;
byte previous = byteArray[0];
List<int> list = new List<int>();

for (int i = 1; i < byteArray.Length; i++)
{
    byte current = byteArray[i];
    if (previous == current)
    {
        count++;
    }
    else
    {
        list.Add(count);
        list.Add(Convert.ToInt32(current));
    }

    previous = current;
}