Sobj_type(
    // Адрес получателя сообщения.
    To_type * to,
    // Само сообщение.
    Mbapi_type * msg,
    // Адрес отправителя сообщения (обратный адрес).
    Reply_to_type * reply_to );

Sobj_type(
    To_type * to,
    Mbapi_type * msg,
    Reply_to_type * reply_to,
    std::auto_ptr< mbapi_3::extended_info_t > extended_info );

//
// extended_info_t
//

/*!
    \since v.3.3.0
    \brief Расширеная информация об MBAPI-сообщении, которая доступна
        для получателя MBAPI-сообщения.

    Большинству получателей MBAPI-сообщений необходимо всего три значения:
    пункт назначения сообщения, само сообщение и его обратный адрес.
    Но в версии 3.3.0 получателю предоставляется так же возможность получить
    историю ремаршрутизаций сообщения. В следующих версиях получатель может
    захотеть получать еще какую-то информацию о сообщении. Для того, чтобы
    не модифицировать для этого шаблон so_templ_postman_t предлагается
    всю дополнительную информацию передавать получателю в виде структуры
    extended_info_t, которая будет расширятся дополнительными атрибутами по
    мере надобности.
*/
struct    extended_info_t
    {
        //! История ремаршрутизации сообщений.
        std::auto_ptr< rerouting_history_t >    m_rerouting_history;

        //! Инициализирующий конструктор.
        /*!
            Самостоятельно извлекает всю информацию из delivery_info_t.
        */
        extended_info_t( const delivery_info_t & info )
            :    m_rerouting_history( info.rerouting_history() ?
                    new rerouting_history_t( *info.rerouting_history() ) : 0 )
            {}
        ~extended_info_t()
            {}
        
        /*! \name Методы getter-ы.
            \{ */
        const rerouting_history_t *
        rerouting_history() const { return m_rerouting_history.get(); }
        /*! \} */
    };

namespace impl
{

//
// sender_params_t
//

/*!
    \since v.3.3.0
    \brief Вспомогательная обертка для параметров доставки MBAPI-сообщения
        в виде SObjectizer сообщения.

    Необходима, главным образом, для того, чтобы сделать вспомогательные
    классы no_extended_info_support_sender_t и extended_info_support_sender_t
    не шаблонными -- это необходимо для поддержки C++ компилятров, в которых
    нет частичной специализации шаблонов.
*/
template<
        class Mbapi_type,
        class Sobj_type,
        class To_type,    
        class Reply_to_type >
struct    sender_params_t
    {
        /*! \name Псевдонимы для параметров шаблона.
            \{ */
        typedef Mbapi_type    mbapi_type_t;
        typedef Sobj_type    sobj_type_t;
        typedef To_type    to_type_t;
        typedef Reply_to_type    reply_to_type_t;
        /*! \} */

        //! Исходные параметры MBAPI-сообщения.
        const delivery_info_t &    m_info;

        //! Инициализирующий конструктор.
        sender_params_t( const delivery_info_t & info )
            :    m_info( info )
            {}

