How to fill byte array with junk?

Question

I am using this:

byte[] buffer = new byte[10240];

As I understand this initialize the buffer array of 10kb filled with 0s.

Whats the fastest way to fill this array (or initialize it) with junk data every time?

I need to use that array like >5000 times and fill it every time with different junk data, that's why I am looking for a fast method to do it. The array size will also have to change every time.

Answer 1

Look at the System.Random.NextBytes() method

Answer 2

Answering 'the fastest way' is impossible without describing what the properties of your junk data have to be. Why isn't all zeroes valid junk data?

That said, this is a fast way to fill your array with meaningless numbers.

Random r = new Random();
r.NextBytes(buffer);

You might also look at implementing your own Linear congruential generator if Random isn't fast enough for you. They're simple to implement and fast, but won't give high quality random numbers. (It's unclear to me if you need those or not.)

Answer 3

How junky should be the data? Do you mean random? If that is the case just use the Random class.

Answer 4

As another option to consider, Marshall.AllocHGlobal will allocate unmanaged memory. It doesn't zero out the memory, you get what happened to be there so it's very fast. Of course you now have to work with this memory using unsafe code, and if you need to pull it into the managed space you are better off with Random.NextBytes.

Answer 5

If you are happy with the data being random, but being created form a random seed buffer, then you could do the following:

public class RandomBufferGenerator
{
    private readonly Random _random = new Random();
    private readonly byte[] _seedBuffer;

    public RandomBufferGenerator(int maxBufferSize)
    {
        _seedBuffer = new byte[maxBufferSize];

        _random.NextBytes(_seedBuffer);
    }

    public byte[] GenerateBufferFromSeed(int size)
    {
        int randomWindow = _random.Next(0, size);

        byte[] buffer = new byte[size];

        Buffer.BlockCopy(_seedBuffer, randomWindow, buffer, 0, size - randomWindow);
        Buffer.BlockCopy(_seedBuffer, 0, buffer, size - randomWindow, randomWindow);

        return buffer;
    }
}

I found it to be approx 60-70 times faster then generating a random buffer from scratch each time.

              START: From seed buffer.
00:00:00.009  END  : From seed buffer. (Items = 5,000; Per Second = 500,776.20)
              START: From scratch.
00:00:00.604  END  : From scratch. (Items = 5,000; Per Second = 8,276.95) 

Update

The general idea is to create a RandomBufferGenerator once, and then use this instance to generate random buffers, e.g.:

RandomBufferGenerator generator = new RandomBufferGenerator(MaxBufferSize);

byte[] randomBuffer1 = generator.GenerateBufferFromSeed(10 * 1024);
byte[] randomBuffer2 = generator.GenerateBufferFromSeed(5 * 1024);
...