c ++, Есть ли хорошее решение для отправителя сообщений для поддержки метода отправки о различных типах?

Question

Я хочу, чтобы MessageSender поддерживал метод отправки для различных типов и удовлетворял следующим условиям.

условие A) «Отправить сообщение типа XXX» может быть добавлено позже (= легко развернуть)

условие B) каждый sendXTypeMessage вызывается в другом потоке (= каждый метод должен был быть независимым от потока)

Сначала я думал о следующем:

class MessageSender
    {
    public:
     sendATypeMessage(ATypeData)
     sendBTypeMessage(BTypeData)
     sendCTypeMessage(CTypeData)
     ...(it can be added other type later)
    }

Но в случае этого, когда я хочу добавить sendDTypeMessage (данные). Я должен изменить класс MessageSender.

---

секунду, когда я думал следующее:

class XTypeData : public IMessage
{
...
}
class MessageSender
{
public:
 sendMessage(const IMessage& data); 
}
MessageSender::sendMessage(const IMessage& data)
{
1) mutex lock
2) switch(check message type)
3) do something...
}

, но в этом случае я должен использовать блокировку мьютекса в sendMessage.

тогда это может вызвать проблемы с производительностью, потому что каждый поток отправителя сообщения может быть заблокирован в sendMessage.

---

Есть ли какое-либо хорошее решение для удовлетворения этих условий?

Answer 1

Я думаю, вы можете

1. сделать так, чтобы MessageSender реализовывал различные стратегии отправки (это может быть основано на MessageType, например: sendXXTypeMessage)
2. IMessage имеет виртуальный интерфейс отправки (MessageSender &), каждый MessageType реализует функцию send (), которая вызывает соответствующие функции отправки в MessageSender
3. MessageSender :: sendMessage вызывает функцию send () интерфейса IMessage, который динамически отправляет вызов функции send () конкретного MessageType

Пример кода:

#include <iostream>

using namespace std;
class MessageSender;
class IMessage{
    public:
    virtual void send(const MessageSender&)  = 0;
};

class ATypeData : public IMessage
{
    public:
    void send(const MessageSender& s) ; 
};

class BTypeData : public IMessage {
    public:
    void send(const MessageSender& s) ; 
};

class CTypeData : public IMessage {
    public:
    void send(const MessageSender& s) ; 
};

class MessageSender
{
public:
 void sendMessage(IMessage& data) { data.send(*this); }
 void sendATypeMessage(ATypeData&) const { /*mutex if needed*/ cout << "Sent A" << endl; }
 void sendBTypeMessage(BTypeData&) const { /*mutex if needed*/ cout << "Sent B" << endl; } 
 void sendCTypeMessage(CTypeData&) const { /*mutex if needed*/ cout << "Sent C" << endl; }
};

void ATypeData::send(const MessageSender& s)  { s.sendATypeMessage(*this); }
void BTypeData::send(const MessageSender& s)  { s.sendBTypeMessage(*this); }
void CTypeData::send(const MessageSender& s)  { s.sendCTypeMessage(*this); }

int main() {
    ATypeData a;
    BTypeData b;
    CTypeData c;
    MessageSender m;
    m.sendMessage(a);
    m.sendMessage(b);
    m.sendMessage(c);
}