Быстрейший способ отделить число от букв

if (RegexPattern.IsFiltered(message))
{
    const string numbers = "0123456789.";
    var numberBuilder = new StringBuilder();
    var unitBuilder = new StringBuilder();
 
    foreach (char c in message)
    {
        if (numbers.IndexOf(c) > -1)
            numberBuilder.Append(c);
        else
            unitBuilder.Append(c);
    }
 
    double.TryParse(numberBuilder.ToString(), out double value);
    rawVoltage = value;
    Mv = unitBuilder.ToString() == "mV";
}

if (IsVoltage(s))
{
    Console.Write($"Voltage: {RegexVoltageValue().Match(s).Value}\t");
    Console.Write($"Unit: {RegexUnitValue().Match(s).Value}");
    Console.WriteLine();
}

[GeneratedRegex(@"\d+\.\d+")]
private static partial Regex RegexVoltageValue();
 
[GeneratedRegex(@"(m?V)$")]
private static partial Regex RegexUnitValue();

    [Benchmark]
    public (double, string) Parse() => January29_Method(source);
 
    static (double, string) January29_Method(string str)
    {
        var value = string.Concat(str.Where(char.IsLetter));
        string unit = str[..str.IndexOf(value)].TrimEnd();
        return (double.Parse(value), unit);
    }

    [Params("1.5224V", "1.5225mV", "1.526 mV", "1.527 V")]
    public string source { get; set; }

string[] msg =
{
  "1,5224V", "1,5225mV", "1,526 mV", "1,527 V"
};
 
 
foreach (var m in msg)
{
    var c1 = Parse(m);
    Console.WriteLine("bl = {0}\t{1}", c1.Item1, c1.Item2);
 
    var c2 = January29_Method(m);
    Console.WriteLine("jn = {0}\t{1}", c2.Item1, c2.Item2);
 
}
 
static (double, string) January29_Method(string str)
{
    var value = string.Concat(str.Where(char.IsLetter));
    string unit = str[..str.IndexOf(value)].TrimEnd();
    return (double.Parse(value), unit);
}

    static (double, string) January29_Method(string str)
    {
        string? unit = string.Concat(str.Where(char.IsLetter));
        string value = str.Substring(0, str.IndexOf(unit)).TrimEnd();
        return (double.Parse(value), unit);
    }

    [Benchmark]
    public (double, string) ParseNew() => ParceNewMathod(source);
 
    static (double, string) ParceNewMathod(ReadOnlySpan<char> s)
    {
        int selected_unit = 0;
        if ((int)s[^2] == 109) selected_unit++;
        int overdotdigit_pos = s.Length - selected_unit - 2;
        while ((int)s[overdotdigit_pos] == 32) overdotdigit_pos--;
        return (double.Parse(s.Slice(0, overdotdigit_pos + 1)), selected_unit == 0 ? "V" : "mV");
    }

    [Benchmark]
    public (double, string) ParseNew2() => ParceNewMathod2(source);
 
    static (double, string) ParceNewMathod2(ReadOnlySpan<char> s)
    {
        int selected_unit = 0;
        if ((int)s[^2] == 109) selected_unit++;
        return (double.Parse(s.Slice(0, s.Length - selected_unit - 1)), selected_unit == 0 ? "V" : "mV");
    }

public class FastParser
{
    static FastParser()
    {
        _isNumberOrDotArray = new bool[char.MaxValue + 1];
        for (char c = '0'; c <= '9'; c++)
            _isNumberOrDotArray[c] = true;
        _isNumberOrDotArray['.'] = true;
    }
    static readonly bool[] _isNumberOrDotArray;
 
    public (double v, string unitName)[] Parse(string[] strings)
    {
        var result = new (double v, string unitName)[strings.Length];
 
        unsafe
        {
            fixed (bool* isNumOrDot = _isNumberOrDotArray)
            {
                for (int i = 0; i < strings.Length; i++)
                {
                    string? s = strings[i];
                    var l = s.Length;
                    fixed (char* sBegin = s)
                    {
                        char* sEnd = sBegin + l;
                        char* sPtr = sEnd - 1;
                        while (sPtr >= sBegin)
                        {
                            char symbol = *sPtr;
 
                            if (isNumOrDot[symbol])
                            {
                                var numberPartOfText = new ReadOnlySpan<char>(sBegin, (int)(sPtr - sBegin + 1));
                                var number = double.Parse(numberPartOfText, CultureInfo.InvariantCulture);
                                if (symbol == ' ')
                                    sPtr++;
                                var unit = new string(sPtr + 1, 0, (int)(sEnd - sPtr - 1));
                                result[i] = (number, unit);
                                break;
                            }
                            sPtr--;
                        }
                    }
                }
            }
        }
 
        return result;
    }
}

