Bygga sträng

Jag kan inte detta språk, men du kanske kan översätta följande JS

function rnd(f,u)
{
  return f + Math.round((u-f) * Math.random());
}
var upperletters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var lowerletters = "abcdefghijklmnopqrstuvwxyz";
var numbers = "0123456789";
var symbols = "_?=@!+%";
var all = [upperletters, lowerletters, numbers, symbols];
var sb = "";

sb += upperletters[rnd(0,upperletters.length-1)]
          + lowerletters[rnd(0,lowerletters.length-1)]
          + numbers[rnd(0,numbers.length-1)]
          + symbols[rnd(0,symbols.length-1)];

for (var i = 0; i < 6; ++i){
  var e = all[rnd(0,all.length-1)];
  sb += e[rnd(0,e.length-1)];
}

document.write(sb)

Tack. Problemet är att då blir det en stor bokstav, en liten bokstav, en siffra och en symbol. Och sen 6 slump tecken. Vill helst att det skall vara 10 tecken i slumpartad ordning.

Någon sådan lösning?

Annars tar jag den du gav. För jag har en annan funktion som gör en "scramble" på en sträng.

function rnd(f,u)
{
  return f + Math.round((u-f) * Math.random());
}
var upperletters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var lowerletters = "abcdefghijklmnopqrstuvwxyz";
var numbers = "0123456789";
var symbols = "_?=@!+%";
var all = [upperletters, lowerletters, numbers, symbols];
var sb = "";

for (var i = 0; i < 10; ++i){
  var e = all[rnd(0,all.length-1)];
  sb += e[rnd(0,e.length-1)];
}

document.write(sb)

Sådär då? Borde väl fungera?

Koplik: Får den inte att fungera som javascript. Och var ser den till att det är med minst ett tecken från varje grupp?

Dino skrev:

Koplik: Får den inte att fungera som javascript. Och var ser den till att det är med minst ett tecken från varje grupp?

Jag misstänkte att jag missade något.
Nä, då blir det ju klurigare. Då blir det att göra en kontroll efter varje och köra om den om det inte kommer med ett tecken från varje grupp.

Sen göra koden anpassad för asp.net

Om det hade varit lätt hade jag aldrig frågat här. ;)

Så här kanske

function rnd(f,u)
{
  if (!(f < u)) return f;
  return f + Math.round((u-f) * Math.random());
}
var upperletters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var lowerletters = "abcdefghijklmnopqrstuvwxyz";
var numbers = "0123456789";
var symbols = "_?=@!+%";
var all = [upperletters, lowerletters, numbers, symbols];
var sb = "";

sb += upperletters[rnd(0,upperletters.length-1)]
          + lowerletters[rnd(0,lowerletters.length-1)]
          + numbers[rnd(0,numbers.length-1)]
          + symbols[rnd(0,symbols.length-1)];

for (var i = 0; i < 6; ++i){
  var e = all[rnd(0,all.length-1)];
  sb += e[rnd(0,e.length-1)];
  var tmpIndex1 = rnd(0,sb.length-1);
  var tmpIndex2 = rnd(0,sb.length-1);
  var tmpEntry  = sb[tmpIndex1];
  sb[tmpIndex1] = sb[tmpIndex2];
  sb[tmpIndex2] = tmpEntry;
}

document.write(sb)

Nu vet jag som sagt inte om ASP.NET tillåter syntaxen med '[]'.

private string RandChars(int chr) 
{ 
 int v1 = chr; 
 string str = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVXYZ_?=@!+%"; 
 string build = ""; 
 while (v1 > 0) { 
   build += MID(str, (RND() * 68) + 1, 1); 
   v1 = v1 - 1; 
 } 
 return build; 
}

Response.Write(RandChars(10));

Notera: Ta bort mellanrummet i strängen mellan Y och Z.

VB:

Private Function RandChars(ByVal chr As Integer) As String 
 Dim v1 As Integer = chr 
 Dim str As String = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVXY Z_?=@!+%" 
 Dim build As String = "" 
 While v1 > 0 
   build += MID(str, (RND * 68) + 1, 1) 
   v1 = v1 - 1 
 End While 
 Return build 
End Function

PeterS: Den fungerar nog inte i C#.

Jesper T: Det ser ut att missa villkoret att det skall vara minst ett tecken från varje grupp.

Ju mer komplicerade javascripten blir desto svårare blir det att göra det till C#. Så för att inte växa skägg över det här så går jag med Peter S första lösning och sen kastar jag om tecknen inbördes.

Tack för svaren.

Håller tråden öppen om en ren c# lösning skulle falla in. :)

här

orkar inte sortera men...

using System;
using System.Text;

namespace myNameSpace
{

	/// <summary>
	/// The Allow flags define restriction values for password generation.
	/// </summary>	
	[Flags]
	public enum Allow : byte 
	{
		Alpha = 1, Digit = 2, Symbol = 4, Lowercase = 8, Uppercase = 16, 
		DigitFirst = 32, DigitLast = 64, SymbolFirst = 128, SymbolLast = 255
	}

	/// <remarks>
	///	This class implements a simple password generator. It allows setting properties
	/// for the types of characters allowed and sizing the generated password.
	/// </remarks>
	public class PasswordGenerator 
	{
		/// <summary>
		/// The ASCII enumeration defines several ranges for ASCII characters.
		/// 32 - 47, 58 - 64, 91 - 95, 123 - 126 special characters
		/// 48 - 57 digits
		/// 65 - 90, 97 - 122 uppercase, lowercase letters
		/// </summary>	
		public enum ASCII 
		{
			SpecialLower1 = 32, SpecialUpper1 = 47, SpecialLower2 = 58, SpecialUpper2 = 64, 
			SpecialLower3 = 91, SpecialUpper3 = 95, SpecialLower4 = 123, SpecialUpper4 = 126,
			DigitsLower = 48, DigitsUpper = 57,
			UppercaseLower = 65, UppercaseUpper = 90, LowercaseLower = 97, LowercaseUpper = 122
		}

		public PasswordGenerator() 
		{
			passwordBuffer = new StringBuilder();
			this.Restrictions = Allow.Alpha;
			this.MinimumSize = 6;
			this.MaximumSize = 10;
			this.ExcludedCharacters = String.Empty;
		}

		/// <summary>
		/// The Password property generates and returns a new password.
		/// </summary>
		public string Password 
		{
			get 
			{
				return Generate();
			}
		}

		/// <summary>
		/// The Restrictions property gets and sets the flags that
		/// control allowable characters for the password.
		/// </summary>
		public Allow Restrictions 
		{
			get 
			{
				return this.allowFlags;
			}
			set 
			{
				this.allowFlags = value;
			}
		}

		/// <summary>
		/// The MinimumSize property gets/sets the minimum, allowable
		/// length of the password.
		/// </summary>
		public int MinimumSize 
		{
			get 
			{
				return this.minSize;
			}
			set 
			{
				this.minSize = value;
			}
		}

		/// <summary>
		/// The MaximumSize property gets/sets the maximum, allowable
		/// length of the password.
		/// </summary>
		public int MaximumSize 
		{
			get 
			{
				return this.maxSize;
			}
			set 
			{
				this.maxSize = value;
			}
		}

		/// <summary>
		/// The ExcludedCharacters property gets/sets the set of individual characters
		/// to be excluded from the password.
		/// </summary>
		public string ExcludedCharacters 
		{
			get 
			{
				return this.excludedChars;
			}
			set 
			{
				this.excludedChars = value;
			}
		}

		/// <summary>
		/// The MaximumDigits property gets/sets the maximum, allowable
		/// number of digits in the password.
		/// </summary>
		public int MaximumDigits 
		{
			get 
			{
				return this.maxDigits;
			}
			set 
			{
				this.maxDigits = value;
			}
		}

		/// <summary>
		/// The MaximumSymbols property gets/sets the maximum, allowable
		/// number of symbols in the password.
		/// </summary>		
		public int MaximumSymbols 
		{
			get 
			{
				return this.maxSymbols;
			}
			set 
			{
				this.maxSymbols = value;
			}
		}

		protected virtual string Generate() 
		{
			rnd = new Random();

			passwordBuffer.Capacity = this.MaximumSize * 2;

			int length = 0;
			int max = passwordBuffer.Capacity - 1;
			while ( length < max ) 
			{
				int genChar = this.rnd.Next(0, 4);

				switch (genChar) 
				{
					case 0:
						if ( (this.Restrictions & Allow.Lowercase) != 0 ) 
						{
							AppendRandomCharacter(ASCII.LowercaseLower, ASCII.LowercaseUpper);
							length = length + 1;
						}
						break;
					case 1:
						if ( (this.Restrictions & Allow.Uppercase) != 0 ) 
						{
							AppendRandomCharacter(ASCII.UppercaseLower, ASCII.UppercaseUpper);
							length = length + 1;
						}
						break;
					case 2:
						if ( (this.Restrictions & Allow.Digit) != 0 ) 
						{
							AppendRandomCharacter(ASCII.DigitsLower, ASCII.DigitsUpper);
							length = length + 1;
						}
						break;
					case 3:
						if ( (this.Restrictions & Allow.Symbol) != 0 ) 
						{
							int sym = this.rnd.Next(0, 4);
							switch (sym) 
							{
								case 0:
									AppendRandomCharacter(ASCII.SpecialLower1, ASCII.SpecialUpper1);
									length = length + 1;
									break;
								case 1:
									AppendRandomCharacter(ASCII.SpecialLower2, ASCII.SpecialUpper2);
									length = length + 1;
									break;
								case 2:
									AppendRandomCharacter(ASCII.SpecialLower3, ASCII.SpecialUpper3);
									length = length + 1;
									break;
								case 3:
									AppendRandomCharacter(ASCII.SpecialLower4, ASCII.SpecialUpper4);
									length = length + 1;
									break;
							}
						}
						break;
				}
			}
			
			EnforceConstraints();
			return passwordBuffer.ToString().Trim();
		}

