public abstract class RecordHeader : EditableObject
{
    [MaxLength(50), Required]
    public abstract string Last { get; set; }
    [MaxLength(50), Required]
    public abstract string First { get; set; }
    [MaxLength(50), NullValue("")]
    public abstract string Middle { get; set; }
}

[TableName("Person")]
public abstract class Person : EditableObject
{
    [Required]                     public abstract Gender Gender     { get; set; }
    [MapIgnore(false)]
    public abstract RecordHeader Name { get; set; }
    [PrimaryKey, NonUpdatable]
    [MapField("PersonID")]         public abstract int    ID         { get; set; }
}

public abstract class PersonAccessor : DataAccessor
{
    public abstract Person SelectByName(Person p);
}

[Test]
public void SelectByNameTest()
{
    Person e = TypeAccessor.CreateInstance<Person>();
    e.Name.First = "John";
    e.Name.Last = "Pupkin";

    Person p = _da.SelectByName(e);
    Assert.AreEqual(1, p.ID);
}

public IDbDataParameter[] CreateParameters(object obj, params IDbDataParameter[] commandParameters)
        {
            ArrayList    paramList = new ArrayList();
            ObjectMapper om        = _mappingSchema.GetObjectMapper(obj.GetType());

            foreach (MemberMapper mm in om)
            {
                Type type = mm.Type;
                object value = mm.GetValue(obj);

                if (TypeHelper.IsScalar(type))
                {
                    string name  = _dataProvider.Convert(mm.Name, ConvertType.NameToParameter).ToString();

                    paramList.Add(mm.MapMemberInfo.Nullable || value == null?
                        NullParameter(name, value, mm.MapMemberInfo.NullValue):
                        Parameter    (name, value));
                }
                else
                {
                    paramList.AddRange(CreateParameters(value));
                }
            }

            if (commandParameters != null)
                foreach (IDbDataParameter p in commandParameters)
                    paramList.Add(p);

            return (IDbDataParameter[])paramList.ToArray(typeof(IDbDataParameter));
        }

        public abstract class RecordHeader
{
    public abstract string Name { get; set; }
}

public abstract class Person : EditableObject
{
    public abstract RecordHeader Header { get; set; }
    public abstract string Name { get; set; }
}

protected virtual MemberMapper CreateComplexMapper(MemberMapper mm, MemberAccessor ma)
{
    MapMemberInfo cmi = new MapMemberInfo();

    cmi.MemberAccessor = ma;
    cmi.Type = mm.Type;
    cmi.MappingSchema = mm.MappingSchema;
    cmi.Name = mm.Name;
    cmi.MemberName = mm.MemberName;

    MemberMapper mapper = new MemberMapper.ComplexMapper(mm);

    mapper.Init(cmi);

    return mapper;
}

public virtual void Init(MappingSchema mappingSchema, Type type)
{
    if (type == null) throw new ArgumentNullException("type");

    _typeAccessor  = TypeAccessor.GetAccessor(type);
    _mappingSchema = mappingSchema;
    _extension     = TypeExtension.GetTypeExtenstion(
        _typeAccessor.OriginalType, mappingSchema.Extensions);

    foreach (MemberAccessor ma in _typeAccessor)
    {
        if (GetIgnore(ma))
            continue;

        MapMemberInfo mi = new MapMemberInfo();

        mi.MemberAccessor  = ma;
        mi.Type            = ma.Type;
        mi.MappingSchema   = mappingSchema;
        mi.MemberExtension = _extension[ma.Name];
        mi.Name            = GetFieldName   (ma);
        mi.MemberName      = ma.Name;
        mi.Trimmable       = GetTrimmable   (ma);
        mi.MapValues       = GetMapValues   (ma);
        mi.DefaultValue    = GetDefaultValue(ma);
        mi.Nullable        = GetNullable    (ma);
        mi.NullValue       = GetNullValue   (ma, mi.Nullable);

        Add(CreateMemberMapper(mi));

        if (!TypeHelper.IsScalar(ma.Type))
        {
            ObjectMapper com = Map.GetObjectMapper(ma.Type);
            foreach (MemberMapper cmm in com)
            {
                Add(CreateComplexMapper(cmm, ma));
            }
        }
    }

    /* А это выкинуть за ненадобностью. А можно и оставить, чтобы и First и Name.First работали.
    foreach (AttributeExtension ae in _extension.Attributes["MapField"])
    {
        string mapName  = (string)ae["MapName"];
        string origName = (string)ae["OrigName"];

        if (mapName == null || origName == null)
            throw new MappingException(string.Format(
                "Type '{0}' has invalid  extension. MapField MapName='{1}' OrigName='{2}'.",
                    type.FullName, mapName, origName));

        EnsureMapper(mapName, origName);
    }

    foreach (MapFieldAttribute attr in MapFieldAttributes)
        EnsureMapper(attr.MapName, attr.OrigName);
    */
}

