Méthode correcte de “statique” l'Aléatoire.Suivant en C#?

Pourquoi ai-je besoin de créer une instance de la classe au sort, si je veux créer un nombre aléatoire entre 1 et 100 ....comme

Random rand = new Random();
rand.Next(1,100);

Est-il statique de la fonction de Hasard de classe à faire de même? comme...

Random.Next(1,100);

Je ne veux pas créer une instance inutilement

Et en conclusion ... ne pas prématurément optimiser 🙂
Double Possible de Pourquoi le Système.Aléatoire classe non statique?

InformationsquelleAutor Sunil | 2010-04-15

c#random

34

Il est recommandé de créer une instance unique de Random et de l'utiliser tout au long de votre programme, faute de quoi les résultats peuvent ne pas être aussi aléatoire. Ce comportement est encouragé par le pas de la création d'une fonction statique.

Vous ne devriez pas vous inquiéter au sujet de "la création d'une instance inutilement", l'impact est négligeable au mieux - c'est le moyen le cadre de travaux.
- pourrait-ce pas être atteint si le Hasard était statique? Le générateur devrait être semées au moment de la construction et vous pouvez l'utiliser à travers?
- qui aurait besoin d'une instance interne de toute façon, et exiger de l'état. Je ne pense pas qu'il appartient en tant que partie du cadre, mais il pourrait être de mettre en œuvre facilement sur votre classe statique.
- peut-être que je devrais poster à ma propre question sur ce point :). L'utilisation de la mémoire et de la performance de côté, je trouve que c'est gênant pour instancier cette classe. Si vous avez l'intention d'utiliser un tout, pourquoi ne pas simplement faire de l'électricité statique. Est-ce quelque chose à propos de classes statiques, je ne suis pas arriver. De toute façon, je m'égare
- maintenant, vous pouvez choisir d'utiliser plusieurs indépendante Rng, ou choisissez d'utiliser un fixe de graines si vous souhaitez utiliser la même liste de "aléatoire" des nombres.
- Pensez à la réutilisabilité - vous pensez-vous appeler qu'une seule fois, mais un jour peut-être quelqu'un va appeler votre fonction de 1000 fois, et vous perdez de l'aléatoire. Si vous trouvez instancier la classe ennuyeux, peut-être que C# n'est pas assez bon pour vous 🙂
- Je ne voulais pas l'offenser en aucune façon - il est juste que l'instanciation d'objets est une tâche commune.
- Je voulais dire l'instanciation de cette classe particulière. Pour moi, c'est un peu comme l'instanciation d'DateTime pour se rendre à Maintenant.
- Mais le Hasard n'est pas thread-safe, donc si vous voulez des appels Aléatoires à partir de plusieurs threads qui ne fonctionne pas... en plus de ce que si vous souhaitez que plusieurs graines pour vos Aléatoire des classes? Par exemple je veux utiliser plusieurs threads qui va produire les mêmes résultats lors de chaque exécution, m'oblige à utiliser plusieurs instances de la même graine, avec un statique, il serait une course.
- vous avez droit, il ne l'est pas. Merci pour éclaircir cela. Même si l'appelant "Aléatoire" pour générer les "mêmes résultats" est contraire à l'intuition.
- Il n'est pas rare de vouloir une série de valeurs qui sont imprévisibles mais toujours reproductibles. Je trouve ça assez pratique dans certains de mes tests unitaires.
- J'ai libération qui. Je commentais sur la langue. Désolé, je ne devrais pas plaisanter
- À l'aide d'une seule graine, produit le même résultat ensembles... mais les valeurs au sein de l'ensemble sont "Aléatoires" les uns des autres. Si le nom ne fait sens.
InformationsquelleAutor Kobi

//Function to get random number
private static readonly Random random = new Random();
private static readonly object syncLock = new object();
public static int RandomNumber(int min, int max)
{
    lock(syncLock) { //synchronize
        return random.Next(min, max);
    }
}

Copié directement à partir de

C'est plutôt à éviter miss-utilisation de la classe comme dans Evgeny de réponse. +1 pour citer le code aussi, le crédit où il est dû 🙂

InformationsquelleAutor Pratik Deoghare

6

Ce n'est pas "inutile", parce que le Hasard de la classe des magasins de l'état interne. Il n'a qu'à assurez-vous que si vous appelez .Next() plusieurs fois très rapidement (dans le même ordre de la milliseconde ou tique ou autre), vous ne parvenez toujours pas à obtenir le même nombre.

