Question

我使用PLINQ运行测试串口的功能，以确定它们是否是GPS设备。

立即发现某些串口是有效的GPS。在这种情况下，我希望第一个完成测试是返回的测试。我不想等待剩下的结果。

我可以使用PLINQ执行此操作，还是必须安排一批任务并等待一个人返回？

Answer 1

PLINQ在这里可能不够。虽然您可以在.NET 4中使用.First，但这会导致它按顺序运行，这会破坏目的。（请注意，这是will be improved in .NET 4.5。）

但是，TPL很可能是正确答案。您可以为每个串行端口创建Task<Location>，然后使用Task.WaitAny等待第一次成功操作。

这提供了一种简单的方法来安排一堆“任务”，然后只使用第一个结果。

Answer 2

进一步审核后，您显然可以使用FirstOrDefault来解决此问题。默认情况下，PLINQ不会保留排序，并且使用无缓冲的查询将立即返回。

http://msdn.microsoft.com/en-us/library/dd460677.aspx

Answer 3

过去几天我一直在考虑这个问题，而且在C＃4.0中找不到内置的PLINQ方法。使用 FirstOrDefault 这个问题的公认答案在完整的PLINQ查询完成后仍然不返回值，并且仍然返回（有序的）第一个结果。以下极端示例显示了该行为：

var cts = new CancellationTokenSource();
var rnd = new ThreadLocal<Random>(() => new Random());

var q = Enumerable.Range(0, 11).Select(x => x).AsParallel()
    .WithCancellation(cts.Token).WithMergeOptions( ParallelMergeOptions.NotBuffered).WithDegreeOfParallelism(10).AsUnordered()
    .Where(i => i % 2 == 0 )
    .Select( i =>
    {
        if( i == 0 )
            Thread.Sleep(3000);
        else
            Thread.Sleep(rnd.Value.Next(50, 100));
        return string.Format("dat {0}", i).Dump();
    });

cts.CancelAfter(5000);

// waits until all results are in, then returns first
q.FirstOrDefault().Dump("result");

我没有看到立即获得第一个可用结果的内置方法，但我能够提出两个解决方法。

第一个创建任务来完成工作并返回任务，从而快速完成PLINQ查询。生成的任务可以传递给WaitAny，以便在第一个结果可用时立即获得：

var cts = new CancellationTokenSource();
var rnd = new ThreadLocal<Random>(() => new Random());

var q = Enumerable.Range(0, 11).Select(x => x).AsParallel()
    .WithCancellation(cts.Token).WithMergeOptions( ParallelMergeOptions.NotBuffered).WithDegreeOfParallelism(10).AsUnordered()
    .Where(i => i % 2 == 0 )
    .Select( i =>
    {
        return Task.Factory.StartNew(() =>
        {
        if( i == 0 )
            Thread.Sleep(3000);
        else
            Thread.Sleep(rnd.Value.Next(50, 100));
        return string.Format("dat {0}", i).Dump();
        });
    });

cts.CancelAfter(5000);

// returns as soon as the tasks are created
var ts = q.ToArray();

// wait till the first task finishes
var idx = Task.WaitAny( ts );
ts[idx].Result.Dump("res");

这可能是一种可怕的方式。由于PLINQ查询的实际工作只是一个非常快的Task.Factory.StartNew，因此完全使用PLINQ毫无意义。 IEnumerable上的简单 .Select( i => Task.Factory.StartNew( ... 更清晰，可能更快。

第二种解决方法使用队列（BlockingCollection），只需在计算完成后将结果插入此队列：

var cts = new CancellationTokenSource();
var rnd = new ThreadLocal<Random>(() => new Random());

var q = Enumerable.Range(0, 11).Select(x => x).AsParallel()
    .WithCancellation(cts.Token).WithMergeOptions( ParallelMergeOptions.NotBuffered).WithDegreeOfParallelism(10).AsUnordered()
    .Where(i => i % 2 == 0 )
    .Select( i =>
    {
        if( i == 0 )
            Thread.Sleep(3000);
        else
            Thread.Sleep(rnd.Value.Next(50, 100));
        return string.Format("dat {0}", i).Dump();
    });

cts.CancelAfter(5000);

var qu = new BlockingCollection<string>();

// ForAll blocks until PLINQ query is complete
Task.Factory.StartNew(() => q.ForAll( x => qu.Add(x) ));

// get first result asap
qu.Take().Dump("result");

使用此方法，使用PLINQ完成工作，并且BlockingCollecion的Take（）将在PLINQ查询插入后立即返回第一个结果。

虽然这会产生预期的结果，但我不确定它是否比使用更简单的Tasks + WaitAny更有优势

Answer 4

使用.NET 4.0中的PLINQ完全实现此目的：

SerialPorts.                        // Your IEnumerable of serial ports
    AsParallel().AsUnordered().     // Run as an unordered parallel query
    Where(IsGps).                   // Matching the predicate IsGps (Func<SerialPort, bool>)
    Take(1).                        // Taking the first match
    FirstOrDefault();               // And unwrap it from the IEnumerable (or null if none are found

关键是不要使用像First或FirstOrDefault这样的有序评估，直到你指定只需要找到一个。

并行Linq - 返回第一个返回的结果

4 个答案: