Come individuare una sequenza di valori (in particolare, byte) all'interno di un insieme più grande in NET

Question

Ho bisogno di analizzare i byte da un file in modo che prendo solo i dati dopo una certa sequenza di byte è stato identificato. Ad esempio, se la sequenza è semplicemente 0xFF (un byte), quindi posso usare LINQ sulla raccolta:

byte[] allBytes = new byte[] {0x00, 0xFF, 0x01};
var importantBytes = allBytes.SkipWhile(byte b => b != 0xFF);
// importantBytes = {0xFF, 0x01}

Ma esiste un modo elegante per rilevare una sequenza multi-byte - per esempio 0xFF, 0xFF -? In particolare uno che fa marcia indietro nel caso in cui si comincia a fare una partita di falso positivo

Answer 1

Io non sono a conoscenza di alcun modo integrato; come al solito, si può sempre scrivere il proprio metodo di estensione. Ecco uno al largo della parte superiore della mia testa (ci possono essere modi più efficaci per attuare it):

public static IEnumerable<T> AfterSequence<T>(this IEnumerable<T> source,
    T[] sequence)
{
    bool sequenceFound = false;
    Queue<T> currentSequence = new Queue<T>(sequence.Length);
    foreach (T item in source)
    {
        if (sequenceFound)
        {
            yield return item;
        }
        else
        {
            currentSequence.Enqueue(item);

            if (currentSequence.Count < sequence.Length)
                continue;

            if (currentSequence.Count > sequence.Length)
                currentSequence.Dequeue();

            if (currentSequence.SequenceEqual(sequence))
                sequenceFound = true;
        }
    }
}

dovrò controllare per assicurarsi che questo è corretto, ma dovrebbe dare l'idea di base; scorrere gli elementi, monitorare l'ultima sequenza di valori recuperati, impostare un flag quando viene trovata la sequenza, e una volta che il flag è impostato, inizia ritornare ogni elemento successivo.

Modifica - ho fatto eseguire un test, e funziona in modo corretto. Ecco alcuni codice di prova:

static void Main(string[] args)
{
    byte[] data = new byte[]
    {
        0x01, 0x02, 0x03, 0x04, 0x05,
        0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA
    };
    byte[] sequence = new byte[] { 0x02, 0x03, 0x04, 0x05 };
    foreach (byte b in data.AfterSequence(sequence))
    {
        Console.WriteLine(b);
    }
    Console.ReadLine();
}

Answer 2

Se si converte i vostri byte in una stringa, è possibile usufruire della miriade di funzioni integrate in che la ricerca, anche se i byte si sta lavorando con non sono in realtà i personaggi nel senso tradizionale.

Answer 3

Proprio come un po 'di teoria; questo è un problema di lingua regolari. Si può essere in grado di utilizzare un motore di espressioni regolari per rilevarla. Il primo ha colpito google per "espressione regolare in funzione" trovati

http://codeguru.earthweb.com/columns/experts/article .php / c14689