Bien sûr, si ce n'est pas un problème dans votre cas, vous pouvez toujours combiner ces deux lignes de code en un seul:
```
new Random().Next(1, 100);
```
- il est probablement d'un problème à l'utilisation Aléatoire comme ça...si elle n'est pas, il peut devenir un problème bientôt - si quelqu'un met en œuvre générateur de nombre aléatoire de ce genre car elle est appelée toutes les 50 millisecondes et il fonctionne sans problème, il va se casser très vite dès que le matériel devient plus rapide et quelqu'un va passer BEAUCOUP de temps à mettre au point ce 🙂
- Vrai, je n'avais jamais utiliser ce genre de code dans une boucle, mais si vous savez que votre programme ne doit générer un nombre aléatoire puis c'est assez sûr.
- Oui oui oui, l'utiliser pour obtenir un seul élément. Jamais autrement. Tenté de downvote.
InformationsquelleAutor EMP
5

De MSDN: au Hasard de Classe (Système):

"La génération de nombre aléatoire démarre à partir d'une valeur initiale. Si la même graine est utilisée à plusieurs reprises, la même série de chiffres est généré. Une façon de produire des séquences différentes est de faire la graine valeur dépendant du temps, et de produire ainsi une série différente avec chaque nouvelle instance de Hasard. Par défaut, le constructeur sans paramètre de la classe Aléatoires utilise l'horloge du système pour générer sa valeur de départ, tandis que son constructeur paramétré peut prendre une valeur Int32 sur la base du nombre de tiques dans le temps actuel. Cependant, parce que le temps a fini de résolution, en utilisant le constructeur sans paramètre de créer différents objets au Hasard dans la succession à proximité crée des générateurs de nombres aléatoires que de réaliser des séquences de nombres aléatoires. L'exemple suivant illustre le fait que les deux objets Aléatoires qui sont instanciés dans la succession à proximité de générer un nombre identique de la série de nombres aléatoires..."

Wikipédia explique PRNGs

InformationsquelleAutor
5

Vous déjà eu des réponses ici. Juste réitérant la bonne solution:
```
namespace mySpace
{
    public static class Util
    {
        private static Random rnd = new Random();
        public static int GetRandom()
        {
            return rnd.Next();
        }
    }
}
```
De sorte que vous pouvez appeler:
```
var i = Util.GetRandom();
```
tout au long de. Si vous avez strictement besoin d'un vrai apatrides méthode statique pour générer des nombres aléatoires, vous pouvez compter sur un Guid.
```
public static class Util
{
    public static int GetRandom()
    {
        return Guid.NewGuid().GetHashCode();
    }
}
```
Ça va être un petit peu plus lent, mais peut être beaucoup plus aléatoire que Random.Next, au moins à partir de mon expérience.

Mais pas:
```
new Random(Guid.NewGuid().GetHashCode()).Next();
```
Inutile de création de l'objet va rendre plus lent, surtout en vertu d'une boucle.

Et jamais:
```
new Random().Next();
```
Non seulement ses plus lent (à l'intérieur d'une boucle), c'est de l'aléatoire... eh bien pas vraiment bon selon moi..
- Guid.GetHashCode ne garantit pas la nature de l'aléatoire. C'est un pari pour l'utiliser. Je suppose que c'est ok pour l'envelopper dans un blanchiment des fonctions telles que new Random...
- Je sais Guid.NewGuid est conçu pour l'unicité et pas aléatoire, mais de hachage de celui-ci (Guid.GetHashCode) est assez aléatoire. C'est parce que toutes Guid.GetHashCode est basée sur la représentation de chaîne de Guid. Si vous dites le code de hachage de la mise en œuvre de la chaîne n'est pas documentée et donc le comportement ne peut être garanti, je suis d'accord, mais dans la pratique c'est assez aléatoire, dans le sens qu'il manque un schéma prévisible.
- Votre premier exemple n'est pas thread-safe. En supposant que vous avez plus d'un thread appelant la méthode statique, vous aurez un problème. .Next() n'est pas thread-safe et pourrait feasably jeter un IndexOutOfRange exception en vertu de l'utilisation concomitante.
InformationsquelleAutor nawfal
3

Pourquoi pas?