        //! Доступ к параметрам MBAPI-сообщения.
        const delivery_info_t &
        info() const { return m_info; }
    };

//
// no_extended_info_support_sender_t
//

/*!
    \since v.3.3.0
    \brief Генератор SObjectizer-сообщения, для случая, когда конструктор
        сообщения получает всего три параметра.
*/
struct    no_extended_info_support_sender_t
    {
        //! Шаблонный метод для генерации SObjectizer-сообщения.
        /*!
            \note В качестве параметра шаблона ожидается sender_params_t.
        */
        template< class Params >
        void
        send(
            //! Имя владельца сообщения.
            const std::string & owner_name,
            //! Имя SObjectizer-сообщения.
            const std::string & msg_name,
            //! Все доступные параметры MBAPI-сообщения.
            const Params & p ) const
            {
                // Для защиты от исключений при выделении памяти.
                std::auto_ptr< Params::to_type_t > to(
                        dynamic_cast< typename Params::to_type_t * >(
                                p.info().to().clone() ) );
                std::auto_ptr< Params::mbapi_type_t > msg(
                        dynamic_cast< typename Params::mbapi_type_t * >(
                                p.info().msg().clone() ) );
                std::auto_ptr< Params::reply_to_type_t > reply_to(
                        dynamic_cast< typename Params::reply_to_type_t * >(
                                p.info().reply_to().clone() ) );

                so_4::api::send_msg_safely( owner_name, msg_name,
                        new typename Params::sobj_type_t(
                                to.release(),
                                msg.release(),
                                reply_to.release() ),
                        "", p.info().delay() );
            }
    };

//
// extended_info_support_sender_t
//

/*!
    \since v.3.3.0
    \brief Генератор SObjectizer-сообщения, для случая, когда конструктор
        сообщения получает четвертым параметром rerouting_history.
*/
struct    extended_info_support_sender_t
    {
        //! Шаблонный метод для генерации SObjectizer-сообщения.
        /*!
            \note В качестве параметра шаблона ожидается sender_params_t.
        */
        template< class Params >
        void
        send(
            //! Имя владельца сообщения.
            const std::string & owner_name,
            //! Имя SObjectizer-сообщения.
            const std::string & msg_name,
            //! Все доступные параметры MBAPI-сообщения.
            const Params & p ) const
            {
                // Для защиты от исключений при выделении памяти.
                std::auto_ptr< Params::to_type_t > to(
                        dynamic_cast< typename Params::to_type_t * >(
                                p.info().to().clone() ) );
                std::auto_ptr< Params::mbapi_type_t > msg(
                        dynamic_cast< typename Params::mbapi_type_t * >(
                                p.info().msg().clone() ) );
                std::auto_ptr< Params::reply_to_type_t > reply_to(
                        dynamic_cast< typename Params::reply_to_type_t * >(
                                p.info().reply_to().clone() ) );
                std::auto_ptr< extended_info_t > extended(
                        new extended_info_t( p.info() ) );

                so_4::api::send_msg_safely( owner_name, msg_name,
                        new typename Params::sobj_type_t(
                                to, msg, reply_to, extended ),
                        "", p.info().delay() );
            }
    };

//
// sender_selector_t
//

/*!
    \since v.3.3.0
    \brief Вспомогательный класс для выбора одного из sender-ов.

    Данная версия одновременно является специализацией для случая,
    когда Extended_info_supported == false.
*/
template< bool Extended_info_supported >
struct    sender_selector_t
    {
        typedef no_extended_info_support_sender_t    sender_type_t;
    };

/*!
    \since v.3.3.0

    Специализация sender_selector_t для случая, когда
    Extended_info_suppored == true.
*/
template<>
struct    sender_selector_t< true >
    {
        typedef extended_info_support_sender_t    sender_type_t;
    };

} /* namespace impl */

//
// so_postman_templ_t
//

//! Реализация интерфейса %postman_t в виде шаблона.
/*!

    \par Версии, предшествующие 3.3.0
    Предназначен для генерации SObjectizer-сообщений,
    которые имеют конструктор следующего вида:
\code
Sobj_type(
    To_type * to,
    Mbapi_type * msg,
    Reply_to_type * reply_to );
\endcode

    Например:
\code
struct    msg_receiver_ack_t
{
    std::auto_ptr< mbapi_3::dest_t > m_to;
    std::auto_ptr< mbapi_3::sms::receive_ack_t > m_msg;
    std::auto_ptr< mbapi_3::dest_t > m_reply_to;

    msg_receiver_ack_t() {}
    msg_receiver_ack_t(
        mbapi_3::dest_t * to,
        mbapi_3::sms::receive_ack_t * msg,
        mbapi_3::dest_t * reply_to )
        :    m_to( to )
        ,    m_msg( msg )
        ,    m_reply_to( reply_to )
        {
        }
};

so_postman_templ_t<
        mbapi_3::sms::receive_ack_t,
        msg_receive_ack_t >
    receive_ack_postman(
        "some_agent_name",
        "msg_receive_ack" );
\endcode

    \par Начиная с версии 3.3.0 поддерживаются SObjectizer-сообщения,
    конструктор который имеет следующий вид:
\code
Sobj_type(
    std::auto_ptr< To_type > to,
    std::auto_ptr< Mbapi_type > msg,
    std::auto_ptr< Reply_to_type > reply_to,
    std::auto_ptr< mbapi_3::extended_info_t > extended_info );
\endcode
*/
template<
    // Тип MBAPI-сообщения.
    class    Mbapi_type,
    // Тип SObjectizer-сообщения.
    class    Sobj_type,
    // Тип адреса получателя сообщения.
    class To_type = mbapi_3::dest_t,
    // Тип адреса отправителя сообщения.
    class    Reply_to_type = mbapi_3::dest_t,
    // Поддерживается ли получателем расширенная информация?
    bool Extended_info_supported = false >
