1

1 つのページ内での個別の操作が異なる結果になることを確認するテストがあります。具体的には、ページを並べ替える方法がいくつかあり、各並べ替えが異なることを確認するテストが必要です。各種類の正確性を確認するために、他のテストがあります。

この会話の焦点は、何をテストするか、またはメソッドをテストすることではなく、テスト操作を並行して実行し、最後に結果を比較する良い方法にあることを望みます。テストにおける並列操作は、興味深いトピックであり、他の人にも役立つ可能性がある十分に広いトピックだと思います。

「generateHashFromSearchResults()」を、現在の IE インスタンスに表示される検索結果の順序を表す文字列を返す関数にします。以下は、1 つのブラウザー インスタンスを使用してシリアル化された方法で作業コードがどのように見えるかです。

var set = new HashSet<string>();
var sortOptions = new List<String>() { "sort1", "sort2", "sort3" };

// Default sort
set.Add(generateHashFromSearchResults());

sortOptions.ForEach(s => {
  ie.Link(Find.ByText(s)).Click();
  set.Add(generateHashFromSearchResults());
});

Assert.That(set.Count() == 4);

数か月前に PLINQ について読んだことがあり、これは適切なユース ケースであると考えていました。ここで、「generateHashFromSearchResults(IE ie)」を同じ関数にしますが、明示的に定義された IE インスタンスで動作します。私はこのようなことを試しました：

List<string> resultList = sortOptions.AsParallel().Select(s => {
  var ie = new IE(true);
  ie.Link(Find.ByText(s)).Click();
  return generateHashFromSearchResults(ie);
}).ToList();

// Forget about default sort for now. There should be 3 distinct results
Assert.That(new HashSet<string>(resultList).Count() == 3);

私が現在直面している最大の問題は、PLINQ がスレッド管理を行う方法を理解していないことです。WatiN は、アパートメントの状態をシングル スレッド (STAThread) に設定して実行する必要があります。各 IE インスタンスは独自のスレッドにある必要がありますが、PLINQ クエリの各スレッドを適切なアパートメント状態に設定しても問題は解決しません。

続行するには PLINQ についてさらに学習する必要があるか、これを機能させるために手動でスレッド管理についてさらに学習する必要があるのではないかと疑い始めています。

何かご意見は？

4

2 に答える 2

2

AsParallel() でカスタム スケジューラを指定することはできません。ただし、並べ替えオプションごとにタスクを作成し、カスタム スケジューラのインスタンスを Start() メソッドに渡すことができます。この STA スレッド スケジューラの実装は、Stephen Toub (http://blogs.msdn.com/b/pfxteam/archive/2010/04/07/9990421.aspx) から借用したものです。

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

/// <summary>
///     Provides a scheduler that uses STA threads.
///     Borrowed from Stephen Toub's implementation http://blogs.msdn.com/b/pfxteam/archive/2010/04/07/9990421.aspx
/// </summary>
public sealed class StaTaskScheduler : TaskScheduler, IDisposable
{
    /// <summary>
    ///     The STA threads used by the scheduler.
    /// </summary>
    private readonly List<Thread> threads;

    /// <summary>
    ///     Stores the queued tasks to be executed by our pool of STA threads.
    /// </summary>
    private BlockingCollection<Task> tasks;

    /// <summary>
    ///     Initializes a new instance of the StaTaskScheduler class with the specified concurrency level.
    /// </summary>
    /// <param name = "numberOfThreads">The number of threads that should be created and used by this scheduler.</param>
    public StaTaskScheduler(int numberOfThreads)
    {
        if (numberOfThreads < 1)
        {
            throw new ArgumentOutOfRangeException(
                "numberOfThreads", "The scheduler must create at least one thread");
        }

        // Initialize the tasks collection
        this.tasks = new BlockingCollection<Task>();

        // Create the threads to be used by this scheduler
        this.threads = Enumerable.Range(0, numberOfThreads).Select(
            i =>
                {
                    var thread = new Thread(
                        () =>
                            {
                                // Continually get the next task and try to execute it.
                                // This will continue until the scheduler is disposed and no more tasks remain.
                                foreach (Task t in this.tasks.GetConsumingEnumerable())
                                {
                                    this.TryExecuteTask(t);
                                }
                            }) {
                                  Name = "Sta Thread", IsBackground = true 
                               };
                    thread.SetApartmentState(ApartmentState.STA);
                    return thread;
                }).ToList();

        // Start all of the threads
        this.threads.ForEach(t => t.Start());
    }

    /// <summary>
    ///     Gets the maximum concurrency level supported by this scheduler.
    /// </summary>
    public override int MaximumConcurrencyLevel
    {
        get
        {
            return this.threads.Count;
        }
    }

    /// <summary>
    ///     Cleans up the scheduler by indicating that no more tasks will be queued.
    ///     This method blocks until all threads successfully shutdown.
    /// </summary>
    public void Dispose()
    {
        if (this.tasks != null)
        {
            // Indicate that no new tasks will be coming in
            this.tasks.CompleteAdding();

            // Wait for all threads to finish processing tasks
            foreach (Thread thread in this.threads)
            {
                thread.Join();
            }

            // Cleanup
            this.tasks.Dispose();
            this.tasks = null;
        }
    }

    /// <summary>
    ///     Provides a list of the scheduled tasks for the debugger to consume.
    /// </summary>
    /// <returns>An enumerable of all tasks currently scheduled.</returns>
    protected override IEnumerable<Task> GetScheduledTasks()
    {
        // Serialize the contents of the blocking collection of tasks for the debugger
        return this.tasks.ToArray();
    }

    /// <summary>
    ///     Queues a Task to be executed by this scheduler.
    /// </summary>
    /// <param name = "task">The task to be executed.</param>
    protected override void QueueTask(Task task)
    {
        // Push it into the blocking collection of tasks
        this.tasks.Add(task);
    }

    /// <summary>
    ///     Determines whether a Task may be inlined.
    /// </summary>
    /// <param name = "task">The task to be executed.</param>
    /// <param name = "taskWasPreviouslyQueued">Whether the task was previously queued.</param>
    /// <returns>true if the task was successfully inlined; otherwise, false.</returns>
    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
    {
        // Try to inline if the current thread is STA
        return Thread.CurrentThread.GetApartmentState() == ApartmentState.STA && this.TryExecuteTask(task);
    }
}
于 2011-06-07T18:00:08.443 に答える
1

たぶん、タスク並列ライブラリを使用する必要がありますか?

私はTPLの初心者ですが、スケジュールされたタスクにSTAThreadを設定するためのオプションがいくつかあるスケジューラがあります。

于 2011-05-18T22:26:23.407 に答える