public class FastParser2
{
    static FastParser2()
    {
        _isNumberOrDotArray = new bool[char.MaxValue + 1];
        for (char c = '0'; c <= '9'; c++)
            _isNumberOrDotArray[c] = true;
        _isNumberOrDotArray['.'] = true;
 
        //Каждому символу (не цифре, а именно символу) от '0' до '9' включительно сопоставляется некоторое число - эта цифра умножить на 1 со сколькими-то нулями
        _i4 = new int[char.MaxValue + 1];
        _i3 = new int[char.MaxValue + 1];
        _i2 = new int[char.MaxValue + 1];
        _i1 = new int[char.MaxValue + 1];
        _ones = new int[char.MaxValue + 1];
 
        //Заполняем
        for (int i = 0; i <= 9; i++)
        {
            _i1[i.ToString()[0]] = 1000 * i;
            _i2[i.ToString()[0]] = 100 * i;
            _i3[i.ToString()[0]] = 10 * i;
            _i4[i.ToString()[0]] = i;
            _ones[i.ToString()[0]] = 10 * 1000 * i;
        }
        //Всё остальное - нули
 
        //А это табличка, на вход жрёт int, на выходе даёт этот int * 0.0001. Чтобы не трогать вычисления с плавающей точкой
        _doubles_array = new double[100 * 1000 + 1];
        for (int i = 0; i < _doubles_array.Length; i++)
            _doubles_array[i] = i * 0.0001;
    }
    static readonly bool[] _isNumberOrDotArray;
 
    static readonly int[] _i4, _i3, _i2, _i1, _ones;
    static readonly double[] _doubles_array;
    
 
    public (double v, string unitName)[] Parse(string[] strings)
    {
        var result = new (double v, string unitName)[strings.Length];
 
        unsafe
        {
            //Прибиваем гвоздями наши заготовленные таблички и избегаем проверки выхода за пределы границ массива
            fixed (int* i1 = _i1)
            fixed (int* i2 = _i2)
            fixed (int* i3 = _i3)
            fixed (int* i4 = _i4)
            fixed (int* ones = _ones)
            fixed (double* doubles = _doubles_array)
            fixed (bool* isNumOrDot = _isNumberOrDotArray)
            {
                for (int i = 0; i < strings.Length; i++)
                {
                    string? s = strings[i];
                    //Берём строку
                    var l = s.Length;
                    fixed (char* sBegin = s)
                    {
                        char* sEnd = sBegin + l;
                        char* sPtr = sEnd - 1;
 
                        //Проходим от последнего до первого символа
                        while (sPtr >= sBegin)
                        {
                            if (isNumOrDot[*sPtr]) //Если символ - число или точка, значит мы прошли единицы измерения и добрались до числа
                            {
                                int number_mul_10_000 = 0;
                                string unit;
                                if (sPtr[1] == ' ') //Если символ, идущий ПОСЛЕ данного - пробел, значит имеем дело с тремя знаками после запятой
                                {
                                    unit = new string(sPtr + 2, 0, (int)(sEnd - sPtr - 2));
 
                                    //Набиваем целое число, дёргая коэффициенты из таблички, которые соответствуют нашим символам
                                    number_mul_10_000 += i3[*sPtr--]; //0.001
                                    number_mul_10_000 += i2[*sPtr--]; //0.01
                                    number_mul_10_000 += i1[*sPtr--]; //0.1
                                    sPtr--; //точка
                                    number_mul_10_000 += ones[*sPtr];
                                }
                                else  //Если символ, идущий ПОСЛЕ данного, не пробел, значит имеем дело с четырьмя знаками после запятой
                                {
                                    unit = new string(sPtr + 1, 0, (int)(sEnd - sPtr - 1));
 
                                    //Набиваем целое число, дёргая коэффициенты из таблички, которые соответствуют нашим символам
                                    number_mul_10_000 += i4[*sPtr--]; //0.0001
                                    number_mul_10_000 += i3[*sPtr--]; //0.001
                                    number_mul_10_000 += i2[*sPtr--]; //0.01
                                    number_mul_10_000 += i1[*sPtr--]; //0.1
                                    sPtr--; //точка
                                    number_mul_10_000 += ones[*sPtr];
                                }
 
                                var number = doubles[number_mul_10_000];  //Делим полученное число на 10_000 с помощью выборки готового значения
                                result[i] = (number, unit);
                                break;
                            }
                            sPtr--;
                        }
                    }
                }
            }
        }
 
        return result;
    }
}