		protected void AppendRandomCharacter(ASCII lower, ASCII upper) 
		{
			int rndchar	= this.rnd.Next((int)lower, (int)(upper + 1));
			byte[] rndbyte = new byte[1];
			rndbyte[0] = (byte)rndchar;
			string appendstr = Encoding.ASCII.GetString(rndbyte); 
			passwordBuffer.Append(appendstr);
		}

		protected void EnforceConstraints() 
		{
			// Remove excluded characters
			foreach (char c in this.ExcludedCharacters) 
			{
				passwordBuffer.Replace(c.ToString(), null);
			}

			// Count digits and symbols and ensure they don't exceed maximums
			int numDigits = 0, numSymbols = 0;
			StringBuilder temp = new StringBuilder(passwordBuffer.ToString(), 0,this.MaximumSize, this.MaximumSize);

			foreach (char count in temp.ToString()) 
			{
				if ( Char.IsDigit(count) == true ) 
				{
					numDigits++;
				}

				if ( Char.IsSymbol(count) == true ) 
				{
					numSymbols++;
				}
			}

			if ( numDigits > this.MaximumDigits ) 
			{
				int count = 0;
				for ( int i = 0; i < temp.Length; i++ ) 
				{
					if ( Char.IsDigit(temp[i]) == true ) 
					{
						if ( count < numDigits - this.MaximumDigits ) 
						{
							temp.Replace(temp[i].ToString(), null);
							count++;
						}
					}
				}
			}

			if ( numSymbols > this.MaximumSymbols ) 
			{
				int count = 0;
				for ( int i = 0; i < temp.Length; i++ ) 
				{
					if ( Char.IsSymbol(temp[i]) == true ) 
					{
						if ( count < numSymbols - this.MaximumSymbols ) 
						{
							temp.Replace(temp[i].ToString(), null);
							count++;
						}
					}
				}
			}

			passwordBuffer.Remove(0, temp.Length);
			passwordBuffer.Insert(0, temp.ToString(), temp.Length);

			// Check first character
			if ( (this.Restrictions & Allow.DigitFirst) == 0 ) 
			{
				while ( Char.IsDigit(passwordBuffer[0]) == true ) 
				{
					passwordBuffer.Remove(0, 1);
				}
			}
			
			if ( (this.Restrictions & Allow.SymbolFirst) == 0 ) 
			{
				while ( Char.IsSymbol(passwordBuffer[0]) == true ) 
				{
					passwordBuffer.Remove(0, 1);
				}
			}
			
			// Pick random length between minimum and maximum
			int pwdLength = rnd.Next(this.MinimumSize, ( this.MaximumSize + 1 ));
			passwordBuffer.Length = pwdLength; 

			// Check last character
			if ( (this.Restrictions & Allow.DigitLast) == 0 ) 
			{
				while ( Char.IsDigit(passwordBuffer[passwordBuffer.Length - 1]) == true ) 
				{
					passwordBuffer.Remove(passwordBuffer.Length - 1, 1);
				}
			}

			if ( (this.Restrictions & Allow.SymbolLast) == 0 ) 
			{
				while ( Char.IsSymbol(passwordBuffer[passwordBuffer.Length - 1]) == true ) 
				{
					passwordBuffer.Remove(passwordBuffer.Length - 1, 1);
				}
			}
		}

		private StringBuilder passwordBuffer;  
		private int minSize, maxSize;
		private string excludedChars;
		private int maxDigits, maxSymbols;
		private Allow allowFlags;
		private Random rnd;
	}
}

Tackar för den. (y) (y) (y) Lägger den i mitt bibliotek.

Min är lite simplare, så jag får se om jag byter ut den :)

public override string GeneratePassword()
{
   StringBuilder sb = new StringBuilder();
   Random rnd = new Random();
   char[] upperletters = "ABCDEFGHJKLMNPQRSTUVWXYZ".ToCharArray();
   char[] lowerletters = "abcdefghjkmnpqrstuvwxyz".ToCharArray();
   char[] numbers = "23456789".ToCharArray();
   char[] symbols = "_?=@!+%".ToCharArray();
   char[] all = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz23456789_?=@!+%".ToCharArray();

   sb.Append(upperletters[rnd.Next(0, upperletters.Length)]);
   sb.Append(lowerletters[rnd.Next(0, lowerletters.Length)]);
   sb.Append(numbers[rnd.Next(0, numbers.Length)]);
   sb.Append(symbols[rnd.Next(0, symbols.Length)]);

   for (int i = 0; i < 3; i++)
   {
      sb.Append(all[rnd.Next(0, all.Length)]);
   }

   char[] arr = sb.ToString().ToCharArray();
            
   for (int i = 0; i < arr.Length; i++)
   {
      int x = rnd.Next(0, arr.Length);
      char temp1 = arr[i];
      char temp2 = arr[x];

      arr[i] = temp2;
      arr[x] = temp1;
   }

   sb.Remove(0, 7);
   sb.Append(arr);
   return sb.ToString();
}