2

我正在编写一个工具，它使用户能够通过更改设置然后流式传输信息来与一些硬件进行交互。

为此，我运行了几个线程：EquipmentInterface它们DataProcessor通过Queue.

该EquipmentInterface线程具有更改设备设置的方法（例如），并将结果信息（和Rotate）添加到. 一旦设置正确，就会有方法，一旦开始流式传输，来自设备的数据就会被打包并添加到队列中。RefocusCurrentAngleCurrentFocalDistanceQueueStartStreamingStopStreaming

放置在队列上的所有信息都来自一个BaseMessage包含消息类型指示的类。然后，我导出了角度、焦距、开始和结束流媒体的消息类型，当然还有数据本身。

监听队列的DataProcessor另一端并根据当前角度/焦距处理后续数据。

现在，问题是，我在数据处理器中有一个函数，它使用 switch 语句对传入的消息进行类型检查。然后将这些消息向下转换为适当的类型并传递给适当的处理程序。实际上，不只是一个 DataProcessor 监听一个队列，而是多个队列上的多个监听器（一些存储到磁盘，一些在 gui 上显示信息）。每次我添加一些信息时，我都必须创建一个新的BaseMessage派生类，向该基类添加一个新类型，然后更新每个消费者中的 switch 语句以处理新消息。

这种架构的某些东西让我觉得不对劲，最近我读了很多关于向下转换的文章。从我所见，普遍的共识似乎是我正在做的是一种糟糕的代码气味。我看到了一个使用 Boost 的建议，但它们看起来并不比我的 switch 语句更干净（也许我遗漏了一些东西？）。

所以我的问题是：我是否应该尝试避免使用 switch-statement / downcasting 解决方案，如果是，如何？

我的实现是在 C++/CLI 中，所以 .net 或 C++ 解决方案都是我所追求的。

编辑- 根据 iammilind 和 stfaanv 的评论，您是否建议这样做：

class QueuedItem
{
public:
    QueuedItem() { }
    virtual ~QueuedItem() { }

};

class Angle : public QueuedItem
{
public:
    Angle() {}
    virtual ~Angle() { }
};

class FocalLength : public QueuedItem
{
public:
    FocalLength() {}
    virtual ~FocalLength() { }
private:

};


class EquipmentHandler
{
protected:
    virtual void ProcessAngle(Angle* angle) {}; 
    virtual void ProcessFocalLength(FocalLength* focalLength) {};   

public:
    void ProcessMessages(QueuedItem* item)
    {
        Angle* pAngle = dynamic_cast<Angle*>(item);
        if( pAngle != NULL )
        {
            ProcessAngle(pAngle);
        }
        FocalLength* pFocalLength = dynamic_cast<FocalLength*>(item);
        if( pFocalLength != NULL )
        {
            ProcessFocalLength(pFocalLength);
        }

    }
};

class MyDataProcessor : public EquipmentHandler
{
protected:
    virtual void ProcessAngle(Angle* angle) override { printf("Processing Angle"); }
    virtual void ProcessFocalLength(FocalLength* focalLength) override { printf("Processing FocalLength"); };   
};


int _tmain(int argc, _TCHAR* argv[])
{

    // Equipment interface thread...
    FocalLength* f = new FocalLength();
    QueuedItem* item = f; // This gets stuck onto the queue

    // ...DataProcessor thread (after dequeuing)
    QueuedItem* dequeuedItem = item;

    // Example of a DataProcessor implementation.
    // In reality, this would 
    MyDataProcessor dataProc;
    dataProc.ProcessMessages(dequeuedItem);

    return 0;
}

...可以简化吗？感觉有点笨拙，ProcessMessages但这是我能看到的唯一方法，没有 switch 语句和基类中的某种枚举消息类型标识符。

4

3 回答 3

2

您可以尝试访问者设计模式：http ://en.wikipedia.org/wiki/Visitor_pattern

每个 DataProcessor 都将继承自一个BaseVisitor类，该类定义了用于处理每种消息类型的虚拟方法。基本上这些方法只是noop。

