/// <summary>Initializes the IOCompletionPortTaskScheduler.</summary>
/// <param name="maxConcurrencyLevel">The maximum number of threads in the scheduler to be executing concurrently.</param>
/// <param name="numAvailableThreads">The number of threads to have available in the scheduler for executing tasks.</param>
public IOCompletionPortTaskScheduler(int maxConcurrencyLevel, int numAvailableThreads)
{
// Validate arguments
if (maxConcurrencyLevel < 1) throw new ArgumentNullException("maxConcurrencyLevel");
if (numAvailableThreads < 1) throw new ArgumentNullException("numAvailableThreads");
m_tasks = new ConcurrentQueue<Task>();
m_iocp = new IOCompletionPort(maxConcurrencyLevel);
m_schedulerThread = new ThreadLocal<bool>();
m_remainingThreadsToShutdown = new CountdownEvent(numAvailableThreads);
// Create and start the threads
for (int i = 0; i < numAvailableThreads; i++)
{
new Thread(() =>
{
try
{
// Note that this is a scheduler thread. Used for inlining checks.
m_schedulerThread.Value = true;
// Continually wait on the I/O completion port until
// there's a work item, then process it.
while (m_iocp.WaitOne())
{
Task next;
if (m_tasks.TryDequeue(out next)) TryExecuteTask(next);
}
}
finally { m_remainingThreadsToShutdown.Signal(); }
}) { IsBackground = true }.Start();
}
}
public void IOCompletionPortConstructorTest()
{
int maxConcurrency = 0; // TODO: 初始化为适当的值
IOCompletionPort target = new IOCompletionPort(maxConcurrency);
Assert.Inconclusive("TODO: 实现用来验证目标的代码");
}
public void DisposeTest()
{
int maxConcurrency = 0; // TODO: 初始化为适当的值
IOCompletionPort target = new IOCompletionPort(maxConcurrency); // TODO: 初始化为适当的值
target.Dispose();
Assert.Inconclusive("无法验证不返回值的方法。");
}
/// <summary>
/// Initializes the IOCompletionPortTaskScheduler.
/// </summary>
/// <param name="maxConcurrencyLevel">The maximum number of threads in the scheduler to be executing concurrently.</param>
/// <param name="numAvailableThreads">The number of threads to have available in the scheduler for executing tasks.</param>
public IOCompletionPortTaskScheduler(int maxConcurrencyLevel, int numAvailableThreads)
{
// Validate arguments
if (maxConcurrencyLevel < 1)
{
throw new ArgumentNullException("maxConcurrencyLevel");
}
if (numAvailableThreads < 1)
{
throw new ArgumentNullException("numAvailableThreads");
}
_tasks = new ConcurrentQueue <Task>();
_iocp = new IOCompletionPort(maxConcurrencyLevel);
_schedulerThread = new ThreadLocal <bool>();
_remainingThreadsToShutdown = new CountdownEvent(numAvailableThreads);
// Create and start the threads
for (int i = 0; i < numAvailableThreads; i++)
{
new Thread(() =>
{
try
{
// Note that this is a scheduler thread. Used for inlining checks.
_schedulerThread.Value = true;
// Continually wait on the I/O completion port until
// there's a work item, then process it.
while (_iocp.WaitOne())
{
Task next;
if (_tasks.TryDequeue(out next))
{
TryExecuteTask(next);
}
}
}
finally
{
_remainingThreadsToShutdown.Signal();
}
})
{
IsBackground = true
}.Start();
}
}
public void GetStatusTest()
{
int maxConcurrency = 0; // TODO: 初始化为适当的值
IOCompletionPort target = new IOCompletionPort( maxConcurrency ); // TODO: 初始化为适当的值
int iMilliseconds = 0; // TODO: 初始化为适当的值
bool bTimedOut = false; // TODO: 初始化为适当的值
bool bTimedOutExpected = false; // TODO: 初始化为适当的值
WaitCallback waitCallback = null; // TODO: 初始化为适当的值
WaitCallback waitCallbackExpected = null; // TODO: 初始化为适当的值
object oState = null; // TODO: 初始化为适当的值
object oStateExpected = null; // TODO: 初始化为适当的值
target.GetStatus( iMilliseconds, out bTimedOut, out waitCallback, out oState );
Assert.AreEqual( bTimedOutExpected, bTimedOut );
Assert.AreEqual( waitCallbackExpected, waitCallback );
Assert.AreEqual( oStateExpected, oState );
Assert.Inconclusive( "无法验证不返回值的方法。" );
}
/// <summary>Initializes the IOCompletionPortTaskScheduler.</summary>
/// <param name="maxConcurrencyLevel">The maximum number of threads in the scheduler to be executing concurrently.</param>
/// <param name="numAvailableThreads">The number of threads to have available in the scheduler for executing tasks.</param>
public IOCompletionPortTaskScheduler(int maxConcurrencyLevel, int numAvailableThreads)
{
ThreadStart start = null;
if (maxConcurrencyLevel < 1)
{
throw new ArgumentNullException("maxConcurrencyLevel");
}
if (numAvailableThreads < 1)
{
throw new ArgumentNullException("numAvailableThreads");
}
this.m_tasks = new ConcurrentQueue <Task>();
this.m_iocp = new IOCompletionPort(maxConcurrencyLevel);
this.m_schedulerThread = new ThreadLocal <bool>();
this.m_remainingThreadsToShutdown = new CountdownEvent(numAvailableThreads);
for (int i = 0; i < numAvailableThreads; i++)
{
if (start == null)
{
start = delegate {
try
{
this.m_schedulerThread.Value = true;
while (this.m_iocp.WaitOne())
{
Task task;
if (this.m_tasks.TryDequeue(out task))
{
base.TryExecuteTask(task);
}
}
}
finally
{
this.m_remainingThreadsToShutdown.Signal();
}
};
}
new Thread(start)
{
IsBackground = true
}.Start();
}
}
public void GetStatusTest()
{
int maxConcurrency = 0; // TODO: 初始化为适当的值
IOCompletionPort target = new IOCompletionPort(maxConcurrency); // TODO: 初始化为适当的值
int iMilliseconds = 0; // TODO: 初始化为适当的值
bool bTimedOut = false; // TODO: 初始化为适当的值
bool bTimedOutExpected = false; // TODO: 初始化为适当的值
WaitCallback waitCallback = null; // TODO: 初始化为适当的值
WaitCallback waitCallbackExpected = null; // TODO: 初始化为适当的值
object oState = null; // TODO: 初始化为适当的值
object oStateExpected = null; // TODO: 初始化为适当的值
target.GetStatus(iMilliseconds, out bTimedOut, out waitCallback, out oState);
Assert.AreEqual(bTimedOutExpected, bTimedOut);
Assert.AreEqual(waitCallbackExpected, waitCallback);
Assert.AreEqual(oStateExpected, oState);
Assert.Inconclusive("无法验证不返回值的方法。");
}
public void IOCompletionPortConstructorTest()
{
int maxConcurrency = 0; // TODO: 初始化为适当的值
IOCompletionPort target = new IOCompletionPort( maxConcurrency );
Assert.Inconclusive( "TODO: 实现用来验证目标的代码" );
}
public void DisposeTest()
{
int maxConcurrency = 0; // TODO: 初始化为适当的值
IOCompletionPort target = new IOCompletionPort( maxConcurrency ); // TODO: 初始化为适当的值
target.Dispose();
Assert.Inconclusive( "无法验证不返回值的方法。" );
}
