Finden, Ersten Bestimmten Byte in ein Byte[] Array in c#

public static int GetFirstOccurance(byte byteToFind, byte[] byteArray)
{
   return Array.IndexOf(byteArray,byteToFind);
}

Es wird -1 zurück wenn nicht gefunden

Oder als Sam wies darauf hin, eine Erweiterung-Methode:

public static int GetFirstOccurance(this byte[] byteArray, byte byteToFind)
{
   return Array.IndexOf(byteArray,byteToFind);
}

- Oder um es generic:

public static int GetFirstOccurance<T>(this T[] array, T element)
{
   return Array.IndexOf(array,element);
}

Dann kann man nur sagen:

int firstIndex = byteArray.GetFirstOccurance(byteValue);

InformationsquelleAutor Philippe Leybaert

Da Sie erwähnt Effizienz, hier ist einige stark optimierten C# - code ich geschrieben habe, das verwendet native Adressierung und maximale qword ausgerichtet Lesen, um die Zahl der Speicherzugriffe durch einen Faktor von 8. Ich wäre überrascht, wenn es einen schnelleren Weg, um scan für ein byte im Speicher in .NET.

Dieser gibt die index des ersten Auftretens von byte 'v' innerhalb der Speicherbereich, beginnend bei offset i (relativ zur Adresse src), aus-und Weiterbildung für die Länge c. Gibt -1 wenn byte v nicht gefunden.

//fast IndexOf byte in memory. (To use this with managed byte[] array, see below)
public unsafe static int IndexOfByte(byte* src, byte v, int i, int c)
{
    ulong t;
    byte* p, pEnd;

    for (p = src + i; ((long)p & 7) != 0; c--, p++)
        if (c == 0)
            return -1;
        else if (*p == v)
            return (int)(p - src);

    ulong r = v; r |= r << 8; r |= r << 16; r |= r << 32;

    for (pEnd = p + (c & ~7); p < pEnd; p += 8)
    {
        t = *(ulong*)p ^ r;
        t = (t - 0x0101010101010101) & ~t & 0x8080808080808080;
        if (t != 0)
        {
            t &= (ulong)-(long)t;
            return (int)(p - src) + dbj8[t * 0x07EDD5E59A4E28C2 >> 58];
        }
    }

    for (pEnd += c & 7; p < pEnd; p++)
        if (*p == v)
            return (int)(p - src);

    return -1;
}

Nicht alarmiert werden, durch die eine Vermehrung, die Sie sehen; es wird nur ausgeführt, maximal einmal pro Aufruf der Funktion, um zu tun, eine endgültige deBruijn-lookup. Der nur-lese-lookup-Tabelle verwendet, die eine einfache gemeinsame Liste von 64-byte-Werte, das erfordert nur einmalig Initialisierung:

//elsewhere in the static class...

readonly static sbyte[] dbj8 =
{
     7, -1, -1, -1, -1,  5, -1, -1, -1,  4, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1,  6, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    -1, -1, -1,  3, -1, -1, -1, -1, -1, -1,  1, -1,  2,  0, -1, -1,
};

Den -1 Werte sind nie zugegriffen, und können Sie auf null, falls gewünscht, anstatt, wie in der folgenden alternative zu der vorstehenden Tabelle Initialisierungs-code, wenn Sie es vorziehen:

static MyStaticClass()
{
    dbj8 = new sbyte[64];  //initialize the lookup table (alternative to the above)
    dbj8[0x00] = 7;
    dbj8[0x18] = 6;
    dbj8[0x05] = 5;
    dbj8[0x09] = 4;
    dbj8[0x33] = 3;
    dbj8[0x3C] = 2;
    dbj8[0x3A] = 1;
 /* dbj8[0x3D] = 0; */
}

readonly static sbyte[] dbj8, dbj16;

Vollständigkeit halber, hier ist, wie man die Funktion mit dem Prototyp-Methode zur Verfügung gestellt, die durch die OP in der ursprünglichen Frage.

///Finds the first occurrence of a specific byte in a byte array.
///If not found, returns -1.
public static unsafe int GetFirstOccurance(byte byteToFind, byte[] byteArray)
{
    fixed (byte* p = byteArray)
        return IndexOfByte(p, byteToFind, 0, byteArray.Length);
}

Diskussion

Mein code ist ein wenig kompliziert, so dass eine detaillierte Untersuchung ist Links als übung für den interessierten Leser. Sie können studieren ein anderes nehmen auf den Allgemeinen Ansatz des Bande-wise memory-Suche im .NET interne Methode Puffer.IndexOfByte, aber code hat signifikante Nachteile im Vergleich zu mir:

