C# 访问列表c中随机元素的值#

我试图访问列表中随机元素的值。目前，我的代码似乎返回的是元素而不是值

int x = _randMoveDecider.Count;

//makes sure x is never more than the array size
if(x != 0)
  {
    x = x - 1 ;
  }

Random _r = new Random();

_move = _r.Next(_randMoveDecider[x]);

return _randMoveDecider[_move];

目前，如果_randMoveDecider持有值2、5和9，它将返回0、1或2，而不是列表中的值，我哪里出错了

---

[编辑]我想我应该说，randMoveDecider的长度和存储在其中的值随程序的每次运行而变化，但它们始终是整数。

首先，您应该初始化Random一次。将其设置为字段：

private Random _rand = new Random();

---

然后从适当的范围内得到一个随机数。如果（x！=0）是无用的-Next（）返回numbersform首先，您应该初始化Random一次。将其设置为字段：

private Random _rand = new Random();

然后从适当的范围内得到一个随机数。如果（x！=0）是无用的-Next（）返回numbersform那么这个呢

// as a field somewhere so it's initialised once only
public Random _r = new Random();

    // later in your code
var _randList = new List<int>{4,5,8,9};
var _move = _r.Next(_randList.Count);
return _randList[_move];

//作为某个字段，因此仅初始化一次
公共随机_r=新随机（）；
//稍后在代码中
var_randList=新列表{4,5,8,9}；
var\u move=\u r.Next（\u randList.Count）；
返回_randList[_move]；

更妙的是，这里有一些东西可以使任何列表随机化：

public static Random _rand = new Random();

public IEnumerable<T> Randomise<T>(IList<T> list)
{
    while(true)
    {
        // we find count every time since list can change
        // between iterations
        yield return list[_rand.Next(list.Count)];
    }
}

publicstaticrandom\u rand=newrandom（）；
公共IEnumerable随机化（IList列表）
{
while（true）
{
//由于列表可以更改，我们每次都可以找到计数
//迭代之间
收益返回列表[_rand.Next（list.Count）]；
}
}

在您的场景中使用它的一种方法：

// make this a field or something global
public IEnumerbale<int> randomiser = Randomise(_randList);

// then later
return randomiser.First();

//将其设为字段或全局
公共IEnumerbale随机化器=随机化（随机列表）；
//后来
返回randomiser.First（）；

就这个怎么样

// as a field somewhere so it's initialised once only
public Random _r = new Random();

    // later in your code
var _randList = new List<int>{4,5,8,9};
var _move = _r.Next(_randList.Count);
return _randList[_move];

//作为某个字段，因此仅初始化一次
公共随机_r=新随机（）；
//稍后在代码中
var_randList=新列表{4,5,8,9}；
var\u move=\u r.Next（\u randList.Count）；
返回_randList[_move]；

更妙的是，这里有一些东西可以使任何列表随机化：

public static Random _rand = new Random();

public IEnumerable<T> Randomise<T>(IList<T> list)
{
    while(true)
    {
        // we find count every time since list can change
        // between iterations
        yield return list[_rand.Next(list.Count)];
    }
}

publicstaticrandom\u rand=newrandom（）；
公共IEnumerable随机化（IList列表）
{
while（true）
{
//由于列表可以更改，我们每次都可以找到计数
//迭代之间
收益返回列表[_rand.Next（list.Count）]；
}
}

在您的场景中使用它的一种方法：

// make this a field or something global
public IEnumerbale<int> randomiser = Randomise(_randList);

// then later
return randomiser.First();

//将其设为字段或全局
公共IEnumerbale随机化器=随机化（随机列表）；
//后来
返回randomiser.First（）；

只需在主类中添加此扩展类：

public static class Extensions
{
    public static int randomOne(this List<int> theList)
    {
        Random rand = new Random(DateTime.Now.Millisecond);
        return theList[rand.Next(0, theList.Count)];
    }
}

编辑：这是一个测试程序，演示如何使用该方法。请注意，由于不正确使用Random，它会产生非常不平衡的结果，100个“随机”数字中有50多个是相同的

