অন্যান্য উত্তরগুলি পর্যালোচনা করার পরে এবং কোডইনচায়োসের মন্তব্যগুলি বিবেচনা করার পরেও কোডইনচায়োস এখনও পক্ষপাতদুষ্ট (যদিও কম) উত্তর পেয়েছে, আমি ভেবেছিলাম একটি চূড়ান্ত চূড়ান্ত কাটা এবং পেস্ট সমাধান দরকার। সুতরাং আমার উত্তর আপডেট করার সময় আমি সিদ্ধান্ত নিয়েছি যে সব কিছু করা হবে।
এই কোডটির একটি আধুনিক সংস্করণের জন্য, দয়া করে বিটবুকিতে নতুন এইচজি সংগ্রহস্থলটি দেখুন: https://bitbucket.org/merarischroeder/secureswiftrandom । আমি আপনাকে কোডটি অনুলিপি করে আটকানোর পরামর্শ দিচ্ছি: https://bitbucket.org/merarischroeder/secureswiftrandom/src/6c14b874f34a3f6576b0213379ecdf0ffc7496ea/Code/Alivate.SolidSwiftRandom/SolidSwatRideomffflflfl=flout/ (নিশ্চিত করুন যে আপনি ক্লিক অনুলিপি করা এবং আপনার কাছে সর্বশেষতম সংস্করণ রয়েছে তা নিশ্চিত করার জন্য কাঁচা বোতামটি, আমি মনে করি এই লিঙ্কটি কোডটির একটি নির্দিষ্ট সংস্করণে গেছে, সর্বশেষটি নয়)।
আপডেট করা নোট:
- কিছু অন্যান্য উত্তরের সাথে সম্পর্কিত - যদি আপনি আউটপুটটির দৈর্ঘ্য জানেন তবে আপনার স্ট্রিংবিল্ডারের প্রয়োজন হবে না এবং টোচারআরে ব্যবহার করার সময় এটি অ্যারে তৈরি করে এবং পূরণ করে (আপনাকে প্রথমে খালি অ্যারে তৈরি করার দরকার নেই)
- কিছু অন্যান্য উত্তরের সাথে সম্পর্কিত - আপনার একবারে পারফরম্যান্সের জন্য পাওয়ার চেয়ে নেক্সটবাইট ব্যবহার করা উচিত
- প্রযুক্তিগতভাবে আপনি দ্রুত অ্যাক্সেসের জন্য বাইট অ্যারেটি পিন করতে পারেন .. যখন আপনার বাইট অ্যারের উপরে 6-8 বারের বেশি পুনরাবৃত্তি হয় তখন এটি সার্থক হয়। (এখানে করা হয়নি)
- সেরা এলোমেলো করার জন্য আরএনজিক্রিপ্টো সার্ভিস প্রোভাইডার ব্যবহার করুন
- ব্যবহারের র্যান্ডম ডেটার একটি 1MB বাফার ক্যাশে - শো মাপকাঠিতে ক্যাশে একক বাইট সংযোগের গতি ~ 1000x দ্রুততর - uncached জন্য 989ms বনাম 1MB উপর 9ms গ্রহণ।
- আমার নতুন শ্রেণীর মধ্যে পক্ষপাতদুষ্ট অঞ্চলটিকে অনুকূলিতকরণ প্রত্যাখ্যান ।
প্রশ্নের শেষ সমাধান:
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
}
}
}
ইতিহাসের জন্য - এই উত্তরের জন্য আমার পুরানো সমাধান, ব্যবহৃত এলোমেলো বস্তু:
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 । অদৃশ্য। চলমান : 5 মিমি (কখনও কখনও এটি 13 মিমি পর্যন্ত যায়) 10,000 একক পুনরাবৃত্তির সাথে, একক গড় পুনরাবৃত্তি = 1.5 মাইক্রোসেকেন্ড সহ। । দ্রষ্টব্য: সাধারণত 2 টি প্রয়োজন, তবে মাঝে মাঝে 8 টি ক্যাশে রিফ্রেশ হয় - কতগুলি একক বাইট বায়াস জোন অতিক্রম করে তার উপর নির্ভর করে
- এলোমেলো - প্রথম একক রান = ~ 0-1ms । অদৃশ্য। চলমান : 10,000 ম্যাসেজের বেশি 5 মিমি । একক গড় পুনরাবৃত্তি = .5 মাইক্রোসেকেন্ড সহ। । একই গতি সম্পর্কে।
এছাড়াও চেক আউট:
এই লিঙ্কগুলি অন্য পদ্ধতি। এই নতুন কোড বেসে বাফারিং যুক্ত করা যেতে পারে তবে সবচেয়ে গুরুত্বপূর্ণ ছিল পক্ষপাত অপসারণের জন্য বিভিন্ন পদ্ধতির অন্বেষণ করা এবং গতি এবং উপকারগুলি / বিপরীতে চিহ্নিত করা।