class    so_postman_templ_t :
    public postman_t
    {
    private :
        //! Имя агента-владельца сообщения.
        const std::string    m_owner_agent;
        //! Имя сообщения, которое нужно отослать.
        const std::string    m_msg_name;

        //! Объект, который реально будет осущетвлять доставку сообщения.
        const typename impl::sender_selector_t<
                        Extended_info_supported >::sender_type_t
                m_sender;

    public :
        inline
        so_postman_templ_t(
            //! Имя агента-владельца сообщения.
            const std::string & owner_agent,
            //! Имя сообщения, которое нужно отослать.
            const std::string & msg_name )
            :    m_owner_agent( owner_agent )
            ,    m_msg_name( msg_name )
            {}

        virtual ~so_postman_templ_t()
            {}

        virtual void
        deliver(
            const mbapi_3::router::delivery_info_t & info )
            {
                impl::sender_params_t<
                                Mbapi_type, Sobj_type, To_type, Reply_to_type >
                        params( info );
                m_sender.send( m_owner_agent, m_msg_name, params );
            }
    };

} /* namespace router */

} /* namespace mbapi_3 */

_FR>

template<
    // Тип MBAPI-сообщения.
    class    Mbapi_type,
    // Тип SObjectizer-сообщения.
    class    Sobj_type,
    // Тип адреса получателя сообщения.
    class To_type = mbapi_3::dest_t,
    // Тип адреса отправителя сообщения.
    class    Reply_to_type = mbapi_3::dest_t >
class    so_postman_templ_t :
    public postman_t
{
    private :
        //! Имя агента-владельца сообщения.
        const std::string    m_owner_agent;
        //! Имя сообщения, которое нужно отослать.
        const std::string    m_msg_name;

    public :
        inline
        so_postman_templ_t(
            //! Имя агента-владельца сообщения.
            const std::string & owner_agent,
            //! Имя сообщения, которое нужно отослать.
            const std::string & msg_name )
            :
                m_owner_agent( owner_agent ),
                m_msg_name( msg_name )
        {
        }

        virtual ~so_postman_templ_t()
        {
        }

        inline
        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 )
        {
            so_4::rt::msg_auto_ptr_t< Sobj_type >
                msg_to_send( new Sobj_type(
                    dynamic_cast< To_type * >( to.clone() ),
                    dynamic_cast< Mbapi_type * >( msg.clone() ),
                    dynamic_cast< Reply_to_type * >( reply_to.clone() ) )
                );

            msg_to_send.send( m_owner_agent, m_msg_name, "",
                delay );
        }
};

template< class Mbapi_type, class Sobj_type, class To_type = mbapi_3::dest_t, class Reply_to_type = mbapi_3::dest_t >
class    so_postman_templ_t :
    public postman_t
{
    private :
                ......
                
        inline
        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 )
        {
            so_4::rt::msg_auto_ptr_t< Sobj_type >
                msg_to_send( new Sobj_type(
                    dynamic_cast< To_type * >( to.clone() ),
                    dynamic_cast< Mbapi_type * >( msg.clone() ),
                    dynamic_cast< Reply_to_type * >( reply_to.clone() ) )
                );

            msg_to_send.send( m_owner_agent, m_msg_name, "",
                delay );
        }
};

struct    some_message_t { some_message_t( dest_type_t * to, source_message_t * msg, dest_type_t * reply_to ) {...} ... };

