Résumé Les nombres pseudo-aléatoires sont largement utilisés dans la conception de logiciels informatiques. Cet article présente les principes généraux de la génération de nombres pseudo-aléatoires et l'utilisation de la classe Random et de ses méthodes fournies dans ASP.NET Framework pour générer des nombres aléatoires dans diverses plages répondant à diverses exigences. Enfin, en combinaison avec le formulaire de contrôle Web, l'application des nombres aléatoires dans ASP.NET dans la conception de logiciels est expliquée.
Mots-clés ASP.NET ; génération de nombres pseudo-aléatoires ; Web ; les nombres aléatoires de type aléatoire
sont largement utilisés dans la conception de logiciels, en particulier dans les domaines de la simulation et des tests d'environnements pratiques. Afin de rechercher des séquences véritablement aléatoires, les gens ont utilisé de nombreuses méthodes physiques primitives pour générer des séquences uniformément distribuées qui respectent la précision (nombre de bits) dans une certaine plage. Leurs inconvénients sont : une vitesse lente, une faible efficacité, nécessitant une grande quantité de stockage. espace, et être indisponible, réapparaître, etc. Afin de répondre aux besoins de la recherche en simulation informatique, les chercheurs se tournent vers la recherche sur l'utilisation d'algorithmes pour générer des séquences pseudo-aléatoires qui simulent diverses distributions de probabilité. Les nombres pseudo-aléatoires font référence à des nombres aléatoires générés par des formules mathématiques de récursion. D'un point de vue pratique, la manière la plus simple et la plus naturelle d'obtenir de tels nombres est d'utiliser un générateur de nombres aléatoires fourni par une bibliothèque de langage informatique. Différents environnements de développement fournissent différentes fonctions et méthodes pour générer des nombres aléatoires. Généralement, il génère une variable pseudo-aléatoire dont les valeurs sont uniformément réparties entre 0 et 1.
Un générateur de nombres aléatoires est
une méthode permettant de générer des nombres aléatoires dans un ordinateur, souvent en utilisant la formule suivante :
Le programme qui utilise cette formule pour générer une séquence de nombres aléatoires a1, a2,... de 0 à 65536 est appelé générateur de nombres aléatoires harmoniques multiplicatifs en 232 étapes. Parmi eux, b, c et d sont des entiers positifs, et d est appelé la graine de la séquence aléatoire générée par la formule.
Il ressort de cette formule qu'une fois les paramètres b, c et d déterminés, la séquence aléatoire générée est également déterminée. Cette séquence qui ne satisfait que dans une certaine mesure au caractère aléatoire est appelée nombre pseudo-aléatoire.
Vous trouverez ci-dessous un exemple de générateur de nombres aléatoires. Parmi eux, la fonction random_seed permet à l'utilisateur de sélectionner la graine d'un nombre aléatoire Lorsque le paramètre formel d = 0, l'heure actuelle du système est utilisée comme graine de nombre aléatoire lorsque d≠0, d est sélectionné comme graine ; seed ; la fonction random est basée sur la graine donnée, calcule une nouvelle graine et génère un nouveau nombre aléatoire dans la plage de bas à haut.
#define MULTIPLICATEUR 0x015A4E35L
#define INCREMENT 1
void random_seed(unsigned long d){
si (d==0)graine = temps(0);
sinon graine = d;}
non signé int aléatoire (non signé long bas, non signé long haut)
{
graine = MULTIPLICATEUR * graine + INCREMENT ;
retour ((seed>>16)% (haut-bas) + bas);
}
}
Le mécanisme de génération de nombres pseudo-aléatoires dans ASP.NET
empêche l'ordinateur de générer des nombres complètement aléatoires. Le générateur de nombres aléatoires utilise un certain algorithme pour effectuer des opérations complexes sur des graines aléatoires présélectionnées et utilise les résultats générés pour simuler approximativement des nombres complètement aléatoires. Ce type de nombre aléatoire est appelé nombre pseudo-aléatoire. Les nombres pseudo-aléatoires sont choisis parmi un ensemble fini de nombres avec une probabilité égale. Les nombres choisis ne sont pas complètement aléatoires, mais ils le sont suffisamment pour des raisons pratiques.
1. Fonctions intégrées de VB.NET
Les programmes ASP.NET peuvent utiliser une variété de langages de programmation. Le langage de programmation par défaut est VB.NET. Bien que VB.NET et VB soient quelque peu similaires, leurs environnements d'application et leurs méthodes d'écriture sont différents. le code est différent. Il y a aussi des différences. Dans VB.NET, si vous souhaitez utiliser des fonctions mathématiques, vous devez transmettre la classe Math fournie par le .NET Framework, qui se trouve sous l'espace de noms Système. Les utilisateurs peuvent ajouter Imports System Math en haut du code pour les utiliser. fonctions mathématiques.
Le prototype de la fonction utilisée pour générer des nombres aléatoires est : Rnd(x) Cette fonction permet de générer un nombre aléatoire simple précision compris entre 0 et 1. x est la graine pour générer des nombres aléatoires. Si vous souhaitez sélectionner au hasard un nombre dans la plage de (min, max), vous devez utiliser la formule : nombre aléatoire = (max - min) * Rnd(x) + min.
La sélection de nombres pseudo-aléatoires part de graines aléatoires. Afin de garantir que les nombres pseudo-aléatoires obtenus à chaque fois sont suffisamment « aléatoires », la sélection de graines aléatoires est très importante. Si les graines aléatoires sélectionnées sont les mêmes, les séquences aléatoires générées seront également les mêmes. Généralement, les paramètres liés à l'heure du système sont utilisés comme valeurs de départ aléatoires, ce qui est également la méthode par défaut utilisée par le générateur de nombres aléatoires dans .net Framework.
2. Classe de nombres aléatoires System.Random
Classe de nombres aléatoires La classe System.Random fournit les méthodes suivantes pour générer divers nombres aléatoires qui répondent à différentes exigences, comme indiqué dans le tableau 1 :
Tableau 1 Diverses méthodes fournies par la classe System.Random
| numéro de série | nom de la méthode | Description de la fonction |
| 1 | Suivant() | Renvoie un entier compris entre 0 et 2147483647 |
| 2 | Suivant(i) | Renvoie un entier compris entre 0 et i |
| 3 | Suivant(i,j) | Renvoie un entier compris entre i~j |
| 4 | Suivantdouble() | Renvoie un nombre décimal aléatoire compris entre 0 et 1 |
| 5 | Suivantdouble(octet()) | Utilisez un entier aléatoire compris entre 0 et 255 comme valeur de chaque élément du tableau d'octets. |
En utilisant la classe de nombres aléatoires System.Random doit être déclaré en premier. Si vous souhaitez utiliser la méthode Nextbytes(byte()), vous devez également déclarer le tableau d'octets avant de l'utiliser.
3. L'écriture du programme de test
doit établir son environnement de développement et d'exécution avant d'exécuter le programme ASP.NET, y compris la configuration de Microsoft IIS et l'installation du SDK .NET Framework et de l'éditeur MSE de la machine. L'éditeur MSE est un logiciel complémentaire pour Microsoft Office et est très pratique comme outil d'édition pour ASP.NET. Le code du programme de test est le suivant :
<script language="vb" runat="server">
sub page_load(send as object,e as eventargs)
dim r1 comme aléatoire = nouveau aléatoire ()
réponse.write("Le résultat de r1.next() est :"+r1.next().tostring())
réponse.write("Le résultatfr1.next(100)est :" +r1.next(100).tostring())
réponse.write("Le résultat de r1.next(100,150) est :"+r1.next(100,150).tostring())
réponse.write("Le résultat de r1.nextdouble() est :"+r1.nextdouble().tostring())
r1.nextbytes(r) // atténue r(300) en octet
réponse.write("le r(100) est :")
réponse.write(r(199))
end sub ＜/script＞
Les résultats des tests sont présentés dans la figure 1 :
Figure 1 Résultats de l'exécution d'un test de nombres pseudo-aléatoires
Exemple
d'analyse des exigences d'une application de développement : Créez une application pour simuler un jeu de dés. Dans ce jeu, les joueurs lancent un dé au hasard. Chaque dé a six faces, représentant respectivement les six points 1, 2, 3, 4, 5 et 6. Lorsque le dé s'arrête, regardez le numéro sur la surface supérieure du dé. Si le nombre de lancers est de 6, le message gagnant sera affiché, sinon le lancer continuera.
1. Technologies clés
1.1 Formulaire de contrôle Web
Le formulaire de contrôle Web présente les caractéristiques orientées objet d'un langage de haut niveau. Il s'agit d'un objet de l'espace de noms System.Web.UI.WebControls dans ASP.NET. Le processus de traitement est similaire au formulaire de contrôle HTML, avec les caractéristiques suivantes : le formulaire s'exécute côté serveur ; les champs de saisie sont tous des contrôles, avec des propriétés et des méthodes puissantes et riches, et les informations des champs de saisie peuvent être conservées ; il a la capacité de vérifier les champs de saisie ; Contient des contrôles d'affichage des données, etc.
Un code de formulaire de contrôle Web typique est le suivant :
<asp: button id="sub3" text="confirm" runat="server"/>
Parmi eux, ASP : XXX indique de quel type de contrôle Web il s'agit ; le nom d'identification du contrôle ; La valeur de l'attribut Runat est serveur, indiquant qu'il s'agit d'un contrôle exécuté côté serveur.
Les champs Web qui seront utilisés dans cet exemple sont principalement des champs boutons. Le champ Image permet d'afficher les fichiers image et possède les attributs suivants : Imageurl, indiquant l'URL du fichier image ; Largeur, la largeur d'affichage du fichier image ; Hauteur, la hauteur d'affichage du fichier image, etc.
1.2 Génération de nombres pseudo-aléatoires
Selon la description de l'analyse des besoins, afin de simuler les points obtenus en lançant des dés aléatoirement, il est nécessaire de générer aléatoirement des nombres entiers allant de 1 à 6. Dans ce cas, la méthode Next (i, j) de la classe System.Random peut être utilisée, où i=1, j=7. (L'auteur a écrit un programme de test et a constaté que si j=6, le nombre aléatoire généré est compris entre 1 et 5)
2. Implémentation du programme
Le code principal du programme est le suivant :
<script language="vb" runat="server ">
sub disp(obj as object,e as eventargs)
dim r1 as random =new random() //Définir une classe de nombres aléatoires
dim file_prefix as string = "Imagesdie"
dim file_suffix as string = ".png"
value = r1. next(1,7) //dim value as Integer
s1 = file_prefix + value.tostring() + file_suffix
pic1.imageurl = s1 //Mettre à jour l'attribut imageurl du contrôle Image
si value = 6 alors
disp.text = " Vous gagnez" / /Afficher les informations d'invite
else
disp.text = "Réessayer"
end if
end sub
＜/script＞
＜form id="form1" runat="server"＞＜br＞
＜asp:button id="disp" runat="server " onclick="disp" text="start"/＞
＜asp:image id="pic1" runat="server" width="50" height="50"/＞＜/form＞
Le résultat en cours d'exécution du programme est illustré dans la figure 2 illustrée :
Figure 2 Résultats de l'exécution du programme
Conclusion
Les nombres pseudo-aléatoires sont utilisés à de nombreux endroits dans les applications Web. Comment choisir les paramètres de départ pour générer des séquences aléatoires et quel algorithme aléatoire utiliser pour générer des séquences pseudo-aléatoires avec de meilleures performances sont des logiciels informatiques. développeurs. Un des objectifs poursuivis. À l'aide de la classe de génération de nombres pseudo-aléatoires fournie par le framework ASP.NET et des méthodes fonctionnelles fournies par le langage de script VB.NET, diverses séquences aléatoires répondant à différentes exigences peuvent être générées. Par exemple, le code de contrôle aléatoire utilisé pour l'authentification d'identité dans le système Web utilise une technologie de génération de nombres aléatoires. Il existe de nombreux articles sur ce site Web, je n'entrerai donc pas dans les détails ici.