var a = ObjectsMapperManager.DefaultInstance.GetMapper<B, A>(
        new DefaultMapConfig().IgnoreMembers<B, A>(new[]{"str1"})
    ).Map(new B());

H>var a = ObjectsMapperManager.DefaultInstance.GetMapper<B, A>(
H>        new DefaultMapConfig().IgnoreMembers<B, A>(new[]{"str1"})
H>    ).Map(new B());
H>

// Это наш собственный атрибут. Нас никто не заставляет использовать атрибуты, но допустим удобней/привычнее
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
public class MyIgnoreAttribute : Attribute
{
}

// Класс-оригинал
public class IgnoreByAttributesSrc
{
    // Делаем так, чтобы первое поле не копировалось
    [MyIgnoreAttribute]
    public string str1 = "IgnoreByAttributesSrc::str1";

    public string str2 = "IgnoreByAttributesSrc::str2";
}

// Класс-копия
public class IgnoreByAttributesDst
{
    public string str1 = "IgnoreByAttributesDst::str1";
    public string str2 = "IgnoreByAttributesDst::str2";
}

public class MyConfigurator : DefaultMapConfig
{
    //Переопределяем метод, который вызывается для конфигурирования меппинга и добавляем вызов IgnoreMembers
    //в соответствии с нашей логикой - атрибутом
    public override IMappingOperation[] GetMappingOperations(Type from, Type to)
    {
        base.IgnoreMembers<object, object>(GetIgnoreFields(from).Concat(GetIgnoreFields(to)).ToArray());
        return base.GetMappingOperations(from, to);
    }

    //Метод возвращает список полей и свойств, помеченных атрибутом
    private IEnumerable<string> GetIgnoreFields(Type type)
    {
        return type
            .GetFields()
            .Where(
                f => f.GetCustomAttributes(typeof(MyIgnoreAttribute), false).Length > 0
            )
            .Select(f => f.Name)
            .Concat(
                type
                .GetProperties()
                .Where(
                    p => p.GetCustomAttributes(typeof(MyIgnoreAttribute), false).Length > 0
                )
                .Select(p => p.Name)
            );
    }
}

[TestMethod]
public void Test()
{
    var mapper = ObjectsMapperManager.DefaultInstance.GetMapper<IgnoreByAttributesSrc, IgnoreByAttributesDst>(new MyConfigurator());
    var dst = mapper.Map(new IgnoreByAttributesSrc());
    Assert.AreEqual("IgnoreByAttributesDst::str1", dst.str1);
    Assert.AreEqual("IgnoreByAttributesSrc::str2", dst.str2);
}

K>Вообще-то БЛТ в первую очередь маппер, а у же потом всё остальное. Вот автор увидит топик и расскажет подробнее

public class Destination
{
    public class Int
    {
        public string str2;
    }

    public string str1;
    public Int i;
}

public class Source
{
    public class Int
    {
        public string str2 = "B1::Int::str2";
    }

    public string str1 = "B1::str1";
    public Int i = new Int();
}

public class A2
{
    public string str1;
    public string str2;
    public string str3;
    public string str4;
    public string str5;
    public string str6;
    public string str7;
    public string str8;
    public string str9;

    public int n1;
    public int n2;
    public int n3;
    public int n4;
    public int n5;
    public int n6;
    public int n7;
}

public class B2
{
    public string str1 = "str1";
    public string str2 = "str2";
    public string str3 = "str3";
    public string str4 = "str4";
    public string str5 = "str5";
    public string str6 = "str6";
    public string str7 = "str7";
    public string str8 = "str8";
    public string str9 = "str9";

    public int n1 = 1;
    public long n2 = 2;
    public short n3 = 3;
    public byte n4 = 4;
    public decimal n5 = 5;
    public float n6 = 6;
    public int n7 = 7;

}

static long BenchBLToolkit_Simple(int mappingsCount)
{
    var s = new B2();
    var d = new A2();

    d = BLToolkit.Mapping.Map.ObjectToObject<A2>(s);

    var sw = new Stopwatch();
    sw.Start();
    for (int i = 0; i < mappingsCount; ++i)
    {
        d = BLToolkit.Mapping.Map.ObjectToObject<A2>(s);
    }
    sw.Stop();
    return sw.ElapsedMilliseconds;
}

static long EmitMapper_Simple(int mappingsCount)
{
    var mapper = ObjectsMapperManager.DefaultInstance.GetMapper<B2, A2>();
    var s = new B2();
    var d = new A2();

    var sw = new Stopwatch();
    sw.Start();
    for (int i = 0; i < mappingsCount; ++i)
    {
        mapper.Map(s, d);
    }
    sw.Stop();
    return sw.ElapsedMilliseconds;
}

Emit Mapper (simple): 130 milliseconds
BLToolkit (simple): 32287 milliseconds

    [Serializable]
    [XmlRoot(ElementName = "object")]
    public class OrgNode
    {
        [XmlIgnore]
        public OrgNode ParentNode { get; set; }

        #region XmlAttributes

        [XmlAttribute("otype")]
        public string Type { get; set; }

        [XmlAttribute("id")]
        public string Id { get; set; }

        [XmlAttribute("prel")]
        public string ParentRelation { get; set; }

        [XmlAttribute("alias")]
        public string Alias { get; set; }

        #endregion

        #region XmlTags

        [XmlElement("description")]
        public string Description { get; set; }

        #endregion

        private OrgNodeCollection _children;

        public OrgNode()
        {
            Children = new OrgNodeCollection();
        }

        [XmlArray("children")]
        [XmlArrayItem("object")]
        public OrgNodeCollection Children
        {
            get { return _children; }
            set { _children = value; _children.Parent = this; }
        }
    }
    
    [Serializable]
    public class OrgNodeCollection : List<OrgNode>
    {
        private OrgNode _parent;

        public OrgNode Parent
        {
            get { return _parent; }
            set
            {
                _parent = value;
                foreach (var collection in this)
                {
                    collection.ParentNode = Parent;
                }
            }
        }

        public new void Add(OrgNode item)
        {
            base.Add(item);
            item.ParentNode = Parent;
        }
    }

private static readonly Mapper<OrgNode, OrgNode> Mapper = ObjectsMapperManager.DefaultInstance.GetMapper<OrgNode, OrgNode>(new DefaultMapConfig().DeepMap<OrgNode>());

_savedObject = Mapper.Map<OrgNode, OrgNode>(node);

_savedObject.Children.Clear();

А>private static readonly Mapper<OrgNode, OrgNode> Mapper = ObjectsMapperManager.DefaultInstance.GetMapper<OrgNode, OrgNode>(new DefaultMapConfig().DeepMap<OrgNode>());

А>_savedObject = Mapper.Map<OrgNode, OrgNode>(node);
А>

А>_savedObject.Children.Clear();
А>

private static readonly Mapper<OrgNode, OrgNode> Mapper = 
    ObjectsMapperManager.DefaultInstance.GetMapper<OrgNode, OrgNode>(new DefaultMapConfig().DeepMap());

static long BenchBLToolkit_Simple(int mappingsCount)
{
    var s = new B2();
    var d = new A2();

    d = BLToolkit.Mapping.Map.ObjectToObject<A2>(s);

    var sw = new Stopwatch();
    sw.Start();
    for (int i = 0; i < mappingsCount; ++i)
    {
        d = BLToolkit.Mapping.Map.ObjectToObject<A2>(s);
    }
    sw.Stop();
    return sw.ElapsedMilliseconds;
}