Comment accéder à un élément aléatoire dans la liste?

J'ai une ArrayList, et je dois pouvoir cliquer sur un bouton, puis choisir au hasard une chaîne de cette liste et l'afficher dans une boîte de message.

Comment pourrais-je procéder?

1. Créez une instance de Randomclasse quelque part. Notez qu'il est assez important de ne pas créer une nouvelle instance chaque fois que vous avez besoin d'un nombre aléatoire. Vous devez réutiliser l'ancienne instance pour obtenir l'uniformité des nombres générés. Vous pouvez avoir un staticchamp quelque part (faites attention aux problèmes de sécurité des threads):

   static Random rnd = new Random();

2. Demandez à l' Randominstance de vous donner un nombre aléatoire avec le maximum du nombre d'articles dans ArrayList:

   int r = rnd.Next(list.Count);

3. Affichez la chaîne:

   MessageBox.Show((string)list[r]);

J'utilise généralement cette petite collection de méthodes d'extension:

public static class EnumerableExtension
{
    public static T PickRandom<T>(this IEnumerable<T> source)
    {
        return source.PickRandom(1).Single();
    }

    public static IEnumerable<T> PickRandom<T>(this IEnumerable<T> source, int count)
    {
        return source.Shuffle().Take(count);
    }

    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source)
    {
        return source.OrderBy(x => Guid.NewGuid());
    }
}

Pour une liste fortement typée, cela vous permettrait d'écrire:

var strings = new List<string>();
var randomString = strings.PickRandom();

Si tout ce que vous avez est une ArrayList, vous pouvez le lancer:

var strings = myArrayList.Cast<string>();

Tu peux faire:

list.OrderBy(x => Guid.NewGuid()).FirstOrDefault()

Créez une Randominstance:

Random rnd = new Random();

Récupère une chaîne aléatoire:

string s = arraylist[rnd.Next(arraylist.Count)];

N'oubliez pas cependant que si vous le faites fréquemment, vous devez réutiliser l' Randomobjet. Mettez-le en tant que champ statique dans la classe afin qu'il ne soit initialisé qu'une seule fois, puis accédez-y.

Ou une classe d'extension simple comme celle-ci:

public static class CollectionExtension
{
    private static Random rng = new Random();

    public static T RandomElement<T>(this IList<T> list)
    {
        return list[rng.Next(list.Count)];
    }

    public static T RandomElement<T>(this T[] array)
    {
        return array[rng.Next(array.Length)];
    }
}

Ensuite, appelez simplement:

myList.RandomElement();

Fonctionne également pour les tableaux.

J'éviterais d'appeler OrderBy()car cela peut coûter cher pour les grandes collections. Utilisez des collections indexées comme List<T>ou des tableaux à cet effet.

Pourquoi pas:

public static T GetRandom<T>(this IEnumerable<T> list)
{
   return list.ElementAt(new Random(DateTime.Now.Millisecond).Next(list.Count()));
}

ArrayList ar = new ArrayList();
        ar.Add(1);
        ar.Add(5);
        ar.Add(25);
        ar.Add(37);
        ar.Add(6);
        ar.Add(11);
        ar.Add(35);
        Random r = new Random();
        int index = r.Next(0,ar.Count-1);
        MessageBox.Show(ar[index].ToString());

J'utilise cette ExtensionMethod depuis un certain temps:

public static IEnumerable<T> GetRandom<T>(this IEnumerable<T> list, int count)
{
    if (count <= 0)
      yield break;
    var r = new Random();
    int limit = (count * 10);
    foreach (var item in list.OrderBy(x => r.Next(0, limit)).Take(count))
      yield return item;
}

Je suggère une approche différente.Si l'ordre des éléments dans la liste n'est pas important lors de l'extraction (et que chaque élément ne doit être sélectionné qu'une seule fois), Listvous pouvez utiliser unConcurrentBag qui est une collection non ordonnée de thread-safe objets:

var bag = new ConcurrentBag<string>();
bag.Add("Foo");
bag.Add("Boo");
bag.Add("Zoo");

Le gestionnaire d'événements:

string result;
if (bag.TryTake(out result))
{
    MessageBox.Show(result);
}

Le TryTaketentera d'extraire un objet "aléatoire" de la collection non ordonnée.

J'avais besoin de plus d'articles au lieu d'un seul. J'ai donc écrit ceci:

public static TList GetSelectedRandom<TList>(this TList list, int count)
       where TList : IList, new()
{
    var r = new Random();
    var rList = new TList();
    while (count > 0 && list.Count > 0)
    {
        var n = r.Next(0, list.Count);
        var e = list[n];
        rList.Add(e);
        list.RemoveAt(n);
        count--;
    }

    return rList;
}

Avec cela, vous pouvez obtenir des éléments combien vous voulez comme au hasard comme ceci:

var _allItems = new List<TModel>()
{
    // ...
    // ...
    // ...
}

var randomItemList = _allItems.GetSelectedRandom(10); 

Impression aléatoire du nom du pays à partir du fichier JSON.
Modèle:

public class Country
    {
        public string Name { get; set; }
        public string Code { get; set; }
    }

Implémentation:

string filePath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, @"..\..\..\")) + @"Data\Country.json";
            string _countryJson = File.ReadAllText(filePath);
            var _country = JsonConvert.DeserializeObject<List<Country>>(_countryJson);


            int index = random.Next(_country.Count);
            Console.WriteLine(_country[index].Name);

Pourquoi pas [2]:

public static T GetRandom<T>(this List<T> list)
{
     return list[(int)(DateTime.Now.Ticks%list.Count)];
}