virtual void
deliver(
    const mbapi_3::dest_t & to,
    const mbapi_3::msg_t & msg,
    const mbapi_3::dest_t & reply_to,
    unsigned int delay ) = 0;

virtual void
deliver( const delivery_info_t & info );

public abstract class Postman
{
  // handles the delivery of the message
  public virtual void deliver(Dest to, Msg msg, Dest replyTo);
}

public class GenericMessage<ToType, MsgType, ReplyToType>
    where ToType: Dest
    where MsgType: Msg
    where ReplyToType: Dest;
{

    public GenericMessage(SomeDestination to, Msg msg, SomeOtherDestination)
    {
      ...
    }
}

public delegate MessageType MessageFactory<MessageType, ToType, MsgType, ReplyToType>(ToType to, MsgType msg, ReplyToType replyTo)
    where ToType: Dest
    where MsgType: Msg
    where ReplyToType: Dest;

public class Postman<MessageType, ToType, MsgType, ReplyToType>: Postman
    where ToType: Dest
    where MsgType: Msg
    where ReplyToType: Dest;
{
    private MessageFactory<MessageType, ToType, MsgType, ReplyToType> _factory;
    private Queue<MessageType> _queue = new Queue<MessageType>();

    public Postman(MessageFactory<MessageType, ToType, MsgType, ReplyToType> factory)
    {
        _factory = factory;
    }
    
    override void deliver(Dest to, Msg msg, Dest replyTo)
    {
        deliver((ToType)to, (MsgType)msg, (ReplyToType)replyTo);
    }
    public virtual void deliver(ToType to, MsgType msg, ReplyToType replyTo)
    {
        _queue.Enqueue(_factory(to, msg, replyTo));
    }
}

public class GenericPostman<ToType, MsgType, ReplyToType>: Postman<GenericMessage<ToType, MsgType, ReplyToType>, ToType, MsgType, ReplyToType>
{
  // Factory helper
  public static GenericMessage<ToType, MsgType, ReplyToType> CreateMessage(ToType to, MsgType msg, ReplyToType replyTo)
    {
        return new GenericMessage<ToType, MsgType, ReplyToType>(to, msg, replyTo);
    }
    
    public GenericPostman(): base (CreateMessage)
    {
    }
}

public class SpecificMessageType
{
  public SpecificMessageType(SomeDestination to, SomeMessageType msg, SomeOtherDestination replyTo)
    {
    ...
    }
}
{
  Router.RegisterPostman(new GenericPostman<SomeDestination, SomeMessageType, SomeOtherDestination>()); // это простой случай
    
  Router.RegisterPostman(new Postman<SpecificMessageType, SomeDestination, SomeMessageType, SomeOtherDestination>
        ( new delegate(SomeDestination to, SomeMessageType msg, SomeOtherDestination replyTo)
            {    return new SpecificMessageType(to, msg, replyTo) }
        )
    );
}

public class GenericMessage<ToType, MsgType, ReplyToType, ExtendedDataType>
    where ToType: Dest
    where MsgType: Msg
    where ReplyToType: Dest;
{

    public GenericMessage(SomeDestination to, Msg msg, SomeOtherDestination to, ExtendedDataType ext)
    {
      ...
    }
}

public delegate MessageType MessageFactory<MessageType, ToType, MsgType, ReplyToType, ExtendedDataType>(ToType to, MsgType msg, ReplyToType replyTo, ExtendedDataType ext)
    where ToType: Dest
    where MsgType: Msg
    where ReplyToType: Dest;

public class Postman<MessageType, ToType, MsgType, ReplyToType, ExtendedDataType>: Postman
    where ToType: Dest
    where MsgType: Msg
    where ReplyToType: Dest;
{
    private MessageFactory<MessageType, ToType, MsgType, ReplyToType, ExtendedDataType> _factory;
    private Queue<MessageType> _queue = new Queue<MessageType>();

    public Postman(MessageFactory<MessageType, ToType, MsgType, ReplyToType, ExtendedDataType> factory)
    {
        _factory = factory;
    }
    
    override void deliver(DeliveryInfo info)
    {
        _queue.Enqueue(_factory(info.to, info.msg, info.replyTo, info.extendedData));
    }
}

