Можно ли сделать массив двумерных байтов одним огромным массивом непрерывных байтов?

Question

У меня есть очень большой 2D ByteArray в памяти,

byte MyBA = new byte[int.MaxValue][10]; 

Есть ли способ (вероятно небезопасные), что я могу обмануть C#, думая, что это один огромный непрерывный массив байтов? Я хочу сделать это, чтобы передать его MemoryStream, а затем BinaryReader.

MyReader = new BinaryReader(MemoryStream(*MyBA)) //Syntax obviously made-up here 

Answer 1

Вы можете создать MemoryStream, а затем передать массив в одну строку с помощью метода Write

EDIT: Предел MemoryStream, конечно, объем памяти для данного приложения. Возможно, есть предел ниже, но если вам нужно больше памяти, вам следует подумать об изменении общей архитектуры. Например. вы можете обрабатывать свои данные в кусках, или вы можете сделать механизм обмена файлом.

Answer 2

Согласен. В любом случае у вас есть ограничение размера массива.

Если вам действительно нужно управлять огромными массивами в потоке, напишите свой собственный класс потока памяти.

Answer 3

Я не верю, что .NET предоставляет это, но довольно просто реализовать свою собственную реализацию System.IO.Stream, которая легко переключает вспомогательный массив. Вот (непроверенные) Основы:

public class MultiArrayMemoryStream: System.IO.Stream 
{ 
    byte[][] _arrays; 
    long _position; 
    int _arrayNumber; 
    int _posInArray; 

    public MultiArrayMemoryStream(byte[][] arrays){ 
     _arrays = arrays; 
     _position = 0; 
     _arrayNumber = 0; 
     _posInArray = 0; 
    } 

    public override int Read(byte[] buffer, int offset, int count){ 
     int read = 0; 
     while(read<count){ 
      if(_arrayNumber>=_arrays.Length){ 
       return read; 
      } 
      if(count-read <= _arrays[_arrayNumber].Length - _posInArray){ 
       Buffer.BlockCopy(_arrays[_arrayNumber], _posInArray, buffer, offset+read, count-read); 
       _posInArray+=count-read; 
          _position+=count-read; 
       read=count; 
      }else{ 
       Buffer.BlockCopy(_arrays[_arrayNumber], _posInArray, buffer, offset+read, _arrays[_arrayNumber].Length - _posInArray); 
       read+=_arrays[_arrayNumber].Length - _posInArray; 
          _position+=_arrays[_arrayNumber].Length - _posInArray; 
       _arrayNumber++; 
       _posInArray=0; 
      } 
     } 
     return count; 
    } 

    public override long Length{ 
     get { 
      long res = 0; 
      for(int i=0;i<_arrays.Length;i++){ 
       res+=_arrays[i].Length; 
      } 
      return res; 
     } 
    } 

    public override long Position{ 
     get { return _position; } 
     set { throw new NotSupportedException(); } 
    } 

    public override bool CanRead{ 
     get { return true; } 
    } 

    public override bool CanSeek{ 
     get { return false; } 
    } 

    public override bool CanWrite{ 
     get { return false; } 
    } 

    public override void Flush(){ 
    } 

    public override void Seek(long offset, SeekOrigin origin){ 
     throw new NotSupportedException(); 
    } 

    public override void SetLength(long value){ 
     throw new NotSupportedException(); 
    } 

    public override void Write(byte[] buffer, int offset, int count){ 
     throw new NotSupportedException(); 
    }  
} 

Другим способ обойти размерное ограничение 2^31 байт является UnmanagedMemoryStream который реализует System.IO.Stream поверх буфера неуправляемых памятей (который может быть столь же большим, как опоры OS). Что-то вроде этого может работать (непроверено):

var fileStream = new FileStream("data", 
    FileMode.Open, 
    FileAccess.Read, 
    FileShare.Read, 
    16 * 1024, 
    FileOptions.SequentialScan); 
long length = fileStream.Length; 
IntPtr buffer = Marshal.AllocHGlobal(new IntPtr(length)); 
var memoryStream = new UnmanagedMemoryStream((byte*) buffer.ToPointer(), length, length, FileAccess.ReadWrite); 
fileStream.CopyTo(memoryStream); 
memoryStream.Seek(0, SeekOrigin.Begin); 
// work with the UnmanagedMemoryStream 
Marshal.FreeHGlobal(buffer); 

Answer 4

Я думаю, что вы можете использовать линейную структуру вместо 2D-структуры, используя следующий подход.

Вместо того, чтобы иметь байт [int.MaxValue] [10], вы можете иметь байт [int.MaxValue * 10]. Вы должны указать элемент в [4,5] как int.MaxValue * (4-1) + (5-1). (Общая формула будет (я-1) * число столбцов + (J-1).

Конечно, вы могли бы использовать другую конвенцию.

Answer 5

Если я правильно понимаю ваш вопрос, вы получили массивный файл, который вы хотите прочитать в памяти и затем обработать.Но вы не можете этого сделать, потому что количество данных в файле превышает объем любого одномерного массива.

Вы упомянули, что скорость важна, и что у вас есть несколько потоков, работающих параллельно, чтобы обрабатывать данные как можно быстрее. Если вам придется разделить данные для каждого потока в любом случае, почему бы не основывать количество потоков на количестве буферов byte[int.MaxValue] покрыть все?

Answer 6

Если вы используете Framework 4.0, у вас есть возможность работать с MemoryMappedFile. Файлы с отображением памяти могут поддерживаться физическим файлом или файлом подкачки Windows. Файлы с отображением памяти действуют как поток в памяти, прозрачно меняя данные в/из хранилища резервных копий, если и когда это необходимо.

Если вы не используете Framework 4.0, вы все равно можете использовать эту опцию, но вам нужно либо написать свой собственный, либо найти exsiting-обертку.Я ожидаю, что на The Code Project будет много.