Remplacer la séquence d'octets dans le fichier binaire

En supposant que vous êtes en train de remplacer un connu section du fichier.

• Ouvrir un FileStream avec accès en lecture/écriture
• Chercher au bon endroit
• Écraser les données existantes

Exemple de code à venir...

public static void ReplaceData(string filename, int position, byte[] data)
{
    using (Stream stream = File.Open(filename, FileMode.Open))
    {
        stream.Position = position;
        stream.Write(data, 0, data.Length);
    }
}

Si vous êtes effectivement essayer de faire une version binaire d'un string.Replace (par exemple, "toujours remplacer octets { 51, 20, 34} avec { 20, 35, 15 }, puis il est plutôt difficile. Une description rapide de ce que vous devriez faire:

• Allouer un tampon d'au moins la taille des données qui vous intéressent
• À plusieurs reprises de lire dans la mémoire tampon, l'analyse pour les données
• Si vous trouvez une correspondance, chercher de retour à la bonne place (par exemple, stream.Position -= buffer.Length - indexWithinBuffer; et écraser les données

Semble simple pour l'instant... mais le problème est que si les données commence près de la fin de la mémoire tampon. Vous avez besoin de se rappeler de tous potentiel matches et dans quelle mesure vous avez égalé jusqu'à présent, de sorte que si vous obtenez un match quand vous lisez les prochaine tampon de la valeur, vous pouvez le détecter.

Il y a probablement des moyens d'éviter ce trickiness, mais je ne voudrais pas essayer de venir avec eux désinvolte 🙂

EDIT: Bon, j'ai une idée qui pourrait aider...

• Garder un tampon, qui est au moins deux fois plus grand que vous avez besoin
• À plusieurs reprises:
  • Copiez le deuxième de la moitié de la mémoire tampon dans la première moitié
  • Remplir la deuxième moitié de la mémoire tampon à partir du fichier
  • De recherche tout au long de la ensemble tampon pour les données que vous êtes à la recherche pour

De cette façon à un certain point, si les données sont présentes, il sera complètement à l'intérieur de la mémoire tampon.

Vous devez être prudent sur l'endroit où le courant était dans le but de revenir à la bonne place, mais je pense que cela devrait fonctionner. Il serait plus difficile si vous essayez de trouver tous matchs, mais au moins, le premier match devrait être assez simple...

Vous pouvez utiliser mon BinaryUtility de rechercher et de remplacer un ou plusieurs octets sans charger tout le fichier en mémoire comme ceci:

var searchAndReplace = new List<Tuple<byte[], byte[]>>() 
{
Tuple.Create(
BitConverter.GetBytes((UInt32)0xDEADBEEF),
BitConverter.GetBytes((UInt32)0x01234567)),
Tuple.Create(
BitConverter.GetBytes((UInt32)0xAABBCCDD),
BitConverter.GetBytes((UInt16)0xAFFE)),
};
using(var reader =
new BinaryReader(new FileStream(@"C:\temp\data.bin", FileMode.Open)))
{
using(var writer =
new BinaryWriter(new FileStream(@"C:\temp\result.bin", FileMode.Create)))
{
BinaryUtility.Replace(reader, writer, searchAndReplace);
}
}

BinaryUtility code:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
public static class BinaryUtility
{
public static IEnumerable<byte> GetByteStream(BinaryReader reader)
{
const int bufferSize = 1024;
byte[] buffer;
do
{
buffer = reader.ReadBytes(bufferSize);
foreach (var d in buffer) { yield return d; }
} while (bufferSize == buffer.Length);
}
public static void Replace(BinaryReader reader, BinaryWriter writer, IEnumerable<Tuple<byte[], byte[]>> searchAndReplace)
{
foreach (byte d in Replace(GetByteStream(reader), searchAndReplace)) { writer.Write(d); }
}
public static IEnumerable<byte> Replace(IEnumerable<byte> source, IEnumerable<Tuple<byte[], byte[]>> searchAndReplace)
{
foreach (var s in searchAndReplace)
{
source = Replace(source, s.Item1, s.Item2);
}
return source;
}
public static IEnumerable<byte> Replace(IEnumerable<byte> input, IEnumerable<byte> from, IEnumerable<byte> to)
{
var fromEnumerator = from.GetEnumerator();
fromEnumerator.MoveNext();
int match = 0;
foreach (var data in input)
{
if (data == fromEnumerator.Current)
{
match++;
if (fromEnumerator.MoveNext()) { continue; }
foreach (byte d in to) { yield return d; }
match = 0;
fromEnumerator.Reset();
fromEnumerator.MoveNext();
continue;
}
if (0 != match)
{
foreach (byte d in from.Take(match)) { yield return d; }
match = 0;
fromEnumerator.Reset();
fromEnumerator.MoveNext();
}
yield return data;
}
if (0 != match)
{
foreach (byte d in from.Take(match)) { yield return d; }
}
}
}