public abstract class RecordHeader : EditableObject
{
    [MaxLength(50), Required]      public abstract string Last   { get; set; }
    [MaxLength(50), Required]      public abstract string First  { get; set; }
    [MaxLength(50), NullValue("")] public abstract string Middle { get; set; }
}

[TableName("Person")]
[MapField("FirstName",  "Name.First")]
[MapField("LastName",   "Name.Last")]
[MapField("MiddleName", "Name.Middle")]
public abstract class Person : EditableObject
{
    [Required]                 public abstract Gender       Gender { get; set; }
                               public abstract RecordHeader Name   { get; set; }
    [PrimaryKey, NonUpdatable]
    [MapField("PersonID")]     public abstract int          ID     { get; set; }
}

IT>[MapField("FirstName",  "Name.First")]
IT>[MapField("LastName",   "Name.Last")]
IT>[MapField("MiddleName", "Name.Middle")]
IT>public abstract class Person : EditableObject
IT>{
IT>

• Всё должно быть максимально очевидно и интуитивно понятно.
  
• Все членомаперы должны быть доступны для IEnumerate'ния сразу по созданию мапера.
  
• Вложенные типы должны учитываться в CRUDL операциях и в вызове хранимок из датаакцесоров.
  
• Вложенные типы могут быть структурами, классами и абстрактными классами. (Тут всё почти ок, об этом дальше.)

public abstract class RecordHeader
{
    public abstract string Last { get; set; }
    public abstract string First { get; set; }
    public abstract string Middle { get; set; }
}

public abstract class Person
{
    [MapIgnore(false), Prefix(null)]
    public abstract RecordHeader Name { get; set; } // Префикса нету; Last, First & Middle попадают в Person как родные.
    [MapIgnore(false), Prefix("Foo")]
    public abstract RecordHeader AlsoName { get; set; } // Last, First & Middle попадают в Person как Foo.Last, Foo.First & Foo.Middle
    [MapIgnore(false)]
    public abstract RecordHeader NameAgain { get; set; } // Last, First & Middle попадают в Person как NameAgain.Last, NameAgain.First & NameAgain.Middle
}

        public abstract class RecordHeader
        {
            public abstract string Last { get; set; }
            public abstract string First { get; set; }
            public abstract string Middle { get; set; }
        }

        public abstract class Person
        {
            [MapIgnore(false)]
            public abstract RecordHeader Name { get; set; }
            public abstract int ID { get; set; }
        }

        [Test]
        public void InnerTest()
        {
            ObjectMapper om = Map.GetObjectMapper(typeof(Person));

            Person o = (Person)om.CreateInstance();

            om.SetValue(o, "Name.First", "Crazy");
            om.SetValue(o, "Name.Last", "Frog");

            Person p2 = Map.ObjectToObject<Person>(o);

            Assert.AreEqual(p2.Name.First, o.Name.First);
            Assert.AreEqual(p2.Name.Last, o.Name.Last);
        }

            // ...
            Type valueType  = value.GetType();
            Type memberType = mapInfo.Type;

            if (valueType != memberType)
            {
            // ...

if (!memberType.IsAssignableFrom(valueType))

o.Name.First = "Foo"

p2.Name.First станет "Foo"

IT>[MapField("FirstName",  "Name.First")]
IT>[MapField("LastName",   "Name.Last")]
IT>[MapField("MiddleName", "Name.Middle")]
IT>public abstract class Person : EditableObject
IT>{
IT>

        public FieldBuilder GetIndexField(string[] index)
        {
            string id = "index$" + string.Join(".", index);

public abstract class RecordHeader : EditableObject
{
    [MaxLength(50), Required]
    public abstract string Last { get; set; }
    [MaxLength(50), Required]
    public abstract string First { get; set; }
    [MaxLength(50), NullValue("")]
    public abstract string Middle { get; set; }
}

public abstract Person
{
    [MapIgnore(false)]
    public abstract RecordHeader Name { get; set; }
    [PrimaryKey, NonUpdatable]
    public abstract string First { get; set; }
}

    namespace BLTTest
{
    [TableName("Rules")]
    [MapField("RuleSetID", "RuleSetInfo.ID")]
    [MapField("RuleSetName", "RuleSetInfo.Name")]
        //Правило
    public abstract class Rule
    {
        [MapField("RuleID")]
        public abstract int ID { get; set; }

        [MapField("RuleName")]
        public abstract String Name { get; set; }

        public abstract RuleSet RuleSetInfo { get; set; }
    }

    [TableName("RuleSets")]
        ////Набор правил
    public abstract class RuleSet
    {
        [MapField("RuleSetID")]
        public abstract int ID { get; set; }

        [MapField("RuleSetName")]
        public abstract String Name { get; set; }
    }
}