RNGCryptoServiceProvider.GetBytes Metod

Definition

Överlagringar

Name Description
GetBytes(Byte[])

Fyller en matris med byte med en kryptografiskt stark sekvens med slumpmässiga värden.

GetBytes(Span<Byte>)

Fyller ett spann med kryptografiskt starka slumpmässiga byte.

GetBytes(Byte[], Int32, Int32)

Fyller den angivna bytematrisen med en kryptografiskt stark slumpmässig sekvens med värden som börjar vid ett angivet index för ett angivet antal byte.

GetBytes(Byte[])

Källa:
RNGCryptoServiceProvider.cs
Källa:
RNGCryptoServiceProvider.cs
Källa:
RNGCryptoServiceProvider.cs
Källa:
RNGCryptoServiceProvider.cs
Källa:
RNGCryptoServiceProvider.cs

Fyller en matris med byte med en kryptografiskt stark sekvens med slumpmässiga värden.

public:
 override void GetBytes(cli::array <System::Byte> ^ data);
public override void GetBytes(byte[] data);
override this.GetBytes : byte[] -> unit
Public Overrides Sub GetBytes (data As Byte())

Parametrar

data
Byte[]

Matrisen som ska fyllas med en kryptografiskt stark sekvens med slumpmässiga värden.

Undantag

Det går inte att hämta den kryptografiska tjänstleverantören (CSP).

data är null.

Exempel

I följande kodexempel visas hur du skapar ett slumptal med RNGCryptoServiceProvider klassen.

//The following sample uses the Cryptography class to simulate the roll of a dice.

using System;
using System.IO;
using System.Text;
using System.Security.Cryptography;

class RNGCSP
{
    private static RNGCryptoServiceProvider rngCsp = new RNGCryptoServiceProvider();
    // Main method.
    public static void Main()
    {
        const int totalRolls = 25000;
        int[] results = new int[6];

        // Roll the dice 25000 times and display
        // the results to the console.
        for (int x = 0; x < totalRolls; x++)
        {
            byte roll = RollDice((byte)results.Length);
            results[roll - 1]++;
        }
        for (int i = 0; i < results.Length; ++i)
        {
            Console.WriteLine("{0}: {1} ({2:p1})", i + 1, results[i], (double)results[i] / (double)totalRolls);
        }
        rngCsp.Dispose();
    }

    // This method simulates a roll of the dice. The input parameter is the
    // number of sides of the dice.

    public static byte RollDice(byte numberSides)
    {
        if (numberSides <= 0)
            throw new ArgumentOutOfRangeException("numberSides");

        // Create a byte array to hold the random value.
        byte[] randomNumber = new byte[1];
        do
        {
            // Fill the array with a random value.
            rngCsp.GetBytes(randomNumber);
        }
        while (!IsFairRoll(randomNumber[0], numberSides));
        // Return the random number mod the number
        // of sides.  The possible values are zero-
        // based, so we add one.
        return (byte)((randomNumber[0] % numberSides) + 1);
    }

    private static bool IsFairRoll(byte roll, byte numSides)
    {
        // There are MaxValue / numSides full sets of numbers that can come up
        // in a single byte.  For instance, if we have a 6 sided die, there are
        // 42 full sets of 1-6 that come up.  The 43rd set is incomplete.
        int fullSetsOfValues = Byte.MaxValue / numSides;

        // If the roll is within this range of fair values, then we let it continue.
        // In the 6 sided die case, a roll between 0 and 251 is allowed.  (We use
        // < rather than <= since the = portion allows through an extra 0 value).
        // 252 through 255 would provide an extra 0, 1, 2, 3 so they are not fair
        // to use.
        return roll < numSides * fullSetsOfValues;
    }
}
'The following sample uses the Cryptography class to simulate the roll of a dice.
Imports System.IO
Imports System.Text
Imports System.Security.Cryptography