new so_postman_templ_t< source_message_t, some_message_t, dest_type_t, dest_type_t >( some_agent, some_message );

struct another_message_t {
    another_message_t( dest_type_t * to, source_message_t * msg, dest_type_t * reply_to,
        std::auto_ptr< extended_info_t > ) {...}
        ...
};

new so_postman_templ_t< source_message_t, some_message_t, dest_type_t, dest_type_t >( some_agent, some_message )
new so_postman_templ_t< source_message_t, another_message_t, dest_type_t, dest_type_t, true >( some_agent, another_message );

template<
    class Mbapi_type, class Sobj_type, class To_type = mbapi_3::dest_t, class Reply_to_type = mbapi_3::dest_t,
    bool Extended_info_supported = false >
class    so_postman_templ_t :
    public postman_t
{
    private :
                ......
                
        inline
        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 )
        {
                    if( Extended_info_supported )
                        new Sobj_type( /* четыре аргумента */ );
                    else
                        new Sobj_type( /* три аргумента */ );
                        
                    ...
        }
};

namespace impl
{

template<
        class Mbapi_type,
        class Sobj_type,
        class To_type,    
        class Reply_to_type >
struct    sender_params_t
    {
        typedef Mbapi_type    mbapi_type_t;
        typedef Sobj_type    sobj_type_t;
        typedef To_type    to_type_t;
        typedef Reply_to_type    reply_to_type_t;
                ...
    };

struct    no_extended_info_support_sender_t
    {
        template< class Params >
        void
        send(
            const std::string & owner_name,
            const std::string & msg_name,
            const Params & p ) const
            {
                            /* Фактически здесь вызывается: */
                            new Sobj_type( /* три параметра */ );
                            ...
            }
    };

struct    extended_info_support_sender_t
    {
        template< class Params >
        void
        send(
            const std::string & owner_name,
            const std::string & msg_name,
            const Params & p ) const
            {
                            /* Фактически здесь вызывается: */
                            new Sobj_type( /* четыре параметра */ );
                            ...
            }
    };

template< bool Extended_info_supported >
struct    sender_selector_t
    {
        typedef no_extended_info_support_sender_t    sender_type_t;
    };

template<>
struct    sender_selector_t< true >
    {
        typedef extended_info_support_sender_t    sender_type_t;
    };

} /* namespace impl */

template<
    class    Mbapi_type,
    class    Sobj_type,
    class To_type = mbapi_3::dest_t,
    class    Reply_to_type = mbapi_3::dest_t,
    bool Extended_info_supported = false >
class    so_postman_templ_t :
    public postman_t
    {
    private :
                /* Вот здесь на этапе компиляции определяется, будет ли вызываться
                    конструктор с тремя параметрами или конструктор с четырьмя параметрами */
        const typename impl::sender_selector_t<
                        Extended_info_supported >::sender_type_t
                m_sender;
                ...
    public :
        virtual void
        deliver(
            const mbapi_3::router::delivery_info_t & info )
            {
                impl::sender_params_t<
                                Mbapi_type, Sobj_type, To_type, Reply_to_type >
                        params( info );
                m_sender.send( m_owner_agent, m_msg_name, params );
            }
    };

>> Sobj_type(
>>     // Адрес получателя сообщения.
>>     To_type * to,
>>     // Само сообщение.
>>     Mbapi_type * msg,
>>     // Адрес отправителя сообщения (обратный адрес).
>>     Reply_to_type * reply_to );
>>

Sobj_type * instance = Sobj_type::create_instance( to, msg, reply_to );

>> Sobj_type * instance = Sobj_type::create_instance( to, msg, reply_to );
>>

template< class Mbapi_type, class Sobj_type, class Sobj_type_factory, class To_type, class Reply_to_type >
class    so_postman_templ_t
{
private :
    Sobj_type_factory m_factory;
    ...
public :
    so_postman_templ_t( Sobj_type_factory factory, ... ) : m_factory( factory ), ... { ... }
    
    void deliver(...)
        {
            Sobj_type * message = Sobj_type_factory.create(...);
            ...
        }
};

