convertir - byte[] c# example

¿Cómo llenar la matriz de bytes con basura?

Question

Estoy usando esto:

byte[] buffer = new byte[10240];

Como entiendo esto, inicialice la matriz de búfer de 10kb llena con 0s.

¿Cuál es la forma más rápida de llenar esta matriz (o inicializarla) con datos no deseados cada vez?

Necesito usar esa matriz como> 5000 veces y llenarla cada vez con diferentes datos basura, es por eso que estoy buscando un método rápido para hacerlo. El tamaño de la matriz también tendrá que cambiar cada vez.

Answer 1

¿Qué tan basura deben ser los datos? ¿Te refieres al azar? Si ese es el caso solo usa la clase Random .

Answer 2

Como otra opción a considerar, Marshall.AllocHGlobal asignará memoria no administrada. No pone a cero la memoria, se obtiene lo que sucedió allí, así que es muy rápido. Por supuesto, ahora tiene que trabajar con esta memoria utilizando un código no seguro, y si necesita Random.NextBytes en el espacio administrado, Random.NextBytes mejor con Random.NextBytes .

Answer 3

Mira el método System.Random.NextBytes()

Answer 4

Responder a "la manera más rápida" es imposible sin describir cuáles deben ser las propiedades de sus datos basura. ¿Por qué no todos los ceros son válidos para los datos basura?

Dicho esto, esta es una forma rápida de llenar tu matriz con números sin sentido.

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

También puede considerar la implementación de su propio generador lineal congruente si Random no es lo suficientemente rápido para usted. Son simples de implementar y rápidos, pero no dan números aleatorios de alta calidad. (No me queda claro si los necesita o no).

Answer 5

Si está de acuerdo con que los datos sean aleatorios, pero que se creen desde un búfer de inicialización aleatorio, puede hacer lo siguiente:

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;
    }
}

Descubrí que era aproximadamente 60-70 veces más rápido que generar un búfer aleatorio desde cero cada vez.

              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) 

Actualizar

La idea general es crear un RandomBufferGenerator una vez, y luego usar esta instancia para generar buffers aleatorios, por ejemplo:

RandomBufferGenerator generator = new RandomBufferGenerator(MaxBufferSize);

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