Задать вопрос
@martensit

Есть ли в c# удобная функция поиска массива байтов внутри другого массива байтов?

for (int i = 0; i < fs.Length; i++)
    {
    if (fs[i] == 64)
                {
                    if (fs[i + 1] == 115)
                    {
                        if (fs[i + 2] == 46)
                        {
                            if (fs[i + 3] == 119)
                            {
                                if (fs[i + 4] == 104)
                                {
                                    if (fs[i + 5] == 97)
                                    {
                                        if (fs[i + 6] == 116)
                                        {
                                            if (fs[i + 7] == 115)
                                            {
                                                if (fs[i + 8] == 97)
                                                {
                                                    byte[] noom = { fs[i - 11], fs[i - 10], fs[i - 9], fs[i - 8], fs[i - 7], fs[i - 6], fs[i - 5], fs[i - 4], fs[i - 3], fs[i - 2], fs[i - 1] };
                                                    string str = Encoding.UTF8.GetString(noom, 0, noom.Length);
                                                    if (Convert.ToInt64(str) > 0)
                                                    {
                                                        numbers.Add(str);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }


Сейчас использую что то типо этого. Неудобно
  • Вопрос задан
  • 903 просмотра
Подписаться 1 Простой 2 комментария
Решения вопроса 2
tomnolane
@tomnolane
профессиональный разработчик
??
static int SearchBytes( byte[] haystack, byte[] needle ) {
    var len = needle.Length;
    var limit = haystack.Length - len;
    for( var i = 0;  i <= limit;  i++ ) {
        var k = 0;
        for( ;  k < len;  k++ ) {
            if( needle[k] != haystack[i+k] ) break;
        }
        if( k == len ) return i;
    }
    return -1;
}
Ответ написан
mindtester
@mindtester Куратор тега C#
http://iczin.su/hexagram_48
эт точно... что мешает завернуть искомый шаблон в массив?

ps
using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] data = new int[128];
            /// init data
            int[] marker = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };  // фикция.. но и работа бесплатная
            bool marker_present = default;
            for (var i = 0; i < data.Length - marker.Length; i++) // data.Length-marker.Length важно, иначе можете получить вылет за границы диапазона
            {
                marker_present = true;
                for (var j = 0; j < marker.Length; j++)
                    if (data[i + j] != marker[j])
                    {
                        marker_present = false;
                        break;
                    }
            }
            Console.WriteLine($"marker_present = {marker_present.ToString().ToUpper()}");
        }
    }
}
Ответ написан
Пригласить эксперта
Ответы на вопрос 1
@nicebmw9
Что было дальше ?
public bool IsContains(this byte[] arr1, byte[] arr2)
        {
            if (arr1.Intersect(arr2).Count() != 0)
                return true;
            return false;
        }

Самое элегантное решение, нет ?
Ответ написан
Ваш ответ на вопрос

Войдите, чтобы написать ответ

Похожие вопросы