如何用 RandomOrDefault 之类的东西替换 FirstOrDefault 以“平衡”调用？

Question

我有这样的代码

    senders.FirstOrDefault(sender => !sender.IsBusy);

这条线经常被调用。

问题是它总是返回第一个不忙的sender；经常返回相同的第一个发件人，但很少返回最后一个发件人。如何轻松平衡？

理想情况下，在每次通话时，我都应该返回最不常用的发件人。 IE。在所有非忙碌发件人之间选择在最后一秒内被选中次数最少的发件人。

Answer 1

可能是这样的：

public static T RandomOrDefault<T>(this IEnumerable<T> dataSet)
{ 
    return dataSet.RandomOrDefault(y => true);
}

public static T RandomOrDefault<T>(this IEnumerable<T> dataSet, Func<T, bool> filter)
{
    var elems = dataSet.Where(filter).ToList();
    var count = elems.Count;
    if (count == 0)
    {
        return default(T);
    }
    var random = new Random();
    var index = random.Next(count - 1);
    return elems[index];
}

然后你可以调用它：

senders.RandomOrDefault(sender => !sender.IsBusy);

Answer 2

如果您想有效地获得最少使用的一个，您可能会很好地使用以下非 Linq“列表轮换”解决方案，它是 O(n) 效率和 O(1) 空间，与大多数其他解决方案不同：

// keep track of these
List<Sender> senders;
int nSelected = 0;          // number of already selected senders

// ...

// solution
int total = senders.Count;  // total number of senders
// looking for next non-busy sender
Sender s = null;
for (int i = 0; i < total; i++)
{
    int ind = (i + nSelected) % total; // getting the one 'after' previous
    if (!senders[ind].IsBusy)
    {
        s = senders[ind];
        ++nSelected;
        break;
    }
}

当然，这会在 senders 容器上添加必须可索引的约束。

Answer 3

您可以通过新的 Guid 轻松地重新排序，如下所示：

senders.Where(sender => !sender.IsBusy).OrderBy(x => Guid.NewGuid()).FirstOrDefault();

您不必弄乱随机数字，也不必为这些数字确定“范围”。我认为它很简单，而且非常优雅。

Answer 4

您可以在 FirstOrDefault 之前使用 this post 中的“Shuffle”扩展方法

Answer 5

您可以使用一个随机数小于非忙碌发件人总数的跳过。

senders.Where(sender => !sender.IsBusy).Skip(randomNumber).FirstOrDefault();

虽然确定随机数的合理限制可能有点棘手。

Answer 6

查找您使用过的发件人及其使用时间。

var recentlyUsed = new Dictionary<Sender, DateTime>();
var sender = senders.FirstOrDefault(sender => !sender.IsBusy && (!recentlyUsed.ContainsKey(sender) || recentlyUsed[sender] < DateTime.Now.AddSeconds(-1)));
if (sender != null)
    recentlyUsed[sender] = DateTime.Now;

Answer 7

基于the "Real world functional programming" book 的算法，这里是从 IEnumearble 获取随机值或默认值的扩展方法的 O(n) 实现。

public static class SampleExtensions
{
    // The Random class is instantiated as singleton 
    // because it would give bad random values 
    // if instantiated on every call to RandomOrDefault method
    private static readonly Random RandomGenerator = new Random(unchecked((int)DateTime.Now.Ticks));

    public static T RandomOrDefault<T>(this IEnumerable<T> source, Func<T, bool> predicate)
    {
        IEnumerable<T> filtered = source.Where(predicate);

        int count = 0;
        T selected = default(T);
        foreach (T current in filtered)
        {
            if (RandomGenerator.Next(0, ++count) == 0)
            {
                selected = current;
            }
        }

        return selected;
    }

    public static T RandomOrDefault<T>(this IEnumerable<T> source)
    {
        return RandomOrDefault(source, element => true);
    }
}

这是确保该算法真正给出均匀分布的代码：

[Test]
public void TestRandom()
{
    IEnumerable<int> source = Enumerable.Range(1, 10);
    Dictionary<int, int> result = source.ToDictionary(element => element, element => 0);
    result[0] = 0;

    const int Limit = 1000000;
    for (int i = 0; i < Limit; i++)
    {
        result[source.RandomOrDefault()]++;
    }

    foreach (var pair in result)
    {
        Console.WriteLine("{0}: {1:F2}%", pair.Key, pair.Value * 100f / Limit);
    }

    Console.WriteLine(Enumerable.Empty<int>().RandomOrDefault());
}

TestRandom 方法的输出是：

1: 9,92%
2: 10,03%
3: 10,04%
4: 9,99%
5: 10,00%
6: 10,01%
7: 9,98%
8: 10,03%
9: 9,97%
10: 10,02%
0: 0,00%
0