当你定义一个新的消息类型时，你在BaseVisitor. 然后，如果子DataProcessor类想要处理此消息类型，则DataProcessor仅覆盖此中的虚拟方法。所有其他DataProcessor保持不变。

    #include <iostream>


    class FocalLength;
    class Angle;
    class EquipmentVisitor;

    class QueuedItem
    {
    public:
            QueuedItem() { }
            virtual ~QueuedItem() { }

            virtual void AcceptVisitor(EquipmentVisitor& visitor) = 0;
    };

    class EquipmentVisitor
    {
    public:
            virtual ~EquipmentVisitor() {}

            virtual void Visit(FocalLength& item) {}
            virtual void Visit(Angle& item)       {}

            void ProcessMessages(QueuedItem* item)
            {
                    item->AcceptVisitor(*this);
            }
    };

    class Angle : public QueuedItem
    {
    public:
            Angle() {}
            virtual ~Angle() { }

            void AcceptVisitor(EquipmentVisitor& visitor) { visitor.Visit(*this); }
    };

    class FocalLength : public QueuedItem
    {
    public:
            FocalLength() {}
            virtual ~FocalLength() { }

            void AcceptVisitor(EquipmentVisitor& visitor) { visitor.Visit(*this); }
    private:

    };

    class MyDataProcessor : public EquipmentVisitor
    {
    public:
            virtual ~MyDataProcessor() {}

            void Visit(Angle& angle)             { std::cout << "Processing Angle" << std::endl; }
            void Visit(FocalLength& focalLength) { std::cout << "Processing FocalLength" << std::endl; }
    };


    int main(int argc, char const* argv[])
    {
            // Equipment interface thread...
            FocalLength* f    = new FocalLength();
            QueuedItem*  item = f; // This gets stuck onto the queue

            // ...DataProcessor thread (after dequeuing)
            QueuedItem* dequeuedItem = item;

            // Example of a DataProcessor implementation.
            // In reality, this would
            MyDataProcessor dataProc;
            dataProc.ProcessMessages(dequeuedItem);

            return 0;
    }
于 2012-04-11T09:14:09.673 回答
0

根据我将 4 条消息发送到 2 个处理程序的最简单消息处理：

#include <iostream>
#include <queue>
#include <memory>

class HandlerA
{
public:
  void doA1() { std::cout << "A1\n"; }
  void doA2(const std::string& s) { std::cout << "A2: " << s << "\n"; }
};

class HandlerB
{
public:
  void doB1() { std::cout << "B1\n"; }
  void doB2(const std::string& s) { std::cout << "B2: " << s << "\n"; }
};


class BaseMsg
{
public:
  virtual ~BaseMsg() {}
  void send();
  virtual void handle() { execute(); }
  virtual void execute() = 0;
};

typedef std::shared_ptr<BaseMsg> Msg;
class Medium
{
  std::queue<Msg> queue;
public:
  void send(Msg msg) { queue.push(msg); }
  void process()
  {
    while (! queue.empty())
    {
      std::cout << "Processing\n";
      queue.front()->handle();
      queue.pop();
    }
  }
};

class BaseMsgHndlrA : public BaseMsg
{
protected:
  HandlerA& ha;
public:
  BaseMsgHndlrA(HandlerA& ha_) : ha(ha_) { }
};

class BaseMsgHndlrB : public BaseMsg
{
protected:
  HandlerB& hb;
public:
  BaseMsgHndlrB(HandlerB& hb_) : hb(hb_) { }
};

class MsgA1 : public BaseMsgHndlrA
{
public:
  MsgA1(HandlerA& ha_) : BaseMsgHndlrA(ha_) { }
  virtual void execute() { ha.doA1(); } 
};

class MsgA2 : public BaseMsgHndlrA
{
public:
  MsgA2(HandlerA& ha_) : BaseMsgHndlrA(ha_) { }
  virtual void execute() { ha.doA2("Msg A2"); } 
};

class MsgB1 : public BaseMsgHndlrB
{
public:
  MsgB1(HandlerB& hb_) : BaseMsgHndlrB(hb_) { }
  virtual void execute() { hb.doB1(); } 
};

class MsgB2 : public BaseMsgHndlrB
{
  std::string s;
public:
  MsgB2(HandlerB& hb_, const std::string s_) : BaseMsgHndlrB(hb_), s(s_) { }
  virtual void execute() { hb.doB2(s); } 
};

int main()
{
  Medium medium;
  HandlerA handlerA;
  HandlerB handlerB;

  medium.send(Msg(new MsgA1(handlerA)));
  medium.send(Msg(new MsgA2(handlerA)));
  medium.send(Msg(new MsgB1(handlerB)));
  medium.send(Msg(new MsgB2(handlerB, "From main")));

  medium.process();
}

