Differenza simmetrica di byte nei file

Ho scaricato file binari (tutti della stessa lunghezza) su determinate entità che fanno parte di una, e solo una, di due categorie. Fortunatamente so esattamente quale file appartiene a quale categoria. Voglio scrivere uno script che scopra cosa hanno in comune tutti i file della categoria 1, quindi fare lo stesso per tutti i file della categoria 2 e quindi confrontare i risultati.

In definitiva voglio avere una lista con le voci del seguente modulo: "Tutti i file nella categoria 1 hanno lo stesso byte X all'offset Y, mentre tutti i file della categoria 2 hanno un byte che non è mai X, ma sempre Z a lo stesso offset Y "

La mia funzione principale ha il seguente aspetto:

private static void FindDifferences(string folderName1, string folderName2) {
    var byteCollection1 = GetEqualBytes(Directory.GetFiles(folderName1, "*.bin"));
    var byteCollection2 = GetEqualBytes(Directory.GetFiles(folderName2, "*.bin"));
    var offsetCandidates =
        byteCollection1.Select(
            pair =>
                new KeyValuePair<long, int?>(pair.Key,
                    byteCollection2.ContainsKey(pair.Key) && byteCollection2[pair.Key] != pair.Value
                        ? pair.Value
                        : null));
    foreach (var offset in offsetCandidates) if (offset.Value != null) AddCandidate(offset.Key);
}

Il metodo GetEqualBytes funziona in questo modo:

private static Dictionary<long, int?> GetEqualBytes(IEnumerable<string> fileNames) {
    var fileQueue = new Queue<string>(fileNames);
    if (fileQueue.Count < 2) throw new Exception();

    var equalBytes = new Dictionary<long, int?>();
    var info1 = new FileInfo(fileQueue.Dequeue());
    var info2 = new FileInfo(fileQueue.Dequeue());
    using (var fs1 = info1.OpenRead())
    using (var fs2 = info2.OpenRead())
    using (var bs1 = new BufferedStream(fs1))
    using (var bs2 = new BufferedStream(fs2)) {
        for (long offset = 0; offset < info1.Length; offset++) {
            var b1 = bs1.ReadByte();
            var b2 = bs2.ReadByte();
            if (b1 == b2) equalBytes.Add(offset, b1);
        }
    }

    while (fileQueue.Count != 0) {
        var info = new FileInfo(fileQueue.Dequeue());
        using (var fs = info.OpenRead())
        using (var bs = new BufferedStream(fs)) {
            for (long offset = 0; offset < info.Length; offset++) {
                var b = bs.ReadByte();
                if (equalBytes.ContainsKey(offset) && equalBytes[offset] != b)
                    equalBytes[offset] = null;
            }
        }
    }

    return equalBytes;
}

L'idea è di trovare i byte uguali e i loro offset di due file e l'uno per l'altro della stessa categoria rimuoviamo le voci che non sono identiche alle forze prima.

Successivamente nel metodo FindDifferences stiamo intersecando le chiavi di entrambe le raccolte e aggiungendole nella speranza che questo sia un byte che in realtà distingue le due categorie.

Sfortunatamente non sono sicuro dell'approccio, poiché penso che questo non sia del tutto corretto. Mi piacerebbe sapere se vedi errori concettuali / algoritmici e se hai suggerimenti su come ottimizzare il codice.