Wie greife ich auf zufällige Elemente in der Liste zu?

Ich habe eine ArrayList und muss in der Lage sein, auf eine Schaltfläche zu klicken und dann zufällig eine Zeichenfolge aus dieser Liste auszuwählen und in einer Nachrichtenbox anzuzeigen.

Wie würde ich das machen?

1. Erstellen Sie Randomirgendwo eine Instanz der Klasse. Beachten Sie, dass es ziemlich wichtig ist, nicht jedes Mal eine neue Instanz zu erstellen, wenn Sie eine Zufallszahl benötigen. Sie sollten die alte Instanz wiederverwenden, um eine Einheitlichkeit der generierten Zahlen zu erreichen. Sie können staticirgendwo ein Feld haben (seien Sie vorsichtig bei Thread-Sicherheitsproblemen):

   static Random rnd = new Random();

2. Bitten Sie die RandomInstanz, eine Zufallszahl mit dem Maximum der Anzahl der Elemente in ArrayList:

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

3. Zeigen Sie die Zeichenfolge an:

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

Normalerweise verwende ich diese kleine Sammlung von Erweiterungsmethoden:

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());
    }
}

Bei einer stark typisierten Liste können Sie Folgendes schreiben:

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

Wenn Sie nur eine ArrayList haben, können Sie diese umwandeln:

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

Du kannst tun:

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

Erstellen Sie eine RandomInstanz:

Random rnd = new Random();

Holen Sie sich eine zufällige Zeichenfolge:

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

Denken Sie jedoch daran, dass Sie das RandomObjekt wiederverwenden sollten, wenn Sie dies häufig tun . Fügen Sie es als statisches Feld in die Klasse ein, sodass es nur einmal initialisiert wird, und greifen Sie dann darauf zu.

Oder eine einfache Erweiterungsklasse wie diese:

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)];
    }
}

Dann rufen Sie einfach an:

myList.RandomElement();

Funktioniert auch für Arrays.

Ich würde es vermeiden, anzurufen, OrderBy()da dies für größere Sammlungen teuer sein kann. Verwenden Sie List<T>zu diesem Zweck indizierte Sammlungen wie oder Arrays.

Warum nicht:

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());

Ich benutze diese ExtensionMethod seit einer Weile:

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;
}

Ich werde anderen Ansatz vorschlagen, wenn die Reihenfolge der Elemente in der Liste bei der Extraktion nicht wichtig ist (und jedes Element nur einmal gewählt werden), dann anstelle eines Listkann man ein verwenden , ConcurrentBagdie eine Thread-sicher ist, ungeordnete Sammlung von Objekte:

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

Der EventHandler:

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

Der TryTakeversucht, ein "zufälliges" Objekt aus der ungeordneten Sammlung zu extrahieren.

Ich brauchte mehr Artikel als nur einen. Also schrieb ich Folgendes:

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;
}

Mit dieser Option können Sie beliebig viele Elemente abrufen:

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

var randomItemList = _allItems.GetSelectedRandom(10); 

Drucken eines zufälligen Ländernamens aus einer JSON-Datei.
Modell:

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

Implementierung:

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);

Warum nicht [2]:

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