Vous devez créer une instance parce que la façon dont les nombres aléatoires sont générés, c'est que les réponses précédentes affecter les réponses. Par défaut, le new Random() constructeur utilise le système actuel de temps à la "graine" de la séquence, mais il ne doit pas: vous pouvez passer votre propre numéro si vous le souhaitez. En particulier:
```
var rand = new Random(1234);
Console.WriteLine(rand.Next(0, 100));
Console.WriteLine(rand.Next(0, 100));
Console.WriteLine(rand.Next(0, 100));
Console.WriteLine(rand.Next(0, 100));
```
Va produire la même séquence de "aléatoire" nombre à chaque fois.

Cela signifie que le Random les besoins de la classe de conserver les données d'instance (la réponse précédente, ou "seed") tout autour pour les appels suivants.

InformationsquelleAutor Dean Harding
3

La meilleure façon de le faire est d'avoir un ThreadStatic Random exemple:
```
[ThreadStatic] static Random random;

Random Get() {
 if (random == null) random = new Random(Guid.NewGuid().GetHashCode());
 return random;
}
```
Ce prend soin de tout.
1. La sécurité des threads
2. Performance
3. Pas besoin de semences
Il m'échappe pourquoi l' .NET Framework (et de tout autre cadre sur la terre) ne pas utiliser quelque chose dans cet esprit.
- ThreadStatic (ou ThreadLocal) eux-mêmes engager des frais généraux afin de ne pas prendre soin de "tout".
- C'est vrai... mais c'est tellement moins cher que la création d'une nouvelle instance Aléatoire à chaque fois. Le delta entre ce dernier et de passer un Hasard de référence est assez faible. CoreClr a récemment été modifiée pour faire que cette réponse dit pour avoir aléatoire graines disponibles pour faire des new Random(). @user2864740
- (Je suis en utilisant cette approche qui fonctionne bien et est facile à comprendre; il suffit d'exposer mon pédant de la nature vers l'universel.)
- Je ne suis pas en désaccord avec ce comportement 🙂
InformationsquelleAutor usr
3

La création d'une nouvelle instance de Hasard, puis de l'appel immédiatement à de multiples reprises, par exemple:
```
for (int i = 0; i < 1000; i++)
{
     Random rand = new Random();
     Console.WriteLine(rand.Next(1,100));
}    
```
Vous donnera une distribution qui est orientée vers l'extrémité inférieure de la gamme.

Le faisant de cette manière:
```
Random rand = new Random();
for (int i = 0; i < 1000; i++)
{
     Console.WriteLine(rand.Next(1,100));
}    
```
Vous donnera une meilleure distribution.
- Merci. Ne le savais pas.
InformationsquelleAutor cjk
1

La création d'une courte durée de l'instance en C# est presque gratuit. Ne perdez pas votre temps à vous préoccuper de cela. Vous avez probablement de meilleurs endroits pour chercher la perf ou de la mémoire des gains.
- s'ajoute à de l'agacement facteur
InformationsquelleAutor psychotik
1

Générateurs de nombres aléatoires doit maintenir l'état afin d'être "aléatoire". Le générateur de nombre aléatoire crée une séquence qui est généré en fonction d'un nombre aléatoire. Le problème est que rien ne dans un ordinateur est réellement aléatoire. La chose la plus proche de l'ordinateur est à portée de main est l'horloge du système, c'est effectivement l'heure à laquelle se déroule le processus. Donc par défaut le courant de comptage de cycles de l'horloge système est utilisé. Si votre demande est assez rapide, alors beaucoup de nombre aléatoire des calculs peut se produire dans le même système de tique. Si le générateur de nombre aléatoire ne maintient pas l'état à tous, il permettra de fournir le même nombre aléatoire à plusieurs reprises (même entrée donne le même résultat). Ce n'est généralement pas ce que vous voulez.

Je connais déjà la réponse, mais je dois dire que je préfère utiliser le pattern singleton dans ce cas.

InformationsquelleAutor Jordan

-1

Vous avez besoin de quelque chose de similaire à ceci si vous voulez que la syntaxe que vous mentionnez.

namespace MyRandom
{
    public class Random
    {
        private static m_rand = new Random();
        public static Next(int min, int max)
        {
            return m_rand.Next(min, max);
        }
    }
}

Cela devrait vous permettre de faire Random.Next(1,100); sans avoir à vous soucier de semis.

InformationsquelleAutor LaustN

Vous devez vous connecter pour publier un commentaire.