Class RNGCSP
    Private Shared rngCsp As New RNGCryptoServiceProvider()
    ' Main method.
    Public Shared Sub Main()
        Const totalRolls As Integer = 25000
        Dim results(5) As Integer

        ' Roll the dice 25000 times and display
        ' the results to the console.
        Dim x As Integer
        For x = 0 To totalRolls
            Dim roll As Byte = RollDice(System.Convert.ToByte(results.Length))
            results((roll - 1)) += 1
        Next x
        Dim i As Integer

        While i < results.Length
            Console.WriteLine("{0}: {1} ({2:p1})", i + 1, results(i), System.Convert.ToDouble(results(i)) / System.Convert.ToDouble(totalRolls))
            i += 1
        End While
        rngCsp.Dispose()
    End Sub


    ' This method simulates a roll of the dice. The input parameter is the
    ' number of sides of the dice.
    Public Shared Function RollDice(ByVal numberSides As Byte) As Byte
        If numberSides <= 0 Then
            Throw New ArgumentOutOfRangeException("NumSides")
        End If 
        ' Create a byte array to hold the random value.
        Dim randomNumber(0) As Byte
        Do
            ' Fill the array with a random value.
            rngCsp.GetBytes(randomNumber)
        Loop While Not IsFairRoll(randomNumber(0), numberSides)
        ' Return the random number mod the number
        ' of sides.  The possible values are zero-
        ' based, so we add one.
        Return System.Convert.ToByte(randomNumber(0) Mod numberSides + 1)

    End Function


    Private Shared Function IsFairRoll(ByVal roll As Byte, ByVal numSides As Byte) As Boolean
        ' There are MaxValue / numSides full sets of numbers that can come up
        ' in a single byte.  For instance, if we have a 6 sided die, there are
        ' 42 full sets of 1-6 that come up.  The 43rd set is incomplete.
        Dim fullSetsOfValues As Integer = [Byte].MaxValue / numSides

        ' If the roll is within this range of fair values, then we let it continue.
        ' In the 6 sided die case, a roll between 0 and 251 is allowed.  (We use
        ' < rather than <= since the = portion allows through an extra 0 value).
        ' 252 through 255 would provide an extra 0, 1, 2, 3 so they are not fair
        ' to use.
        Return roll < numSides * fullSetsOfValues

    End Function 'IsFairRoll
End Class

Kommentarer

Längden på bytematrisen avgör hur många kryptografiskt starka slumpmässiga byte som produceras.

Den här metoden är trådsäker.

Se även

Gäller för

GetBytes(Span<Byte>)

Källa:
RNGCryptoServiceProvider.cs
Källa:
RNGCryptoServiceProvider.cs
Källa:
RNGCryptoServiceProvider.cs
Källa:
RNGCryptoServiceProvider.cs
Källa:
RNGCryptoServiceProvider.cs

Fyller ett spann med kryptografiskt starka slumpmässiga byte.

public:
 override void GetBytes(Span<System::Byte> data);
public override void GetBytes(Span<byte> data);
override this.GetBytes : Span<byte> -> unit
Public Overrides Sub GetBytes (data As Span(Of Byte))

Parametrar

data
Span<Byte>

Det intervall som ska fyllas med kryptografiskt starka slumpmässiga byte.

Gäller för

GetBytes(Byte[], Int32, Int32)

Källa:
RNGCryptoServiceProvider.cs
Källa:
RNGCryptoServiceProvider.cs
Källa:
RNGCryptoServiceProvider.cs
Källa:
RNGCryptoServiceProvider.cs
Källa:
RNGCryptoServiceProvider.cs

Fyller den angivna bytematrisen med en kryptografiskt stark slumpmässig sekvens med värden som börjar vid ett angivet index för ett angivet antal byte.

public:
 override void GetBytes(cli::array <System::Byte> ^ data, int offset, int count);
public override void GetBytes(byte[] data, int offset, int count);
override this.GetBytes : byte[] * int * int -> unit
Public Overrides Sub GetBytes (data As Byte(), offset As Integer, count As Integer)

Parametrar

data
Byte[]

Matrisen som ska fyllas med kryptografiskt starka slumpmässiga byte.

offset
Int32

Matrisens index för att starta fyllningsåtgärden.

count
Int32

Antalet byte som ska fyllas.

Undantag

data är null.

offset eller count är mindre än 0.

offset plus count överskrider längden på data.

Gäller för