class DataTable {
  public DataRowCollection Rows {get;}
  public DataColumnCollection Columns {get;}
}

class DataColumnCollection {
  public int Count {get;}
  public DataColumn this[int index] {get;}
}

class DataColumn {
  public string ColumnName {get;}
  public Type DataType {get;}
}

class DataRowCollection {
  public int Count {get;}
  public DataRow this[int index] {get;}
}

class DataRow {
  public object this[DataColumn] {get; set;}
}

public TestA
{
  [Editable]
  string Server;
  [Editable, Serializable]
  string ProcessName;  
  typedef (select Field from TestA.Fields where Serializable in Field.Attributes) SerializablePropertiesMap;
  typedef (select Field from TestA.Fields where Editable in Field.Attributes) EditablePropertiesMap;
}

public class Accumulator< T > {
    private T val_;
    public void Add( T x ) {
        val_ = val_ + x;  //  oops!  what +?
    }
}

public interface Addable< T > {
    void Add( T x, T y );
}

public class Accumulator< T, AddT > where AddT : Addable< T > {
    private T val_;
    public void Add( T x ) {
        AddT addt = new AddT();        //  even this is impossible
        val_ = addt.AddT( val_, x );
    }
}

public class AddableInt : Addable< int > {
    public void Add( int x, int y ) { return x + y; }
}

//  now I can do this
Accumulator< int, AddableInt > acc;

public class Accumulator< T, AddT > where AddT : Addable< T > {
    private T val_;
    private AddT addt_;
    public Accumulator( AddT a ) { addt_ = a; }    //  come on!
    public void Add( T x ) {
        val_ = addt_.Add( val_, x );        //  virtual function call!
    }
}

public class Accumulator< T > {
    private T val_;
    private Addable< T > addt_;
    //  ...
}

template < typename T >
class Accumulator
{
    T val_;
public:    Accumulator< T > & operator+=( T const & x ) {
        val_ = val_ + x;    //  even val_ += x;
                    //  this call will be resolved at compile time
        return * this;
    }
};

template< typename Iter >
Iter find( Iter begin, Iter end
    , typename Iter::value_type const & what
        // this is impossible in C# with generics,
        // because value_type is a typedef
    ) {
    for ( Iter it = begin; it != end; ++it )
        if ( * it == what )
            break;
    return it;
}

//  usage
vector< int > v;
vector< int >::iterator pos = find( v.begin(), v.end(), 5 );

public class Finder< EnumT, ElemT, CompT > where
    EnumT : IEnumerator< ElemT >
    , CompT : IComparable< ElemT >
{
    public Finder( CompT comp ) { comp_ = comp; }
    public EnumT Find( EnumT it, ElemT x ) {
        while ( it.MoveNext() )
            if ( ! comp_.CompareTo( it.Current, x ) )
                break;
        return it;
    }
}

//  usage
class CompareInt : IComparable< int >
{
    public int CompareTo( int x, int y ) { return x - y; }
}

//  Enumerator< int > should be already defined

ArrayList< int > v;
Finder< Enumerator< int >, int, CompareInt > find = new Finder < Enumerator< int >, int, CompareInt >( new CompareInt() );
Enumerator< int > pos = find.Find( v.GetEnumerator(), 5 );

VD>А новой парадигмы и не нужно. Нужно расширение дотнета позволяющее писать более эффективные и безопастные приложения. Парадигмы же достаточно и той что есть.

void TestA::DoSomething()
{
   data<m_Server>() = "asdf";
}

#define DDX_DATA(theType) data((theType*)0)

void TestA::DoSomething()
{
   DDX_DATA(m_Server) = "asdf";
}

А>public TestA
А>{
А>  [Editable]
А>  string Server;
А>  [Editable, Serializable]
А>  string ProcessName;  
А>  typedef (select Field from TestA.Fields where Serializable in Field.Attributes) SerializablePropertiesMap;
А>  typedef (select Field from TestA.Fields where Editable in Field.Attributes) EditablePropertiesMap;
А>}
А>

S>>Код был приведен для случая, когда все поля сохраняются — там параметром шаблона класс Ser (typedef RegistrySerializer Ser указан. Если какое-то поле не надо сохранять, то вместо него указывается NopSerializer. То же и для DDX — там просто 0 вместо функции надо передать. Есть еще параметр для DDV, там по дефолту NOPValidator.

typedef ddx::member<BOOL, IDC_REMOVECF, Ser, &DDX_Check, Logger> m_RemoveCF;
typedef ddx::validated_float<IDC_TIME_LIMIT, ddx::NOPSerializer, ddx::NOPLogger, 0.f, 100.f> m_TimeLimit;

ddx::members<TYPELIST_2(m_RemoveCF, m_TimeLimit)> ddxMembers;

VD>Проблема (у тебя ) в том, что мой грид будет доступен в дизайнере и я настрою колонки за несколько секунд, а ты будешь длбить код как пака крло.

... = {
col_map(0, "Attr1"),
col_map(1, "Attr1"),
col_map(2, "Attr1"),
col_map(-1, "") // Финализатор описания
}

AVK>Проблема в том что этот самый std::map при наличии rtti не нужен.

<SomeValue>
  <Order>
    <OrderName>ABCDEF</OrderName>
  </Order>
  <Order>
    <OrderName>GHIJKL</OrderName>
  </Order>
</SomeValue>

<SomeValue>
  <Order2>
    <OrderNm>ABCDEF</OrderNm>
  </Order2>
  <Order2>
    <OrderNm>GHIJKL</OrderNm>
  </Order2>
</SomeValue>