Create an array with random numbers

Question

private static byte[] GenerateData(long size)
{
    var result = new byte[size];
    new Random().NextBytes(result);

    return result;
}

Is it good, robust and efficient solution?

I use my method like this

[TestMethod]
public void WriteAndRead16MBbyZeroOffsetTest()
{
     var length = 1024 * 1024 * 16; // 16mb
     WriteAndReadTest(length);
}

private void WriteAndReadTest(long length, long offset = 0L)
{
    byte[] generatedData = GenerateData(length);
    byte[] expectedData = null;

    StorageException resultException = null;
    try
    {
         _blobReaderWriterLazy.Value.Write(offset, generatedData);
         _blobReaderWriterLazy.Value.Read(offset, length, out expectedData);
    }
    catch (StorageException exception)
    {
        resultException = exception;
    }

    Assert.IsNull(resultException);
    Assert.IsTrue(generatedData.Length == expectedData.Length);
    Assert.IsTrue(generatedData.SequenceEqual(expectedData));
}

Answer 1

I will use this method inside my tests class

Your plan is to generate random data to test your thing. Suppose a test fails. How are you planning on debugging it with the data that caused it to fail?

Don't randomize tests. Generate the random test data once, and save it, and then use it over and over again.

Answer 2

You don't need to new up a new random number generator every time. In fact, doing so may result in the same sequence of "random" numbers being generated if they're called too fast in succession (it bases itself off of ticks of the real-time clock). However, with a single instance of the RNG, you wind up with a similar issue as it's not thread-safe, so a mutual exclusion scheme needs to be used to keep its calls serialized. So, in the snippet below, there's one RNG created at the class level and then the lock keyword is used to ensure mutual exclusion from multiple threads.

private static readonly Random _Random = new Random();

private static byte[] GenerateData(long size)
{
    var result = new byte[size];

    lock (_Random)
    {
        _Random.NextBytes(result);
    }

    return result;
}