// Базовый класс для сообщений.
class msg_t { ... };

// Базовый класс для пунктов назначений (адресов получателей и отправителей сообщений).
class dest_t { ... };

// Метод для маршрутизации сообщения:
void
route(
    // Куда должно идти сообщение.
    const dest_t & to,
    // Само сообщение.
    const msg_t & msg,
    // От кого идет сообщение.
    const dest_t & reply_to,
    // Еще какие-то параметры, суть которых сейчас не важна
    ... );

route( some_dest_t( "recipient" ), some_message_t( "hello!" ), some_dest_t( "sender" ) );

struct    so_message_t
    {
        std::auto_ptr< dest_t >    m_to;
        std::auto_ptr< msg_t >    m_msg;
        std::auto_ptr< dest_t >    m_reply_to;
    };

template< class Msg, class To, class Reply_to >
struct    so_msg_templ_t
    {
        std::auto_ptr< To >    m_to;
        std::auto_ptr< Msg >    m_msg;
        std::auto_ptr< Reply_to >    m_reply_to;
    };

so_postman_templ_t::deliver( /* параметры из route */ )
    {
        ... new Message_type( to.clone(), msg.clone(), reply_to.clone() ) ...
    }

so_postman_templ_t::deliver( /* параметры из route */ )
    {
        if( Extended_info_supported )
            // Используем конструктор с четырьмя параметрами.
            ... new Message_type( to.clone(), msg.clone(), reply_to.clone(), extended_info.clone() ) ...
        else
            // Используем конструктор с тремя параметрами.
            ... new Message_type( to.clone(), msg.clone(), reply_to.clone() ) ...
    }

struct    no_extended_info_support_sender_t
    {
            // Используем конструктор с тремя параметрами.
            ... new Message_type( to.clone(), msg.clone(), reply_to.clone() ) ...
    };

struct    extended_info_support_sender_t
    {
            // Используем конструктор с четырьмя параметрами.
            ... new Message_type( to.clone(), msg.clone(), reply_to.clone(), extended_info.clone() ) ...
    };

template< bool Extended_info_supported >
struct    sender_selector_t
    {
        typedef no_extended_info_support_sender_t    sender_type_t;
    };

template<>
struct    sender_selector_t< true >
    {
        typedef extended_info_support_sender_t    sender_type_t;
    };

template< class    Mbapi_type, class    Sobj_type, class To_type = mbapi_3::dest_t, class    Reply_to_type = mbapi_3::dest_t,
    bool Extended_info_supported = false >
class    so_postman_templ_t : public postman_t {
    ...
    //! Объект, который реально будет осущетвлять доставку сообщения.
    const typename impl::sender_selector_t<
                    Extended_info_supported >::sender_type_t
            m_sender;
    ...
};

new so_postman_templ_t< some_message_t, some_async_message_t, some_dest_t >( ... );

using System.Reflection;

public class Postman<MessageType> 
{
  public void Deliver(Destination to, Msg msd, Destination replyTo)
    {
        ConstructorInfo messageCtor = typeof(MessageType).GetConstructor(new Type[]{typeof(Destination),typeof(Msg), typeof(Destination)});
        if (messageCtor != null)
            MessageType msg = (MessageType)messageCtor.Invoke(new object[]{to, msg, replyTo};
    }
}

public class Postman<MessageType> 
{
  public void ExtendedDeliver(Destination to, Msg msd, Destination replyTo, Extended extended)
    {
        MessageType msg = null;
        ConstructorInfo messageCtor = typeof(MessageType).GetConstructor(new Type[]{typeof(Destination),typeof(Msg), typeof(Destination), typeof(Extended)});
        if (messageCtor != null)
            msg = (MessageType)messageCtor.Invoke(new object[]{to, msg, replyTo, extended};
        else // попробуем найти старый конструктор
        {
            messageCtor = typeof(MessageType).GetConstructor(new Type[]{typeof(Destination),typeof(Msg), typeof(Destination)});
            if (messageCtor != null)
                msg = (MessageType)messageCtor.Invoke(new object[]{to, msg, replyTo};
        }
    }
}

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 });
    }
}