RNGCryptoServiceProvider.GetBytes Metod
Definition
Viktigt
En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.
Ö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[])
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>)
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
Gäller för
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.
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.