我有两个应用程序，一个C ++服务器和一个C＃WPF UI。 C ++代码通过ZeroMQ消息传递[PUB / SUB]服务接收请求（来自任何地方/任何人）。我使用我的C＃代码进行反向测试并创建“反向测试”并执行它们。这些反向测试可以由许多“单元测试”组成，每个测试都从C ++服务器发送/接收数千条消息。
目前，单个背部测试工作正常，可以发送N个单元测试，每个测试都有数千个请求和捕获。我的问题是架构;当我发出另一个回测试（在第一次之后）时，由于轮询线程没有被取消和处理，我得到第二次事件订阅的问题。这导致错误的输出。这可能看起来像一个微不足道的问题（可能是你们中的一些人），但在我当前的配置下取消这个轮询任务证明是麻烦的。一些代码...
我的消息代理类很简单，看起来像
public class MessageBroker : IMessageBroker<Taurus.FeedMux>, IDisposable
{
private Task pollingTask;
private NetMQContext context;
private PublisherSocket pubSocket;
private CancellationTokenSource source;
private CancellationToken token;
private ManualResetEvent pollerCancelled;
public MessageBroker()
{
this.source = new CancellationTokenSource();
this.token = source.Token;
StartPolling();
context = NetMQContext.Create();
pubSocket = context.CreatePublisherSocket();
pubSocket.Connect(PublisherAddress);
}
public void Dispatch(Taurus.FeedMux message)
{
pubSocket.Send(message.ToByteArray<Taurus.FeedMux>());
}
private void StartPolling()
{
pollerCancelled = new ManualResetEvent(false);
pollingTask = Task.Run(() =>
{
try
{
using (var context = NetMQContext.Create())
using (var subSocket = context.CreateSubscriberSocket())
{
byte[] buffer = null;
subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect(SubscriberAddress);
subSocket.Subscribe(String.Empty);
while (true)
{
buffer = subSocket.Receive();
MessageRecieved.Report(buffer.ToObject<Taurus.FeedMux>());
if (this.token.IsCancellationRequested)
this.token.ThrowIfCancellationRequested();
}
}
}
catch (OperationCanceledException)
{
pollerCancelled.Set();
}
}, this.token);
}
private void CancelPolling()
{
source.Cancel();
pollerCancelled.WaitOne();
pollerCancelled.Close();
}
public IProgress<Taurus.FeedMux> MessageRecieved { get; set; }
public string PublisherAddress { get { return "tcp://127.X.X.X:6500"; } }
public string SubscriberAddress { get { return "tcp://127.X.X.X:6501"; } }
private bool disposed = false;
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (this.pollingTask != null)
{
CancelPolling();
if (this.pollingTask.Status == TaskStatus.RanToCompletion ||
this.pollingTask.Status == TaskStatus.Faulted ||
this.pollingTask.Status == TaskStatus.Canceled)
{
this.pollingTask.Dispose();
this.pollingTask = null;
}
}
if (this.context != null)
{
this.context.Dispose();
this.context = null;
}
if (this.pubSocket != null)
{
this.pubSocket.Dispose();
this.pubSocket = null;
}
if (this.source != null)
{
this.source.Dispose();
this.source = null;
}
}
disposed = true;
}
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
~MessageBroker()
{
Dispose(false);
}
}
回溯测试“引擎”用于执行每个后台测试，首先构造一个包含每个Dictionary的{{1}}（单元测试）和每个测试发送到C ++应用程序的消息。
Test方法，此处为
DispatchTests最后的private void DispatchTests(ConcurrentDictionary<Test, List<Taurus.FeedMux>> feedMuxCollection)
{
broker = new MessageBroker();
broker.MessageRecieved = new Progress<Taurus.FeedMux>(OnMessageRecieved);
testCompleted = new ManualResetEvent(false);
try
{
// Loop through the tests.
foreach (var kvp in feedMuxCollection)
{
testCompleted.Reset();
Test t = kvp.Key;
t.Bets = new List<Taurus.Bet>();
foreach (Taurus.FeedMux mux in kvp.Value)
{
token.ThrowIfCancellationRequested();
broker.Dispatch(mux);
}
broker.Dispatch(new Taurus.FeedMux()
{
type = Taurus.FeedMux.Type.PING,
ping = new Taurus.Ping() { event_id = t.EventID }
});
testCompleted.WaitOne(); // Wait until all messages are received for this test.
}
testCompleted.Close();
}
finally
{
broker.Dispose(); // Dispose the broker.
}
}
消息，它告诉C ++我们已经完成了。然后我们强制等待，以便在从C ++代码收到所有返回之前不调度下一个[unit]测试 - 我们使用PING执行此操作。
当C ++收到PING消息时，它会直接发送消息。我们通过ManualResetEvent处理收到的消息，PING告诉我们设置OnMessageRecieved以便我们可以继续进行单元测试; “下一个请”......
ManualResetEvent.Set() 我的问题是，最终上面的。private async void OnMessageRecieved(Taurus.FeedMux mux)
{
string errorMsg = String.Empty;
if (mux.type == Taurus.FeedMux.Type.MSG)
{
// Do stuff.
}
else if (mux.type == Taurus.FeedMux.Type.PING)
{
// Do stuff.
// We are finished reciving messages for this "unit test"
testCompleted.Set();
}
}
永远不会被击中。我很欣赏最终在后台线程上执行的块不能保证执行
上面划掉的文字是由于我弄乱了代码;在孩子完成之前我正在停止父线程。但是，仍有问题...
现在正确调用broker.Dispose()，并调用broker.Dispose()，在此方法中，我尝试取消轮询线程并正确处置broker.Dispose()以避免任何多个订阅。
要取消线程，我使用Task方法
CancelPolling()但是在private void CancelPolling()
{
source.Cancel();
pollerCancelled.WaitOne(); <- Blocks here waiting for cancellation.
pollerCancelled.Close();
}
方法
StartPolling() while (true)
{
buffer = subSocket.Receive();
MessageRecieved.Report(buffer.ToObject<Taurus.FeedMux>());
if (this.token.IsCancellationRequested)
this.token.ThrowIfCancellationRequested();
}
，并且线程永远不会被取消，因此从未正确处理过。 ThrowIfCancellationRequested()方法阻止了轮询器线程。
现在，我不清楚如何实现我想要的，我需要在除了用于轮询消息的线程之外的线程上调用subSocket.Receive() / broker.Dispose()以及一些强制消除。线程中止不是我想要的任何代价。
基本上，我想在执行下一个返回测试之前正确处理PollerCancel()，如何正确处理此问题，拆分轮询并在单独的应用程序域中运行？
我已经尝试过，在broker处理程序内部进行处理，但这显然是在与poller相同的线程上执行的，并且不是这样做的方式，而不调用其他线程，它会阻塞。
实现我想要的最佳方式和是否存在一种模式，我可以遵循这种情况？
感谢您的时间。
答案 0 :(得分：2)
这就是我最终解决这个问题的方法[虽然我愿意接受更好的解决方案！]
public class FeedMuxMessageBroker : IMessageBroker<Taurus.FeedMux>, IDisposable
{
// Vars.
private NetMQContext context;
private PublisherSocket pubSocket;
private Poller poller;
private CancellationTokenSource source;
private CancellationToken token;
private ManualResetEvent pollerCancelled;
/// <summary>
/// Default ctor.
/// </summary>
public FeedMuxMessageBroker()
{
context = NetMQContext.Create();
pubSocket = context.CreatePublisherSocket();
pubSocket.Connect(PublisherAddress);
pollerCancelled = new ManualResetEvent(false);
source = new CancellationTokenSource();
token = source.Token;
StartPolling();
}
#region Methods.
/// <summary>
/// Send the mux message to listners.
/// </summary>
/// <param name="message">The message to dispatch.</param>
public void Dispatch(Taurus.FeedMux message)
{
pubSocket.Send(message.ToByteArray<Taurus.FeedMux>());
}
/// <summary>
/// Start polling for messages.
/// </summary>
private void StartPolling()
{
Task.Run(() =>
{
using (var subSocket = context.CreateSubscriberSocket())
{
byte[] buffer = null;
subSocket.Options.ReceiveHighWatermark = 1000;
subSocket.Connect(SubscriberAddress);
subSocket.Subscribe(String.Empty);
subSocket.ReceiveReady += (s, a) =>
{
buffer = subSocket.Receive();
if (MessageRecieved != null)
MessageRecieved.Report(buffer.ToObject<Taurus.FeedMux>());
};
// Poll.
poller = new Poller();
poller.AddSocket(subSocket);
poller.PollTillCancelled();
token.ThrowIfCancellationRequested();
}
}, token).ContinueWith(ant =>
{
pollerCancelled.Set();
}, TaskContinuationOptions.OnlyOnCanceled);
}
/// <summary>
/// Cancel polling to allow the broker to be disposed.
/// </summary>
private void CancelPolling()
{
source.Cancel();
poller.Cancel();
pollerCancelled.WaitOne();
pollerCancelled.Close();
}
#endregion // Methods.
#region Properties.
/// <summary>
/// Event that is raised when a message is recived.
/// </summary>
public IProgress<Taurus.FeedMux> MessageRecieved { get; set; }
/// <summary>
/// The address to use for the publisher socket.
/// </summary>
public string PublisherAddress { get { return "tcp://127.0.0.1:6500"; } }
/// <summary>
/// The address to use for the subscriber socket.
/// </summary>
public string SubscriberAddress { get { return "tcp://127.0.0.1:6501"; } }
#endregion // Properties.
#region IDisposable Members.
private bool disposed = false;
/// <summary>
/// Dispose managed resources.
/// </summary>
/// <param name="disposing">Is desposing.</param>
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
CancelPolling();
if (pubSocket != null)
{
pubSocket.Disconnect(PublisherAddress);
pubSocket.Dispose();
pubSocket = null;
}
if (poller != null)
{
poller.Dispose();
poller = null;
}
if (context != null)
{
context.Terminate();
context.Dispose();
context = null;
}
if (source != null)
{
source.Dispose();
source = null;
}
}
// Shared cleanup logic.
disposed = true;
}
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
/// <summary>
/// Finalizer.
/// </summary>
~FeedMuxMessageBroker()
{
Dispose(false);
}
#endregion // IDisposable Members.
}
因此我们以相同的方式进行轮询，但使用NetMQ中的Poller类。在我们设置的任务延续中，我们确保取消Poller和Task。我们可以安全地处置......
答案 1 :(得分：1)
您致力于创建测试框架的重点和努力表明您的意志旨在开发严谨和专业级的方法，这使我首先对这种勇敢的承诺表示敬意。
虽然测试是提供合理定量证据的重要活动，但被测系统正在满足定义的期望，但这取决于测试环境与实际部署条件的接近程度。
有人可能会同意，在另一个不同的基础上进行测试并不能证明真实部署会在环境中按预期运行，这主要与测试的部署不同。
您的努力（至少在发布OP时）专注于代码体系结构，它试图将实例保留在原位并尝试在下一次测试电池启动之前重新设置Poller实例的内部状态
在我看来，如果您努力进行专业测试，测试有一些原则可以遵循：
测试重复性原则（测试＆＃39;重新运行应该提供相同的结果，从而避免提供仅提供结果的准测试 - ＆＃34;彩票＆＃34 ;）
非干预测试原则（测试＆＃39;重新运行不应受＆＃34;外部＆＃34; - 干扰，不受测试场景控制）
话虽如此，让我带来一些由Harry Markowitz启发的笔记，这是诺贝尔奖得主因其卓越的定量投资组合优化研究而获奖。
CACI Simulations，Inc。（Harry Markowitz的公司之一）在90年代早期开发了他们的旗舰软件框架COMET III - 一个非常强大的模拟引擎，用于大型，复杂的设计 - 原型设计和流程性能模拟在大型计算/网络/电信网络中运营。
COMET III给人留下最深刻的印象是它能够产生测试场景，包括可配置的预测试和预热＆＃34;预载荷使得被测元件进入类似于疲劳状态的状态。在机械酷刑试验实验中，或氢扩散脆性对核电厂冶金学家意味着什么。
是的，一旦你进入关于算法，节点缓冲区，内存分配，管道/负载均衡/网格处理架构选择，故障恢复开销，垃圾收集策略和有限资源的低级细节共享算法的工作和影响（在实际工作负载模式和＃34;压力＆＃34;）端到端性能/延迟，这个功能是必不可少的。
这意味着，单个与实例相关的简单状态控制是不够的，因为它不提供测试可重复性和测试隔离/非干预行为的手段。简单地说，即使你找到了一种方法来重置＆＃34;一个Poller实例，这不会让你进入真实的测试，保证测试可重复性，并且可以进行预测试预热。
需要后退和更高层的抽象和测试场景控制。