• Die meisten deutlich, die .NET nur code-scans 4 bytes an der Zeit, statt 8 wie bei mir.
• Es ist ein nicht-öffentliches Verfahren, so müssten Sie mithilfe von reflektion zu nennen.
• .NET-code hat ein "performance-Leck", wo die t1 != 0 check gibt eine false positive, und die vier Prüfungen, die Folgen verschwendet. Beachten Sie Ihren "fall-through" - Fall: aufgrund dieser falsch-positiven, die Sie benötigen, vier abschließenden Prüfungen--wodurch fallen-durch-zu pflegen, Korrektheit, statt nur drei.
• .NET-code ist falsch-positiven wird verursacht durch ein von Natur aus unterlegen bitweise Berechnung basiert auf überlauf der carry-bit von einem byte zum nächsten. Dies führt zu Zweierkomplement Asymmetrien (belegt durch Ihre Verwendung von Konstanten 0x7efefeff oder 0x81010100) und den gelegentlichen "Links-weisen Ausstieg" (d.h., Verlust von Informationen in Bezug auf das most significant byte, das ist das wirkliche problem hier. Im Gegensatz dazu benutze ich ein Unterlauf Berechnung, die dafür sorgt, jedem byte die Berechnung unabhängig von seinen Nachbarn. Meine Methode gibt ein schlüssiges Ergebnis ist in allen Fällen mit keine falsch-positiven oder "fall-through" - Verarbeitung.
• Mein code verwendet eine astfreie Technik für die endgültige Suche. Eine Handvoll von nicht-Verzweigung logische Operationen (plus eine Multiplikation in diesem Fall) wird allgemein geglaubt, dass zu Gunsten der performance über längere if-else Strukturen, da letztere stören können CPU predictive caching. Dieses Problem ist wichtiger für meine 8-byte-scanner, da ohne mithilfe von lookup-ich hätte doppelt so viele if-else Bedingungen in der Endkontrolle, als im Vergleich zu einem 4-byte-gang-klug-scanner.

Natürlich, wenn Sie nicht damit beschäftigt, alle diese Kleinigkeiten, Sie können einfach kopieren und den code; ich habe Gerät getestet, es ganz ausführlich und verifiziert das richtige Verhalten für alle gut gebildet Eingänge. So, während die Kern-Funktionalität ist bereit zu verwenden, werden Sie wahrscheinlich wollen, fügen Sie eine überprüfung der Argumente.

[edit:]

String.IndexOf(String s, Char, char, int ix_start, int count) ... schnell!

Wegen der oben beschriebenen Methode gearbeitet hat, so erfolgreich in meine Projekte, die ich erweitert auf 16-bit-Suche. Hier ist der gleiche code angepasst, um die Suche nach einem 16-bit short, ushort, oder char primitive anstelle von byte. Mit dieser angepassten Methode auch unabhängig geprüft gegen Ihre jeweiligen unit-test-Methodik angepasst von oben.

static MyStaticClass()
{
    dbj16 = new sbyte[64];
 /* dbj16[0x3A] = 0; */
    dbj16[0x33] = 1;
    dbj16[0x05] = 2;
    dbj16[0x00] = 3;
}
readonly static sbyte[] dbj16;

public static int IndexOf(ushort* src, ushort v, int i, int c)
{
    ulong t;
    ushort* p, pEnd;

    for (p = src + i; ((long)p & 7) != 0; c--, p++)
        if (c == 0)
            return -1;
        else if (*p == v)
            return (int)(p - src);

    ulong r = ((ulong)v << 16) | v;
    r |= r << 32;

    for (pEnd = p + (c & ~7); p < pEnd; p += 4)
    {
        t = *(ulong*)p ^ r;
        t = (t - 0x0001000100010001) & ~t & 0x8000800080008000;
        if (t != 0)
        {
            i = dbj16[(t & (ulong)-(long)t) * 0x07EDD5E59A4E28C2 >> 58];
            return (int)(p - src) + i;
        }
    }

    for (pEnd += c & 7; p < pEnd; p++)
        if (*p == v)
            return (int)(p - src);

    return -1;
}

Und unten sind die verschiedenen überladungen für den Zugriff auf diese für die restlichen 16-bit-primitive, plus String (Letzte Abbildung):

public static int IndexOf(this char[] rg, char v) => IndexOf(rg, v, 0, rg.Length);
public static int IndexOf(this char[] rg, char v, int i, int c = -1)
{
    if (rg != null && (c = c < 0 ? rg.Length - i : c) > 0)
        fixed (char* p = rg)
            return IndexOf((ushort*)p, v, i, c < 0 ? rg.Length - i : c);
    return -1;
}

public static int IndexOf(this short[] rg, short v) => IndexOf(rg, v, 0, rg.Length);
public static int IndexOf(this short[] rg, short v, int i, int c = -1)
{
    if (rg != null && (c = c < 0 ? rg.Length - i : c) > 0)
        fixed (short* p = rg)
            return IndexOf((ushort*)p, (ushort)v, i, c < 0 ? rg.Length - i : c);
    return -1;
}

public static int IndexOf(this ushort[] rg, ushort v) => IndexOf(rg, v, 0, rg.Length);
public static int IndexOf(this ushort[] rg, ushort v, int i, int c = -1)
{
    if (rg != null && (c = c < 0 ? rg.Length - i : c) > 0)
        fixed (ushort* p = rg)
            return IndexOf(p, v, i, c < 0 ? rg.Length - i : c);
    return -1;
}
public static int IndexOf(String s, Char ch, int i = 0, int c = -1)
{
    if (s != null && (c = c < 0 ? s.Length - i : c) > 0)
        fixed (char* p = s)
            return IndexOf((ushort*)p, ch, i, c);
    return -1;
}

Beachten Sie, dass die String überlastung ist nicht ausdrücklich als eine Erweiterung Methode, da diese höher-performance-Ersatz-version würde die Funktion nie aufgerufen werden, die Art und Weise (built-in Methoden mit dem gleichen Namen immer Vorrang vor der Erweiterung Methoden). Verwenden Sie als Erweiterung auf String Instanzen, Sie können ändern Sie den Namen dieser Methode. Als Beispiel IndexOf__(this String s,...) würde ihn erscheinen neben den built-in method name in Intellisense Inserate, vielleicht eine hilfreiche Erinnerung zu opt-in. Ansonsten, wenn Sie nicht brauchen, Erweiterung der syntax, Sie können nur sicherstellen, dass Sie rufen Sie diese optimierte version direkt wie eine statische Methode der eigenen Klasse, wenn Sie es verwenden möchten, anstatt s.IndexOf(Char ch).

InformationsquelleAutor Glenn Slayden