这仅使用虚函数通过一些参数调度到正确的处理程序。
handle() 函数不是严格需要的，但在定义消息层次结构时很有帮助。
通用消息可以包含一个可以用 bind 填充的 std::function，因此可以发送带有参数的实际函数，而不是为每个排队的操作创建一个消息类。
为了隐藏实际的发送，处理程序可以自己进行发送，因此可以立即从发送线程访问它们。

但是，如果需要将多个消息发送到更多处理程序，则可以使用双重调度（访问者）。

于 2012-04-12T07:05:44.193 回答
0

您可以执行以下任何操作：

case将处理代码（如您的switch语句中的每个）委托给Handler对象——对象的层次结构HandlerBase或完全不相关的类型。

然后你让你的消息保持对Handler对象的引用（如果它是一个层次结构，你可以在BaseMessage级别上做，如果是不相关的对象，那么作为单独的专用消息类型的一部分），然后你可以在你的时候将它们传递给通过BaseMessage::Handle()方法处理它们。编辑：此方法不是虚拟的。

当然，如果你沿着HandlerBase层次结构的路径走，你仍然需要static_cast将消息返回到它们的任何类型，但这应该没问题：它们应该只用自己的 Handler 创建（应该知道它们的类型）反正。

例子：

// BaseMessage.hpp
#include <iostream>

class BaseMessage
{
public:
  BaseMessage(HandlerBase* pHandler);
  : m_pHandler(pHandler)
  {}

  virtual ~BaseMessage()
  {}

  void  SetHandler(HandlerBase* pHandler)
  {
    m_pHandler = pHandler;
  }

  void  Handle()
  {
    assert(m_pHandler != 0);
    m_pHandler->Handle(this);
  }

protected:
  HandlerBase*  m_pHandler; // does not own it - can be shared between messages
};

// HandlerBase.hpp
class HandlerBase
{
public:
  HandlerBase()
  {}

  virtual ~HandlerBase()
  {}

  virtual void Handler(BaseMessage* pMessage) =0;
}

// message and handler implementations
class AMessage: public BaseMessage
{
public:
  AMessage(BaseHandler* pHandler)
    : BaseMessage(pHandler)
  {}

  ~AMessage() {}

  void  DoSomeAness()
  {
    std::cout << "Being an A..." << std::endl;
  }
};

class AHandler
{
public:
  AHandler()
  {}

  virtual ~AHandler()
  {}

  virtual void Handle(BaseMessage* pMessage)
  {
    AMessage *pMsgA(static_cast<AMessage*>(pMessage));
    pMsgA->DoSomeAness();
  }
};

class BMessage: public BaseMessage
{
public:
  BMessage(BaseHandler* pHandler)
    : BaseMessage(pHandler)
  {}

  ~BMessage() {}

  void  DoSomeBness()
  {
    std::cout << "Being a B..." << std::endl;
  }
};

class BHandler
{
public:
  BHandler()
  {}

  virtual ~BHandler()
  {}

  virtual void Handle(BaseMessage* pMessage)
  {
    BMessage *pMsgB(static_cast<BMessage*>(pMessage));
    pMsgB->DoSomeBness();
  }
};


// the thread
static std::list<BaseMessage*> msgQueue;

int HandlerThread(void *pData)
{
  while(true)   // find some more sophisticated way to break
  {
    while(!msgQueue.empty())
    {
      msgQueue.front()->Handle();
      msgQueue.pop_front();
    }
    // delay and stuff
  }
  return 0;
}

int main(int argc, char** argv)
{
  start_thread(HandlerThread, 0); // your favorite API here

  AHandler  aHandler;
  BHandler  bHandler;

  msqQueue.push_back(new AMessage(&aHandler));
  msqQueue.push_back(new BMessage(&bHandler));
  msqQueue.push_back(new BMessage(&bHandler));
  msqQueue.push_back(new AMessage(&aHandler));
  msqQueue.push_back(new AMessage(&aHandler));
  msqQueue.push_back(new BMessage(&bHandler));
  msqQueue.push_back(new AMessage(&aHandler));
  msqQueue.push_back(new BMessage(&bHandler));

  return 0;
}

编辑：是的，本质上，这是访问者模式。

于 2012-04-11T07:20:52.243 回答