Dados Binários: Endianness, BinaryReader e Arquivos Mapeados em Memória
Objective
Ler e escrever dados binários exige três decisões que o texto esconde: em quais bytes um valor se transforma (largura, ordem dos bytes, prefixo de string), como você chega aos bytes (um stream, um span, ou memória mapeada a partir do arquivo) e como você sabe que eles não foram danificados no caminho (um checksum). Este conceito mede cada uma. BinaryWriter e BinaryReader são cômodos e a saída deles é definida pelo runtime, não pela sua máquina. BinaryPrimitives e [StructLayout] com MemoryMarshal leem um cabeçalho de arquivo real em poucas instruções, se você respeitar a ordem dos bytes e o padding. MemoryMappedFile deixa o page cache do sistema operacional ser o seu buffer, o que ganha no acesso aleatório e não ganha numa leitura sequencial simples. System.IO.Hashing traz checksums CRC e xxHash que são de 4 a 70 vezes mais rápidos que SHA256 e MD5 aqui, e não são ferramentas de segurança. Tudo rodou numa máquina só, com o page cache quente.
Versões: .NET SDK 10.0.100 (runtime 10.0.0), TFM net10.0, NuGet System.IO.Hashing 10.0.15 (a 11.0.0 também resolve em net10.0), macOS 27.2 arm64, Apple M4 Max, 14 núcleos, 36 GiB de RAM, página de 16 KiB.
Use Cases
- Um formato binário de arquivo (um segmento de log, um índice) com cabeçalho validado, um protocolo big-endian, consultas aleatórias num arquivo enorme, ou detectar um bloco corrompido.
Deep Dive
O que o BinaryWriter escreve
csharpvar ms = new MemoryStream();
using (var w = new BinaryWriter(ms, Encoding.UTF8, leaveOpen: true))
{
w.Write(true); w.Write((short)-2); w.Write(0x01020304); w.Write(1234567890123L);
w.Write(1.5f); w.Write(1.5d); w.Write(12.34m); w.Write('A'); w.Write("héllo");
w.Write(new byte[] { 0xDE, 0xAD });
}text01 | FE FF | 04 03 02 01 | CB 04 FB 71 1F 01 00 00 | 00 00 C0 3F | 00 00 00 00 00 00 F8 3F | D2 04 00 00 00 00 00 00 00 00 00 00 00 00 02 00 | 41 | 06 68 C3 A9 6C 6C 6F | DE AD (53 bytes)
(Os | foram acrescentados aqui.) bool ocupa 1 byte, short 2, int 4, long 8, float 4, double 8, decimal 16, e Write(char) codifica um char com o encoding do writer (A ocupa 1 byte). O int 0x01020304 saiu como 04 03 02 01: little-endian. Muitos tutoriais dizem "endianness do host". O código-fonte do runtime diz outra coisa: BinaryWriter.Write(int) chama BinaryPrimitives.WriteInt32LittleEndian e BinaryReader.ReadInt32 usa o leitor little-endian, então o formato é little-endian em qualquer host (fonte e docs, medido só numa máquina little-endian). Isso é o que torna o arquivo portável, e significa que o BinaryWriter não escreve um protocolo big-endian.
Strings levam um prefixo de tamanho codificado em 7 bits, contado em bytes codificados, não em chars:
textstring of 5 chars: prefix 1 byte [05], total 6 string of 127 chars: prefix 1 byte [7F], total 128 string of 128 chars: prefix 2 bytes [80 01], total 130 string of 300 chars: prefix 2 bytes [AC 02], total 302 string of 20000 chars: prefix 3 bytes [A0 9C 01], total 20003 "ééé" (UTF-8): 06 C3 A9 C3 A9 C3 A9 "ab" with Encoding.Unicode (UTF-16): 04 61 00 62 00
São sete bits de dado por byte, e o bit alto diz "vem mais". Write7BitEncodedInt e Write7BitEncodedInt64 são públicos: 300 vira AC 02 e -1L ocupa 10 bytes (FF nove vezes e depois 01). O encoding faz parte do formato: bytes UTF-8 lidos de volta com Encoding.Latin1 viraram héllo, então o leitor precisa do encoding do escritor. Write('\uD83D') (metade de um par substituto) lançou ArgumentException: escreva uma string.
Posse, flush e falha
textdefault dispose closes the stream: CanWrite=False over FileStream, before Flush: length on disk 0 (fs.Length 4); after bw.Flush(): 4 ReadInt32 on 3 bytes: EndOfStreamException ReadString, 6 bytes of FF: FormatException
leaveOpen: true mantém o stream aberto, como em Stream Class Hierarchy and Decorators. O BinaryWriter não tem buffer próprio, então Flush só pede ao stream que faça flush: sobre um FileStream, os 4 bytes ainda estavam no buffer do stream. Uma entrada truncada é uma EndOfStreamException, não um valor curto, e um prefixo de string corrompido é EndOfStreamException ou FormatException: valide tamanhos lidos de entrada não confiável antes de usá-los. O custo é uma chamada ao stream por campo. Lendo 16.777.216 ints (64 MiB), mediana de 7:
textBinaryReader.ReadInt32 over MemoryStream: 43.2 ms BinaryReader.ReadInt32 over FileStream (4 KiB): 108.6 ms BinaryReader.ReadInt32 over FileStream (1 MiB): 100.8 ms BinaryPrimitives.ReadInt32LittleEndian on span: 6.8 ms MemoryMarshal.Cast<byte,int> loop: 4.9 ms File.ReadAllBytes + Cast loop: 13.9 ms
Cerca de 6 ns por campo pelo stream, 0,4 ns por um span. Um buffer maior no FileStream não ajudou: o custo é o caminho de cada chamada, não as chamadas de sistema. Ler o arquivo de uma vez e interpretar spans é 8 vezes mais rápido que o BinaryReader sobre o arquivo, ao preço de manter os dados em memória.
Endianness e BinaryPrimitives
BitConverter.IsLittleEndian foi True (arm64 e x64 são little-endian na prática). Protocolos de rede (cabeçalhos TCP/IP) e muitos formatos são big-endian. BinaryPrimitives lê e escreve numa ordem declarada e só troca os bytes quando o host é diferente:
textBitConverter.GetBytes(0x01020304): 04 03 02 01 WriteInt32BigEndian: 01 02 03 04 ReverseEndianness(0x01020304) = 0x04030201 ReadInt32BigEndian({00 00 01 00}) = 256 ReadInt32LittleEndian(same bytes) = 65536 TryWriteUInt64LittleEndian into 6 bytes: False into 8 bytes: True 88 77 66 55 44 33 22 11 ReadInt32BigEndian on 3 bytes: ArgumentOutOfRangeException TryReadInt32BigEndian: False
BitConverter.ToInt32 não tem argumento de ordem: lê na ordem do host, então um campo big-endian lido com ele deu 65536 em vez de 256. Use o par Read*/Write* para um span, as formas Try* quando entrada curta é esperada, e ReverseEndianness para um valor que já está numa variável.
Um cabeçalho real com Span<byte> e [StructLayout]
Um arquivo começa com um cabeçalho de 24 bytes: magic DAT1, versão e flags big-endian (u16), contagem de registros (u32), data de criação (i64) e CRC32 do payload (u32), little-endian. O jeito portável escreve cada campo com a ordem explícita:
csharppublic void WritePortable(Span<byte> dst)
{
"DAT1"u8.CopyTo(dst);
BinaryPrimitives.WriteUInt16BigEndian(dst[4..], Version);
BinaryPrimitives.WriteUInt16BigEndian(dst[6..], Flags);
BinaryPrimitives.WriteUInt32LittleEndian(dst[8..], RecordCount);
BinaryPrimitives.WriteInt64LittleEndian(dst[12..], CreatedUnixMs);
BinaryPrimitives.WriteUInt32LittleEndian(dst[20..], PayloadCrc);
}O jeito sem cópia mapeia os bytes numa struct com MemoryMarshal.Read<T> e Write<T> e troca os campos big-endian:
csharp[StructLayout(LayoutKind.Sequential, Pack = 1)]
struct RawHeader { public uint Magic; public ushort VersionBE, FlagsBE;
public uint RecordCountLE; public long CreatedUnixMsLE; public uint PayloadCrcLE; }
var raw = MemoryMarshal.Read<RawHeader>(src); // throws if src is shorter than 24
ushort version = BitConverter.IsLittleEndian ? BinaryPrimitives.ReverseEndianness(raw.VersionBE) : raw.VersionBE;Os dois produziram os mesmos 24 bytes e a ida e volta foi igual:
text44 41 54 31 | 00 03 | 80 01 | 03 00 00 00 | 00 64 C0 9E 9A 01 00 00 | 86 55 0F 3E magic DAT1 | v3 BE | fl BE | count 3 LE | 1763600000000 LE | crc 0x3E0F5586 LE bad magic 58585858 -> InvalidDataException (our own check) MemoryMarshal.Read<RawHeader> on 10 bytes: ArgumentOutOfRangeException
O caminho da struct exige três disciplinas. Primeiro, o tamanho: sem Pack = 1 o CLR alinha os campos, e o layout deixa de bater com o arquivo:
textNaturalPad { byte Flag; long Timestamp }: 16 bytes: 01 00 00 00 00 00 00 00 | 08 07 06 05 04 03 02 01 Packed (Pack = 1) same fields: 9 bytes: 01 | 08 07 06 05 04 03 02 01
Os 7 bytes de padding foram zero aqui, mas o conteúdo deles não é garantido, então nunca calcule hash nem compare como bytes uma struct com padding. Segundo, MemoryMarshal.Read<T> não aceita tipo com referências (Read<string> é erro de compilação, CS0453, e uma struct que contém uma lança ArgumentException: Only value types without pointers or references are supported em tempo de execução, medido) e não valida: um campo bool com o byte 2 foi lido sem exceção. Terceiro, uma struct empacotada tem campos desalinhados, o que funciona em x64 e arm64 e é o motivo de o formato do arquivo, não o layout do CLR, ser o contrato. Use a forma portável quando o formato é o contrato e a forma da struct para um cabeçalho fixo e quente. Um record Header montado a partir do bruto mantém os valores já trocados fora do resto do código.
Arquivos mapeados em memória
MemoryMappedFile pede ao SO que mapeie um arquivo no espaço de endereços do processo: leituras viram page faults atendidos pelo page cache, sem chamada read e sem cópia para um buffer seu. CreateFromFile cria um mapa persistido; CreateNew(null, capacity) cria um não persistido (memória anônima, sem arquivo). Comportamentos medidos no macOS:
textcapacity 0 on a 100 byte file: view.Capacity = 100 (whole file) capacity 4096 on a 100 byte file: file grew to 4096 bytes capacity 50 on a 100 byte file: ArgumentOutOfRangeException empty file, capacity 0: ArgumentException (a positive capacity is required) Read map with capacity > file: ArgumentException ReadWrite view on a Read map: UnauthorizedAccessException Write on a Read view: NotSupportedException CopyOnWrite: view[0]=99, file[0]=1 (the file is not changed)
Modos de acesso: Read, ReadWrite, CopyOnWrite (cópia privada, nunca gravada de volta) no mapa, e uma vista só pode ser tão permissiva quanto o mapa. Uma vista recebe um offset e um tamanho. Uma vista no offset 5000 (sem alinhamento de página) funcionou: Capacity 100, PointerOffset 5000 e o primeiro byte estava certo, porque o runtime mapeia a partir do limite de página logo abaixo (16 KiB aqui, Environment.SystemPageSize) e entrega o deslocamento dentro dela. Uma vista que passou do fim do arquivo de 20000 bytes lançou UnauthorizedAccessException, e ReadInt32 dois bytes antes do fim da vista lançou ArgumentException.
Escrever por uma vista ReadWrite não usa um buffer separado. Depois de view.Write(0, 0x01020304) e nenhum Flush, File.ReadAllBytes já devolveu 04 03 02 01, e um processo filho que mapeou o arquivo leu 12345 enquanto o pai nunca chamou Flush (uma máquina, um page cache). Flush() limpa os buffers da vista e grava no arquivo, e segundo a doc um mapa persistido é salvo quando o último processo termina de usá-lo. Então o Flush não torna o dado visível: é o passo para durabilidade e antes de ler por outro caminho que ignora o cache (não medido: queda de energia).
ViewStream embrulha uma vista como Stream com seek (Length 4, CanSeek True, ReadByte no fim devolveu -1), então código de stream lê uma região mapeada. Para o acesso mais rápido, pegue o ponteiro:
csharpusing var view = mmf.CreateViewAccessor(0, 0, MemoryMappedFileAccess.Read);
byte* p = null;
view.SafeMemoryMappedViewHandle.AcquirePointer(ref p);
try { var span = new ReadOnlySpan<byte>(p + view.PointerOffset, (int)view.Capacity); /* use span */ }
finally { view.SafeMemoryMappedViewHandle.ReleasePointer(); } // needs AllowUnsafeBlocksAcquirePointer mantém o handle da vista vivo enquanto você segura o ponteiro (docs), então você precisa chamar ReleasePointer. O tamanho de um span é um int, então uma vista acima de 2 GiB pede várias vistas ou aritmética de ponteiro. Os acessores genéricos funcionaram com uma struct: Write<Pt>/Read<Pt> de {int X; double Y} gravou 03 00 00 00 | 00 00 00 00 | 00 00 00 00 00 00 12 40 (o padding da própria struct incluído).
Memória compartilhada: CreateNew("name", ...), CreateOrOpen, OpenExisting e CreateFromFile com mapName lançaram todos PlatformNotSupportedException: Named maps are not supported no macOS. No Windows eles são o mecanismo de IPC (só docs aqui). No Unix, compartilhe um arquivo: dois processos mapeando o mesmo arquivo viram os mesmos bytes (acima). Dentro de um processo, CreateNew(null, 4096) deu duas vistas que enxergavam uma à outra (777). Truncar um arquivo enquanto ele está mapeado não lançou exceção na chamada que truncou (vista de 8192 bytes, arquivo cortado para 100). Tocar uma página além do novo fim causa falha segundo a documentação, e uma falha numa vista mapeada pode derrubar o processo em vez de lançar exceção (docs, não executado), o principal perigo de mapear um arquivo que outro processo pode alterar.
Medindo leituras: 512 MiB, cache quente
O arquivo tinha 512 MiB de bytes aleatórios gerados no diretório temporário desta sessão (escrito em 3,0 s, removido no fim). Todos os números são com page cache quente: o arquivo foi escrito instantes antes e lido uma vez para calcular a soma esperada, e os tempos ficaram estáveis de uma execução para outra (variação abaixo de 3 por cento), que é como um arquivo residente se comporta. Não foi possível rodar com cache frio: o purge exige root aqui, e esvaziar o cache não é uma chamada que o runtime ofereça. Números a frio são dominados pelo disco, não pela API, e reduziriam as diferenças abaixo. Cada método somou o arquivo como ulongs (a soma de cada execução bateu), mediana de 7 após um aquecimento:
textSequential full read median min max MiB/s FileStream, 4 KiB buffer, Read in 4 KiB 84 ms 83 85 6,129 FileStream, bufferSize 0, Read in 1 MiB 44 ms 43 44 11,574 File.ReadAllBytes (one 512 MiB array) 71 ms 71 74 7,166 RandomAccess.Read in 1 MiB chunks 44 ms 43 45 11,608 MemoryMappedFile, new map each run, pointer span 41 ms 40 41 12,573 MemoryMappedFile, ViewStream + 1 MiB reads 60 ms 60 60 8,550 MemoryMappedFile, accessor.ReadUInt64 per 8 bytes 640 ms 637 643 799 MemoryMappedFile, one map reused, pointer span 17 ms 17 17 29,421 array already in RAM (no I/O, for reference) 17 ms 17 18 29,394
Numa passada sequencial, RandomAccess em blocos de 1 MiB, um FileStream sem buffer e um mapa novo ficam a cerca de 7 por cento um do outro: todos custam uma ida ao page cache. File.ReadAllBytes paga uma alocação e uma cópia de 512 MiB (71 ms), e leituras de 4 KiB pagam uma chamada por 4 KiB. A passada mapeada reaproveitada é tão rápida quanto a memória (17 ms), e os 24 ms de diferença para o mapa novo são o custo de montar e fazer o fault do mapeamento. ReadUInt64 a cada 8 bytes é 15 vezes mais lento que o ponteiro sobre um mapa novo: cada chamada do acessor checa limites e adquire o handle. Acesso aleatório, 1.000.000 de leituras de 8 bytes em offsets alinhados aleatórios:
textFileStream Seek + Read(8 bytes), bufferSize 0 471 ms 471 ns/read RandomAccess.Read(handle, 8 bytes, offset) 492 ms 492 ns/read MemoryMappedViewAccessor.ReadUInt64(offset) 40 ms 40 ns/read pointer from AcquirePointer, unsafe read 25 ms 25 ns/read
Aqui o mapa ganha de 12 a 20 vezes, porque cada leitura por handle é uma chamada de sistema e uma leitura pelo mapa é um load de memória. A frio, uma leitura pelo mapa é um page fault que lê do disco, e o primeiro toque em cada página de 16 KiB paga por ele (não medido).
Ponte: memória virtual e page cache
Um arquivo mapeado é memória virtual usada de propósito. O SO dá a cada página um lugar no seu espaço de endereços, carrega no primeiro toque (um page fault) e pode despejá-la depois, e o read passa pelo mesmo page cache, por isso os resultados sequenciais convergem. O modelo de working set de Denning explica por que um processo cujas páginas tocadas recentemente cabem na memória roda rápido e um que não cabe sofre thrashing: um índice de acesso aleatório cabe quando as páginas quentes dele cabem. O cache_ext descreve o page cache do Linux como uma política LRU aproximada que funciona mal para certas cargas, um scan grande que expulsa páginas úteis por exemplo, e esse é o custo de deixar o kernel decidir o que fica. Uma passada sequencial de 512 MiB sobre um arquivo que você também usa para consultas é esse caso. O mapeamento não dá controle nenhum sobre o despejo.
Checksums com System.IO.Hashing
O pacote System.IO.Hashing é separado do shared framework (dotnet add package System.IO.Hashing). Ele traz Crc32 (IEEE 802.3), Crc64 (ECMA-182 Annex B), XxHash32, XxHash64, XxHash3 e XxHash128, todos derivados de NonCryptographicHashAlgorithm. Cada um tem uma forma estática de uma chamada e uma instância incremental:
csharpuint crc = Crc32.HashToUInt32(data); // data is a ReadOnlySpan<byte>
ulong h = XxHash3.HashToUInt64(data, seed: 1);
byte[] bytes = XxHash128.Hash(data); // 16 bytes; HashToUInt128 also exists
var x = new XxHash3();
foreach (var chunk in chunks) x.Append(chunk); // also Append(Stream) and AppendAsync(Stream)
byte[] digest = x.GetCurrentHash(); // GetHashAndReset() starts overVerificações que rodaram: Crc32("123456789") é 0xCBF43926 (o valor de verificação padrão), Crc64 é 0x6C40DF5F0B497347 (o valor do ECMA-182), XxHash3 é 0x72DCB18B67A17DFF (seed 0) e 0xE967C19057995816 (seed 1); um buffer de 1.000.003 bytes alimentado em blocos de 4.096 bytes deu o mesmo XxHash3 de uma chamada só, e GetCurrentHash pode ser chamado duas vezes; TryHash para 3 bytes devolveu False, e Crc32.Hash(source, destination) com 3 bytes lançou ArgumentException. Um bit invertido mudou o Crc32 de 53C537E1 para 483F4B68. A forma em bytes depende do algoritmo: Crc32.Hash devolveu 26 39 F4 CB, os bytes little-endian de 0xCBF43926, enquanto os bytes de XxHash64, XxHash3 e Crc64 saíram na ordem do inteiro (8C B8 41 DB ... para 0x8CB841DB...). Se você guarda um hash num cabeçalho, guarde o inteiro na ordem que você escolheu, como no cabeçalho acima, e não o array de bytes de um algoritmo.
Vazão, uma thread, buffer de 256 MiB em RAM, mediana de 7 (duas execuções a mais concordaram em até 3 por cento):
textCrc32 8.6 ms 29.0 GiB/s XxHash3 18.5 ms 13.5 GiB/s SHA256 88.6 ms 2.82 GiB/s Crc64 4.7 ms 53.2 GiB/s XxHash128 18.5 ms 13.5 GiB/s SHA1 88.3 ms 2.83 GiB/s XxHash32 22.6 ms 11.1 GiB/s XxHash64 11.3 ms 22.1 GiB/s SHA512 153.9 ms 1.62 GiB/s MD5 329.0 ms 0.76 GiB/s
Para entradas de 64 bytes (5.000.000 de hashes): Crc32 2,8 ns, XxHash64 6,8 ns, XxHash3 12,5 ns, SHA256 192 ns, MD5 289 ns, e string.GetHashCode numa chave de 25 chars 9,9 ns. A ordem medida difere da afirmação comum de que o XxHash3 é o mais rápido: nesta CPU arm64 o XxHash64 ganhou dele, e Crc32 e Crc64 ganharam dos dois (provavelmente instruções de CRC em hardware e multiplicação sem carry, não verificado). Isso pode ser diferente em x64 e não foi medido. O SHA256 foi 3,7 vezes mais rápido que o MD5 aqui, provavelmente por suporte a SHA em hardware (não verificado, e não medido em outras CPUs). string.GetHashCode não é uma chave estável: "abc" deu 285973014 num processo e 1718255714 no seguinte.
Eles não são criptográficos. A classe base se chama NonCryptographicHashAlgorithm, e o motivo não é a velocidade: quem conhece o algoritmo constrói outra entrada com o mesmo valor de CRC ou xxHash, e não há chave. Use onde o adversário é ruído: um checksum contra corrupção (o CRC de um segmento, um download), uma chave estável de partição ou de tabela entre processos e versões (GetHashCode não é uma), ou deduplicação de dados em que você confia. Use SHA256 (ou HMACSHA256 quando há um segredo) para uma assinatura, uma checagem de senha ou qualquer entrada que um atacante controle. O Crc32 também não diz que o dado é o que você queria, só que ele não foi danificado de um jeito que o CRC detecta.
Livro vs hoje
- Material mais antigo lê dados binários com
BinaryReaderouMarshal.PtrToStructure, troca bytes comArray.ReverseeBitConverter.IsLittleEndian, e diz que arquivos mapeados em memória são o jeito rápido de ler um arquivo. Hoje as APIs de span leem um campo em 0,4 ns contra cerca de 6 ns peloBinaryReader, oBinaryPrimitivessubstitui o código de troca de bytes, e um mapa só é claramente mais rápido no acesso aleatório (25 a 40 ns contra cerca de 480 ns por leitura de 8 bytes aqui), não numa passada sequencial (41 ms contra 44 ms). - Conselho antigo usa
MD5ouSHA1como "checksum rápido". Medido aqui, oMD5foi o hash mais lento (0,76 GiB/s), 38 vezes mais lento que oCrc32, e também não é seguro para segurança. - Código antigo conta com mapas nomeados para memória compartilhada. Funcionam no Windows e lançam
PlatformNotSupportedExceptionno macOS (medido); compartilhe um arquivo mapeado ou use um pipe.
Trade-offs
BinaryReaderé simples e lento por campo. Bom para leituras pequenas e raras, cerca de 6 ns por campo aqui. Para um arquivo grande, leia tudo e interprete um span, ou useBinaryPrimitivessobre um buffer (ReadInt32LittleEndian(buffer.AsSpan(8))).- O formato fixa a ordem dos bytes, não o host.
BinaryWriteré little-endian, um protocolo pode ser big-endian, então escreva cada campo com a chamada nomeada doBinaryPrimitives. Um cast de struct pede a guardaBitConverter.IsLittleEndianePack = 1(bytemaislongocupa 16 bytes por padrão, 9 empacotado), e continua sem validar. - Mapear compensa só em acesso aleatório ou reuso. Uma passada sequencial ficou a cerca de 7 por cento de um laço com
RandomAccess. Leituras aleatórias de 8 bytes foram de 12 a 20 vezes mais rápidas mapeadas. - Mapear muda onde os erros aparecem e aumenta o risco. Um erro de I/O ou um arquivo truncado por outro processo vira uma falha na página mapeada, não uma exceção numa chamada
Read(docs, não executado). Não mapeie arquivos que outros escritores possam encolher. Spans sobre uma vista são limitados a 2 GiB. Flushé para durabilidade. O dado ficou visível para um segundo processo sem ele. Chame antes de depender de os bytes estarem no disco, e façaDisposeda vista antes do mapa.- CRC e xxHash detectam dano, não adulteração. De 4 a 70 vezes mais rápidos que
SHA256eMD5aqui, e falsificáveis de propósito. Escolha pela ameaça: corrupção pede CRC ou xxHash, um atacante pede um hash criptográfico. - Números com cache quente são o melhor caso. Um arquivo frio é limitado pelo disco e as diferenças entre as APIs de leitura diminuem. Meça na máquina de destino, com o estado de cache de destino.
Documentation Links
- BinaryWriter class, Microsoft Learn
- BinaryReader class, Microsoft Learn
- BinaryPrimitives class, Microsoft Learn
- BitConverter.IsLittleEndian, Microsoft Learn
- MemoryMarshal.Read, Microsoft Learn
- StructLayoutAttribute.Pack, Microsoft Learn
- Memory-mapped files, Microsoft Learn
- MemoryMappedFile class, Microsoft Learn
- MemoryMappedViewAccessor.Flush, Microsoft Learn
- SafeBuffer.AcquirePointer, Microsoft Learn
- System.IO.Hashing namespace, Microsoft Learn
- NonCryptographicHashAlgorithm class, Microsoft Learn
- RandomAccess class, Microsoft Learn