public enum Units : int
{
    mV,
    V
}
public class FastParser3
{
    static FastParser3()
    {
        _isNumberOrDotArray = new bool[char.MaxValue + 1];
        for (char c = '0'; c <= '9'; c++)
            _isNumberOrDotArray[c] = true;
        _isNumberOrDotArray['.'] = true;
 
        //Каждому символу (не цифре, а именно символу) от '0' до '9' включительно сопоставляется некоторое число - эта цифра умножить на 1 со сколькими-то нулями
        _i4 = new int[char.MaxValue + 1];
        _i3 = new int[char.MaxValue + 1];
        _i2 = new int[char.MaxValue + 1];
        _i1 = new int[char.MaxValue + 1];
        _ones = new int[char.MaxValue + 1];
 
        //Заполняем
        for (int i = 0; i <= 9; i++)
        {
            _i1[i.ToString()[0]] = 1000 * i;
            _i2[i.ToString()[0]] = 100 * i;
            _i3[i.ToString()[0]] = 10 * i;
            _i4[i.ToString()[0]] = i;
            _ones[i.ToString()[0]] = 10 * 1000 * i;
        }
        //Всё остальное - нули
 
        //А это табличка, на вход жрёт int, на выходе даёт этот int * 0.0001. Чтобы не трогать вычисления с плавающей точкой
        _doubles_array = new double[100 * 1000 + 1];
        for (int i = 0; i < _doubles_array.Length; i++)
            _doubles_array[i] = i * 0.0001;
    }
    static readonly bool[] _isNumberOrDotArray;
 
    static readonly int[] _i4, _i3, _i2, _i1, _ones;
    static readonly double[] _doubles_array;
    
 
    public (double v, Units unitName)[] Parse(string[] strings)
    {
        var result = new (double v, Units unitName)[strings.Length];
 
        unsafe
        {
            //Прибиваем гвоздями наши заготовленные таблички и избегаем проверки выхода за пределы границ массива
            fixed (int* i1 = _i1)
            fixed (int* i2 = _i2)
            fixed (int* i3 = _i3)
            fixed (int* i4 = _i4)
            fixed (int* ones = _ones)
            fixed (double* doubles = _doubles_array)
            fixed (bool* isNumOrDot = _isNumberOrDotArray)
            {
                for (int i = 0; i < strings.Length; i++)
                {
                    string? s = strings[i];
                    //Берём строку
                    var l = s.Length;
                    fixed (char* sBegin = s)
                    {
                        char* sEnd = sBegin + l;
                        char* sPtr = sEnd - 2;
                        Units units = Units.V;
                        if (*sPtr == 'm')
                        {
                            units = Units.mV;
                            sPtr--;
                        }
                        //Проходим от последнего до первого символа
                        while (sPtr >= sBegin)
                        {
                            if (isNumOrDot[*sPtr]) //Если символ - число или точка
                            {
                                int number_mul_10_000 = 0;
                                if (sPtr[1] == ' ') //Если символ, идущий ПОСЛЕ данного - пробел, значит имеем дело с тремя знаками после запятой
                                {
                                    //Набиваем целое число, дёргая коэффициенты из таблички, которые соответствуют нашим символам
                                    number_mul_10_000 += i3[*sPtr--]; //0.001
                                    number_mul_10_000 += i2[*sPtr--]; //0.01
                                    number_mul_10_000 += i1[*sPtr--]; //0.1
                                    sPtr--; //точка
                                    number_mul_10_000 += ones[*sPtr];
                                }
                                else  //Если символ, идущий ПОСЛЕ данного, не пробел, значит имеем дело с четырьмя знаками после запятой
                                {
 
                                    //Набиваем целое число, дёргая коэффициенты из таблички, которые соответствуют нашим символам
                                    number_mul_10_000 += i4[*sPtr--]; //0.0001
                                    number_mul_10_000 += i3[*sPtr--]; //0.001
                                    number_mul_10_000 += i2[*sPtr--]; //0.01
                                    number_mul_10_000 += i1[*sPtr--]; //0.1
                                    sPtr--; //точка
                                    number_mul_10_000 += ones[*sPtr];
                                }
 
                                var number = doubles[number_mul_10_000];  //Делим полученное число на 10_000 с помощью выборки готового значения
                                result[i] = (number, units);
                                break;
                            }
                            sPtr--;
                        }
                    }
                }
            }
        }
 
        return result;
    }
}

  //Формируем миллион чисел
  string[] million_numbers;
  {
      var list = new List<string>();
      for (int i = 0; i < 250000; i++)
      {
          list.AddRange(new string[] { "1.5224V", "1.5225mV", "1.526 mV", "1.527 V" });
      }
      million_numbers = list.ToArray();
  }
 
 
  var fp = new FastParser2(); 
  var nums = fp.Parse(million_numbers); //Чтобы jit всё прогрузил нахолодную
 
  var stopw = new Stopwatch();
  stopw.Restart();
 
 
  nums = fp.Parse(million_numbers);
 
 
  decimal nanoseconds = stopw.ElapsedMilliseconds * 1m * 1000 * 1000;
  stopw.Stop();
 
  Trace.WriteLine($"Время: {stopw.ElapsedMilliseconds} мс, то есть {(double)nanoseconds / million_numbers.Length} нс на каждый парсинг");