Question

我正在编写一个工具，通过更改设置和流信息，用户可以与一些硬件进行交互。

为此，我运行了几个主题：EquipmentInterface和DataProcessor，它们由Queue连接。

EquipmentInterface主题包含更改设备设置的方法（例如Rotate和Refocus）以及生成的信息（CurrentAngle和CurrentFocalDistance）已添加到Queue。一旦设置正确，就会有StartStreaming和StopStreaming的方法，一旦开始流式传输，设备的数据就会被分组并添加到队列中。

队列中的所有信息都来自单个BaseMessage类，其中包含消息类型的指示。然后，我得到了角度，焦距，开始和结束流的消息类型，当然还有数据本身。

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

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

关于这种架构的一些东西对我来说是错误的，而且我最近一直在阅读很多有关向下铸造的内容。从我所看到的，普遍的共识似乎是what I'm doing is a bad code smell。我见过a suggestion which use 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语句和基类中的某种枚举消息类型标识符的情况下看到的唯一方法。

Answer 1

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

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

定义新消息类型时，在BaseVisitor中为此消息类型添加一个带有noop实现的新虚拟方法。然后，如果子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;
    }

Answer 2

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

将处理代码（如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;
}

编辑：是的，实质上，这是visitor pattern。

Answer 3

根据我的最简单的消息处理，向4个处理程序发送4条消息：

#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，因此可以发送带参数的实际函数，而不是为每个排队操作生成消息类。
为了隐藏实际发送，处理程序可以自己进行发送，因此可以从发送线程立即访问它们。

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

如何通过队列传递信息时避免向下转换？

3 个答案: