C # Случайное число

Ни одна из тех вещей, которые вы сказали, которые вы пробовали, должна быть "медленной". Возможно, размещение какого-то кода поможет нам найти то, что неправильно. Кроме того, каковы критерии приемлемости для медленных?

Одна вещь, которую, кажется, вы не пробовали, - это вызвать Random.Next таким образом, чтобы гарантировать, что возвращаемое число равно 8 'chars' long: Random.Next(10000000, 100000000).

Глядя на ваш исходный код:

В каждом цикле создается генератор случайных чисел. Создайте его один раз и продолжайте вызывать функцию .Next(). Это

В стороне, я только что провел тест на своей машине относительно скорости упомянутых подходов.

На моей машине это дает следующие моменты:

Testing: Guffa1
00:00:05.2472507
Testing: Guffa2
00:00:03.6620228
Testing: Simple
00:00:03.7890637
Testing: Brian
00:00:01.8473002
Testing: JohnDagg
00:00:03.8853139
Testing: chsh
00:00:05.9960557

Единственный подход, который, по-видимому, действительно помогает, - пропустить StringBuilder и работать непосредственно из буфера символов

Код следует:

using System;
using System.Text;
using System.Diagnostics;

class C
{
  const int IterationCount = 10000000;

  static void Main() {
    Test("Guffa1", Guffa1);
    Test("Guffa2", Guffa2);
    Test("Simple", Simple);
    Test("Brian", Brian);
    Test("JohnDagg", JohnDagg);
    Test("chsh", chsh);
  }

  delegate string TestDelegate(Random rg);

  private static void Test(string name, TestDelegate testMethod) {
    Console.WriteLine("Testing: " + name);
    Random rg = new Random(0);//Start each test with the same random seed

    //Call the method once outside of the test to make sure the JIT has run etc.
    for(int i=0;i<1000000;++i) {
      testMethod(rg);
    }
    Stopwatch timer = new Stopwatch();
    timer.Start();
    for(int i=0;i<IterationCount;++i) {
      testMethod(rg);
    }
    timer.Stop();
    Console.WriteLine(timer.Elapsed);
  }

  private static string Simple(Random rg) {
    return Convert.ToString(rg.Next(0, 99999999)).PadLeft(8, '0');
  }

  private static string Brian(Random rg) {
    char[] fauxbuilder = new char[8];
    int num = rg.Next(0, 100000000);
    for (int i = 0; i < 8; i++) {
      fauxbuilder[i] = (char)((num % 10) + 48);
      num /= 10;
    }
    return new string(fauxbuilder);
  }

  private static string Guffa1(Random rg) {
    StringBuilder builder = new StringBuilder(8);
    for (int i = 0; i < 8; i++) {
      builder.Append((char)rg.Next(48,58));
    }
    return builder.ToString();
  }

  private static string Guffa2(Random rg) { 
    StringBuilder builder = new StringBuilder(8);
    int num = rg.Next(0, 100000000);
    for (int i = 0; i < 8; i++) {
      builder.Append((char)((num % 10) + 48));
      num /= 10;
    }
    return builder.ToString();
  }

  private static string JohnDagg(Random rg) {
    StringBuilder builder = new StringBuilder(8);
    byte[] b = new byte[8];
    rg.NextBytes(b);
    for (int i = 0; i < 8; i++) {
      builder.Append((char)((b[i] % 10) + 48));
    }
    return builder.ToString();
  }

  private static string chsh(Random rg) {
    return (
      NextSpecial(rg, 10000000) +
      NextSpecial(rg, 1000000) +
      NextSpecial(rg, 100000) +
      NextSpecial(rg, 10000) +
      NextSpecial(rg, 1000) +
      NextSpecial(rg, 100) +
      NextSpecial(rg, 10) +
      NextSpecial(rg, 1))
      .ToString().PadLeft(8,'0');
  }

  static int NextSpecial(Random rg, int multiplier) {
    return rg.Next(0, 10) * multiplier;
  }   
}

