// Смотри файл Reflection.cpp

    //Получение экземпляра метакласса:
    TheClass* pClass = 
            TheClass::GetClass("Application::BusinessLogic::MyClassName");

    //Получение функтора-конструктора по прототипу, заданному в ConstructParamList;
    typedef    TYPELIST_4(    const std_string&, 
                unsigned char, 
                const std_string&,
                unsigned int )                ConstructorParamList;
    typedef    Loki::Functor<    TheObject*, 
                ConstructorParamList >            Constructor;
    
    //В случае отстутствия конструктора с таким прототипом будет выброшено исключение 
    //подобная стратегия применяется для всех запросов к метаклассу
    Constructor    ctor = 
                pClass->GetConstructor<    ConstructorParamList>();

    //Создание экземпляра обьекта с вызовом полученного конструктора
    TheObject* pObj = ctor("Vasya", 27, "London", 12 );
    
    //Get functor to member method
    typedef    Loki::NullType                    VoidParamList;
    typedef    Loki::Functor<void, VoidParamList >            VoidMethod;
    VoidMethod f1 = 
            pClass->GetMethod<void, VoidParamList >(pObj, "f1");
    f1();

    //Get string property
    StringProperty name = pClass->GetProperty<std::string>(pObj, "name");
    name = "Rick";

    //Serialize object
    std::ostrstream    out_stream;
    IO::Formatter::BinaryWriter b_writer(out_stream);
    b_writer << pObj;

    //Удаление экземпляра обьекта
    TheClass::Destructor dtor = pClass->GetDestructor(pObj);
    dtor();

    //Смотри Application.h/Application.cpp
    using namespace Reflection;
    using namespace    IO::Formatter;

    class    Employee    : 
            public    System::ObjectImpl<    Employee,
                            System::Object<DEFAULT_THREADING> >
    {
    public:
        typedef        std_string                            app_string;
        typedef        Employee                            TheEmployee;
        typedef        System::Object<DEFAULT_THREADING>                TheObject;

    protected:
        app_string            _name;
        byte                _age;
        app_string            _address;
        uint                _department;

        void    DefaultInit();
    public:
        Employee();
        Employee(    
                const app_string&        name, 
                const Reflection::byte&    age,
                const app_string&        address,
                const uint            department );

        virtual    void    PrintEmployee();
        
        DEFINE_STREAMING_OPERATIONS( EmployeeSerializer )
                
        template<
            template< class > class ThreadingModel = DEFAULT_THREADING >
        struct    TheClassImpl    :    
                    public    Reflection::Private::ClassImpl<    TheEmployee ,    
                                        TheObject, 
                                        EmployeeSerializer, 
                                        ThreadingModel >
        {
            TheClassImpl()    
            {
                BindProperty(    "name", 
                        &Employee::_name);
                BindProperty(    "age",
                        &Employee::_age );
                BindProperty(    "address",
                        &Employee::_address );
                BindProperty(    "department",
                        &Employee::_department );
                BindMethod(    "PrintEmployee", 
                        &Employee::PrintEmployee);
                BindConstructor<    
                        const app_string&, 
                        Reflection::byte,
                        const app_string&,
                        uint>(  );
            }
        };

        typedef TheClassImpl<DEFAULT_THREADING>    ClassImpl;
    };

    REGISTER_CLASS( Employee_Class_Tag, Application::BusinessLogic::Employees::Employee)

    struct MethodCall : public    System::ObjectImpl<    MethodCall2Params<T1, T2, R>, 
                            System::Object<DEFAULT_THREADING> >
    {
        // идентификатор обьекта, который позволяет получить экземпляр обьекта  в адресном пространстве удаленной машины
        ObjectRuntimeId    _ObjId; 
        std_string        _MethodName;
        
        //Блок для регистрации полей в метаклассе
        //
            BindProperty(    "ObjectId", 
                    &MethodCall::_ObjId );
            BindProperty(    "MethodName", 
                    &MethodCall::_MethodName);
        //
        //Блок для регистрации полей в метаклассе
        
        virtual    void    CallMethod() = 0;
    };

    template< typename T1, typename T2, typename R >
    struct    MethodCall2Params : public    System::ObjectImpl<    MethodCall2Params<T1, T2, R>, 
                                MethodCall >
    {
        typedef    typename        MethodCall2Params<T1, T2, R>    MethodCall2ParamsImpl;
        T1 _Param1;
        T2 _Param2;
        R _RetVal;
        //Блок для регистрации полей в метаклассе
            BindProperty(    "P1", 
                    &MethodCall2ParamsImpl::_Param1 );
            и так далее...
        //Блок для регистрации полей в метаклассе
        void    CallMethod()
        {
            TheObject* pObj = GetObjectFromRepository( _ObjId );
            TheClass* pClass = pObj->GetClass();
            typedef    TYPELIST_2(    T1, 
                        T2 )    PARAM_LIST;
            Loki::Functor<R,PARAM_LIST> pFn = pClass->GetMethod< R, PARAM_LIST>(_MethodName);
            _RetVal = pFn( _Param1, _Param2 );
        }
    };

class A
{
    int a;
    std::string b;
};

template <class T> class Serializer;
class A
{
    int a;
    std::string b;

    friend class Serializer<A>;
};

BindProperty("name", &Employee::_name);

А>>BindProperty("name", &Employee::_name);
А>>

class Person
{
    std::string name;
    std::string secondName;
    std::string nick;
    int         homePhone;
    int         mobilePhone;
    std::string email;
    int         imNumber;
    int         icqNumber;
    Image       smallPhoto;
    Image       bigPhoto;
};

А>class Person
А>{
А>    std::string name;
А>    std::string secondName;
А>    std::string nick;
А>    int         homePhone;
А>    int         mobilePhone;
А>    std::string email;
А>    int         imNumber;
А>    int         icqNumber;
А>    Image       smallPhoto;
А>    Image       bigPhoto;
А>};
А>

struct PersonOnCall
{
    PersonOnCall( const Person& person ){...}
    std::string     _name;
    Image          _Photo;
};

struct MyStruct
{
    [UpDown(0,100)]
    int a;
};

Привычным образом это как? Руками?

B>struct PersonOnCall
B>{
B>    PersonOnCall( const Person& person ){...}
B>    std::string     _name;
B>    Image          _Photo;
B>};
B>

B>struct MyStruct
B>{
B>    [UpDown(0,100)]
B>    int a;
B>};
B>

//Получение функтора-конструктора по прототипу, заданному в ConstructParamList;
    typedef    TYPELIST_4(    const std_string&, 
                unsigned char, 
                const std_string&,
                unsigned int )                ConstructorParamList;
    typedef    Loki::Functor<    TheObject*, 
                ConstructorParamList >            Constructor;
    
    //В случае отстутствия конструктора с таким прототипом будет выброшено исключение 
    //подобная стратегия применяется для всех запросов к метаклассу
    Constructor    ctor = 
                pClass->GetConstructor<    ConstructorParamList>();

    //Создание экземпляра обьекта с вызовом полученного конструктора
    TheObject* pObj = ctor("Vasya", 27, "London", 12 );

MyTypeName(const std_string&, unsigned char, const std_string&, unsigned int );