Router.RegisterPostman(new GenericPostman<SomeDestination, SomeMessageType, SomeOtherDestination>()); // это простой случай

Router.RegisterPostman(
    new GenericPostman<
            SomeDestination, SomeMessageType, SomeOtherDestination, NoExtendedInfo >()); // это простой случай

GenericMessage<To,Msg,ReplyTo>
MessageFactory<MessageType,To,Msg,ReplyTo>
Postman<MessageType,To,Msg,ReplyTo>
GenericPostman<To,Msg,ReplyTo>

GenericMessage<To,Msg,ReplyTo,Extended>
MessageFactory<MessageType,To,Msg,ReplyTo,Extended>
Postman<MessageType,To,Msg,ReplyTo,Extended>
GenericPostman<To,Msg,ReplyTo,Extended>

S>  Router.RegisterPostman(new GenericPostman<SomeDestination, SomeMessageType, SomeOtherDestination>()); // это простой случай
    
S>  Router.RegisterPostman(new Postman<SpecificMessageType, SomeDestination, SomeMessageType, SomeOtherDestination>
S>        ( new delegate(SomeDestination to, SomeMessageType msg, SomeOtherDestination replyTo)
S>            {    return new SpecificMessageType(to, msg, replyTo) }
S>        )
S>    );
S>}
S>

class    SomeAgent
{
    public void receiveSomeMessage( GenericMessage< SomeDestination, SomeMessageType, SomeOtherDestination > msg )
        { ... }
};

template< class Message, class To, class ReplyTo, bool Extended_info_required = false >
struct so_msg_templ_t
    {
        typedef Message    message_type_t;
        typedef To    to_type_t;
        typedef ReplyTo    reply_to_type_t;
        enum { extended_info_required = Extended_info_required };
        ...
    };

template< class So_message >
class    so_msg_templ_postman_t
    :    public postman_t
    {
        // Агрегируем функциональность ранее созданного шаблона so_postman_templ_t.
        typedef so_postman_templ_t<
                        // Вот здесь берем псевдонимы из So_message.
                        typename So_message::message_type_t,
                        So_message,
                        typename So_message::to_type_t,
                        typename So_message::reply_to_type_t,
                        So_message::extended_info_required >
                real_postman_t;
                
        real_postman_t    m_postman;
        ...
    };

typedef so_msg_templ_t< some_message_t, some_dest_t, some_another_dest_t > my_message_t;

so_msg_templ_postman_t< my_message_t > my_postman;

void
some_agent_t::evt_receive_my_message( const my_message_t & msg ) {...}

using IntList = System.Collections.Generic.List<int>;

delegate Result Creator<Result, T1, T2, T3>(T1 t1, T2 t2, T3 t3);

class Destination { }
class Msg { }
class Message
{
    public Message(Destination to, Msg msd, Destination replyTo)  {  }
}

class Postman<MessageType>
{
    public Postman(Creator<MessageType, Destination, Msg, Destination> creator) { _creator = creator; }

    Creator<MessageType, Destination, Msg, Destination> _creator;
 
    public void Deliver(Destination to, Msg msd, Destination replyTo)
    {
        MessageType message = _creator(to, msd, replyTo);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Postman<Message> postman = new Postman<Message>(
            delegate(Destination to, Msg msd, Destination replyTo) { return new Message(to, msd, replyTo); });

        postman.Deliver(new Destination(), new Msg(), new Destination());
    }
}

class Postman<MessageType>
{
    public void Deliver(Destination to, Msg msd, Destination replyTo)
    {
        MessageType message = (MessageType)Activator.CreateInstance(typeof(MessageType), new object[] { to, msd, replyTo });
    }
}