class Program
{
    static void Main(string[] args)
    {
        var myList = Enumerable.Range(0, 100).ToList();
        var myRandoms = myList.Select(v => new { key = v, value = 0 })
                 .ToDictionary(e => e.key, e => e.value);

        for (int i = 0; i < 100; i++)
        {
            var random = myList.RandomOne();
            myRandoms[random]++;
        }

        Console.WriteLine(myRandoms.Values.Max());
        Console.ReadLine();
    }
}

类程序
{
静态void Main（字符串[]参数）
{
var myList=Enumerable.Range（0100.ToList（）；
var myRandoms=myList.Select（v=>new{key=v，value=0}）
.ToDictionary（e=>e.key，e=>e.value）；
对于（int i=0；i<100；i++）
{
var random=myList.RandomOne（）；
myRandoms[随机]+；
}
WriteLine（myRandoms.Values.Max（））；
Console.ReadLine（）；
}
}

要解决此问题，请为扩展类创建随机静态实例或在程序中更广泛地共享。这将在中讨论

公共静态类扩展
{
静态随机兰德=新随机（）；
公共静态int randomOne（此列表）
{
返回列表[rand.Next（0，列表计数）]；
}
}

只需在主类中添加此扩展类：

public static class Extensions
{
    public static int randomOne(this List<int> theList)
    {
        Random rand = new Random(DateTime.Now.Millisecond);
        return theList[rand.Next(0, theList.Count)];
    }
}

编辑：这是一个测试程序，演示如何使用该方法。请注意，由于不正确使用Random，它会产生非常不平衡的结果，100个“随机”数字中有50多个是相同的

class Program
{
    static void Main(string[] args)
    {
        var myList = Enumerable.Range(0, 100).ToList();
        var myRandoms = myList.Select(v => new { key = v, value = 0 })
                 .ToDictionary(e => e.key, e => e.value);

        for (int i = 0; i < 100; i++)
        {
            var random = myList.RandomOne();
            myRandoms[random]++;
        }

        Console.WriteLine(myRandoms.Values.Max());
        Console.ReadLine();
    }
}

类程序
{
静态void Main（字符串[]参数）
{
var myList=Enumerable.Range（0100.ToList（）；
var myRandoms=myList.Select（v=>new{key=v，value=0}）
.ToDictionary（e=>e.key，e=>e.value）；
对于（int i=0；i<100；i++）
{
var random=myList.RandomOne（）；
myRandoms[随机]+；
}
WriteLine（myRandoms.Values.Max（））；
Console.ReadLine（）；
}
}

要解决此问题，请为扩展类创建随机静态实例或在程序中更广泛地共享。这将在中讨论

公共静态类扩展
{
静态随机兰德=新随机（）；
公共静态int randomOne（此列表）
{
返回列表[rand.Next（0，列表计数）]；
}
}

randMoveDecider中有什么？值会更改，但它们始终是整数。randMoveDecider中有什么？值会更改，但它们始终是整数。@yamen No.从文档中“返回一个小于指定最大值的非负随机数”。是的，我刚刚意识到它是最大排他，已删除注释。@yamen No.从文档中“返回小于指定最大值的非负随机数。“是的，我刚刚意识到这是max独家评论，删除了评论。-1。每次创建Random都会返回相同的值，直到时间改变…@AlexeiLevenkov我在第二组代码中修复了这个问题，而不是第一组，现在更新了。这是不值得的。你并没有真正解决这个问题。如果你为2个列表创建了Randomise，并比较结果的“随机化”序列，你会发现几乎所有的时间都是以相同的方式随机化的。您正在为每个列表创建随机初始化，很可能使用相同的种子（如果在大约相同的时间调用，即在下一行调用），结果伪随机序列以很高的概率相同。@AlexeiLevenkov也许您应该看看Randomise是如何构建的，并注意，只要只调用一次，它就只调用

new Random（）

一次。后续的每个调用都在枚举器上，该枚举器只使用

yield

语句。第一个示例也固定为move