Это должно быть достаточно эффективно. Он выделяет буфер из восьми символов и добавляет к нему символы. Нет лишнего шага превращения каждой цифры в строку и конкатенации строк, символы помещаются непосредственно в буфер. Затем буфер возвращается в виде строки, поэтому нет дополнительного шага создания строки из буфера:

StringBuilder builder = new StringBuilder(8);
for (int i = 0; i < 8; i++) {
   builder.Append((char)rnd.Next(48,58));
}
string code = builder.ToString();

Включение одного случайного числа в строку имеет то преимущество, что только один раз вызывает случайный генератор. Вы можете сделать это быстрее, выполнив преобразование в строку самостоятельно:

StringBuilder builder = new StringBuilder(8);
int num = rnd.Next(0, 100000000);
for (int i = 0; i < 8; i++) {
   builder.Append((char)((num % 10) + 48));
   num /= 10;
}
string code = builder.ToString();

(Обратите внимание, что второй параметр для метода "Следующий" не является включительным, поэтому он должен быть 100000000, а не 99999999. Это число фактически отображается назад в строку таким образом, но это не имеет значения, поскольку это случайное число. )

Вероятно, в сценарии вы описываете, что строковые операции занимают столько же или больше времени, что и вызовы Random.Next(). Я не тестировал библиотеки, но преобразование двоичного случайного числа в десятичную строку, вероятно, будет намного медленнее, чем генерация. Когда вы генерируете строку по-символу, это, скорее всего, будет иметь место.

Поэтому рассмотрим возможность сохранения числа как int, если это возможно, а затем преобразование только для целей отображения.

Ну, я решил попробовать победить Гуффа:) Я подозревал, что его версия слишком сильно коснулась. Итак, вот вариант его решения, в котором вместо символьного массива используется массив символов. Он работает примерно в 70% случаев его более быстрого решения, когда я сравнивал его с помощью Stopwatch.

char[] fauxbuilder = new char[8];
int num = rnd.Next(0, 100000000);
for (int i = 0; i < 8; i++)
{
    fauxbuilder[i] = (char)((num % 10) + 48);
    num /= 10;
}
string code = new string(fauxbuilder);

Этот код - это то, что я взломал вместе как решение и не имеет реальной оптимизации (кроме инициализации списка до известного размера). В моей системе за повторные тесты это было менее 1 секунды. У меня есть запись в конце файла для контроля качества. Кажется, что он генерирует то, что вы ищете, но не стесняйтесь указывать на любые недостатки.

    static Random rand = new Random();

    static int NextSpecial(this Random r, int multiplier)
    {
        return r.Next(0, 10) * multiplier;
    }

    static string randomString()
    {
        return (rand.NextSpecial(10000000) +
               rand.NextSpecial(1000000) +
               rand.NextSpecial(100000) +
               rand.NextSpecial(10000) +
               rand.NextSpecial(1000) +
               rand.NextSpecial(100) +
               rand.NextSpecial(10) +
               rand.NextSpecial(1))
               .ToString().PadLeft(8,'0');
    }

    static void Main()
    {
        int MAXITEMS = 1000000;
        IList<string> numbers = new List<string>(MAXITEMS);
        Stopwatch sw = new Stopwatch();
        sw.Start();
        for (int i = 0; i < MAXITEMS; i++)
        {
            numbers.Add(randomString());
        }
        sw.Stop();

        Console.WriteLine("{0} iterations took: {1}", MAXITEMS.ToString(), sw.Elapsed);

        File.WriteAllLines(@"c:\test.txt", numbers.ToArray());
        Console.ReadLine();
    }

Похож на ответ Гуффа, но, возможно, быстрее на наномасштабном уровне, так как он избегает "дорогостоящего" разделения.

        Random rnd = new Random();
        StringBuilder builder = new StringBuilder(8);
        byte[] b = new byte[8];
        rnd.NextBytes(b);
        for (int i = 0; i < 8; i++)
        {
            builder.Append((char)((b[i] % 10) + 48));
        }
        string code = builder.ToString();