CodeInChaos와 함께 다른 답변을 검토하고 CodeInChaos의 의견을 고려한 후에도 여전히 치우친 답변이 있지만 최종 최종 잘라 내기 및 붙여 넣기 솔루션 이 필요 하다고 생각했습니다 . 그래서 내 대답을 업데이트하는 동안 나는 모두 나가기로 결정했습니다.
이 코드의 최신 버전을 보려면 Bitbucket의 새로운 Hg 저장소를 방문하십시오. https://bitbucket.org/merarischroeder/secureswiftrandom) 하십시오 . 난 당신이 복사에서 코드를 붙여 추천 : https://bitbucket.org/merarischroeder/secureswiftrandom/src/6c14b874f34a3f6576b0213379ecdf0ffc7496ea/Code/Alivate.SolidSwiftRandom/SolidSwiftRandom.cs?at=default&fileviewer=file-view-default (메이크업 확실히 당신은 클릭 Raw 버튼을 사용하면 쉽게 복사하고 최신 버전을 사용할 수 있습니다.이 링크는 최신 버전이 아닌 특정 버전의 코드로 이동한다고 생각합니다.
업데이트 된 메모 :
- 다른 답변과 관련-출력 길이를 알고 있다면 StringBuilder가 필요하지 않으며 ToCharArray를 사용할 때 배열을 만들고 채 웁니다 (먼저 빈 배열을 만들 필요가 없습니다)
- 다른 답변과 관련-성능을 위해 한 번에 하나씩 얻는 대신 NextBytes를 사용해야합니다.
- 기술적으로보다 빠른 액세스를 위해 바이트 배열을 고정 할 수 있습니다. 일반적으로 바이트 배열에서 6-8 회 이상 반복 할 때 유용합니다. (여기서는 안됨)
- 최상의 무작위성을 위해 RNGCryptoServiceProvider 사용
- 임의 데이터의 1MB 버퍼 캐싱 사용 -벤치마킹은 캐시 된 단일 바이트 액세스 속도가 ~ 1000 배 빠르다는 것을 보여줍니다.
- 새 클래스 내 에서 바이어스 영역의 거부를 최적화했습니다 .
궁금한 최종 솔루션 :
static char[] charSet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".ToCharArray();
static int byteSize = 256; //Labelling convenience
static int biasZone = byteSize - (byteSize % charSet.Length);
public string GenerateRandomString(int Length) //Configurable output string length
{
byte[] rBytes = new byte[Length]; //Do as much before and after lock as possible
char[] rName = new char[Length];
SecureFastRandom.GetNextBytesMax(rBytes, biasZone);
for (var i = 0; i < Length; i++)
{
rName[i] = charSet[rBytes[i] % charSet.Length];
}
return new string(rName);
}
그러나 당신은 나의 새로운 (예상치 않은) 수업이 필요합니다 :
/// <summary>
/// My benchmarking showed that for RNGCryptoServiceProvider:
/// 1. There is negligable benefit of sharing RNGCryptoServiceProvider object reference
/// 2. Initial GetBytes takes 2ms, and an initial read of 1MB takes 3ms (starting to rise, but still negligable)
/// 2. Cached is ~1000x faster for single byte at a time - taking 9ms over 1MB vs 989ms for uncached
/// </summary>
class SecureFastRandom
{
static byte[] byteCache = new byte[1000000]; //My benchmark showed that an initial read takes 2ms, and an initial read of this size takes 3ms (starting to raise)
static int lastPosition = 0;
static int remaining = 0;
/// <summary>
/// Static direct uncached access to the RNGCryptoServiceProvider GetBytes function
/// </summary>
/// <param name="buffer"></param>
public static void DirectGetBytes(byte[] buffer)
{
using (var r = new RNGCryptoServiceProvider())
{
r.GetBytes(buffer);
}
}
/// <summary>
/// Main expected method to be called by user. Underlying random data is cached from RNGCryptoServiceProvider for best performance
/// </summary>
/// <param name="buffer"></param>
public static void GetBytes(byte[] buffer)
{
if (buffer.Length > byteCache.Length)
{
DirectGetBytes(buffer);
return;
}
lock (byteCache)
{
if (buffer.Length > remaining)
{
DirectGetBytes(byteCache);
lastPosition = 0;
remaining = byteCache.Length;
}
Buffer.BlockCopy(byteCache, lastPosition, buffer, 0, buffer.Length);
lastPosition += buffer.Length;
remaining -= buffer.Length;
}
}
/// <summary>
/// Return a single byte from the cache of random data.
/// </summary>
/// <returns></returns>
public static byte GetByte()
{
lock (byteCache)
{
return UnsafeGetByte();
}
}
/// <summary>
/// Shared with public GetByte and GetBytesWithMax, and not locked to reduce lock/unlocking in loops. Must be called within lock of byteCache.
/// </summary>
/// <returns></returns>
static byte UnsafeGetByte()
{
if (1 > remaining)
{
DirectGetBytes(byteCache);
lastPosition = 0;
remaining = byteCache.Length;
}
lastPosition++;
remaining--;
return byteCache[lastPosition - 1];
}
/// <summary>
/// Rejects bytes which are equal to or greater than max. This is useful for ensuring there is no bias when you are modulating with a non power of 2 number.
/// </summary>
/// <param name="buffer"></param>
/// <param name="max"></param>
public static void GetBytesWithMax(byte[] buffer, byte max)
{
if (buffer.Length > byteCache.Length / 2) //No point caching for larger sizes
{
DirectGetBytes(buffer);
lock (byteCache)
{
UnsafeCheckBytesMax(buffer, max);
}
}
else
{
lock (byteCache)
{
if (buffer.Length > remaining) //Recache if not enough remaining, discarding remaining - too much work to join two blocks
DirectGetBytes(byteCache);
Buffer.BlockCopy(byteCache, lastPosition, buffer, 0, buffer.Length);
lastPosition += buffer.Length;
remaining -= buffer.Length;
UnsafeCheckBytesMax(buffer, max);
}
}
}
/// <summary>
/// Checks buffer for bytes equal and above max. Must be called within lock of byteCache.
/// </summary>
/// <param name="buffer"></param>
/// <param name="max"></param>
static void UnsafeCheckBytesMax(byte[] buffer, byte max)
{
for (int i = 0; i < buffer.Length; i++)
{
while (buffer[i] >= max)
buffer[i] = UnsafeGetByte(); //Replace all bytes which are equal or above max
}
}
}
역사-이 대답에 대한 나의 오래된 해결책은 Random 객체를 사용했습니다.
private static char[] charSet =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".ToCharArray();
static rGen = new Random(); //Must share, because the clock seed only has Ticks (~10ms) resolution, yet lock has only 20-50ns delay.
static int byteSize = 256; //Labelling convenience
static int biasZone = byteSize - (byteSize % charSet.Length);
static bool SlightlyMoreSecurityNeeded = true; //Configuration - needs to be true, if more security is desired and if charSet.Length is not divisible by 2^X.
public string GenerateRandomString(int Length) //Configurable output string length
{
byte[] rBytes = new byte[Length]; //Do as much before and after lock as possible
char[] rName = new char[Length];
lock (rGen) //~20-50ns
{
rGen.NextBytes(rBytes);
for (int i = 0; i < Length; i++)
{
while (SlightlyMoreSecurityNeeded && rBytes[i] >= biasZone) //Secure against 1/5 increased bias of index[0-7] values against others. Note: Must exclude where it == biasZone (that is >=), otherwise there's still a bias on index 0.
rBytes[i] = rGen.NextByte();
rName[i] = charSet[rBytes[i] % charSet.Length];
}
}
return new string(rName);
}
공연:
- SecureFastRandom - 최초의 단일 실행은 = ~ 9-33ms . 이해할 수 없습니다. 진행 중 : 10,000 회 이상 5ms (때로는 최대 13ms), 단일 평균 반복 = 1.5 마이크로 초. . 참고 : 일반적으로 2 개, 때로는 최대 8 개의 캐시 새로 고침이 필요합니다. 바이어스 영역을 초과하는 단일 바이트 수에 따라 다릅니다.
- Random - First 단일 실행 = ~ 0-1ms . 이해할 수 없습니다. 진행 중 : 10,000 회 이상 5ms 단일 평균 반복 = 0.5 마이크로 초 . 같은 속도입니다.
또한 확인하십시오 :
이 링크는 또 다른 접근법입니다. 이 새로운 코드베이스에 버퍼링을 추가 할 수 있었지만, 가장 중요한 것은 바이어스를 제거하고 속도와 장단점을 벤치마킹하는 다양한 방법을 모색하는 것이 었습니다.