var mapper = ObjectMapperManager.DefaultInstance.GetMapper<Source, Destination>(new DefaultMapConfig().NullSubstitution<int?, int>(() => -1));
...
Destination d = mapper.Map(new Source());

new DefaultMapConfig().PostProcess<Foo>( (value, state) => Console.WriteLine("Post processing a Foo or it's descendant: " + value.ToString())
)

new DefaultMapConfig().PostProcess<object>( (value, state) => Console.WriteLine("Post processing: " + value.ToString()) )

/// <summary>
/// Define custom type converter
/// </summary>
/// <typeparam name="From">Source type</typeparam>
/// <typeparam name="To">Destination type</typeparam>
/// <param name="converter">Function which converts an inctance of the source type to an instance of the destination type</param>
/// <returns></returns>
DefaultMapConfig ConvertUsing<From, To>(Func<From, To> converter)

public class A
{public string fld1;public string fld2;
}public class B
{public string fld1 = "B::fld1";public string fld2 = "B::fld2";
}[TestMethod]
public void Test_CustomConverter2()
{A a = Context.objMan.GetMapper<B, A>(new DefaultMapConfig().ConvertUsing<object, string>(v => "converted " + v.ToString())).Map(new B());Assert.AreEqual("converted B::fld1", a.fld1);Assert.AreEqual("converted B::fld2", a.fld2);
}

/// <summary>
/// Define conversion for a generic. It is able to convert not one particular class but all generic family
/// providing a generic converter.
/// </summary>
/// <param name="from">Type of source. Can be also generic class or abstract array.</param>
/// <param name="to">Type of destination. Can be also generic class or abstract array.</param>
/// <param name="converterProvider">Provider for getting detailed information about generic conversion</param>
/// <returns></returns>
public IMappingConfigurator ConvertGeneric(Type from, Type to, ICustomConverterProvider converterProvider);
...
/// <summary>
/// Provider for getting detailed information about generic conversion
/// </summary>
public interface ICustomConverterProvider
{/// <summary>/// Getting detailed information about generic conversion/// </summary>/// <param name="from">Type of source. Can be also generic class or abstract array.</param>/// <param name="to">Type of destination. Can be also generic class or abstract array.</param>/// <param name="mappingConfig">Current mapping configuration</param>/// <returns>Detailed description of a generic converter.</returns>CustomConverterDescriptor GetCustomConverterDescr(Type from, Type to, MapConfigBaseImpl mappingConfig);
}
...
/// <summary>
/// Detailed description of a generic converter.
/// </summary>
public class CustomConverterDescriptor
{/// <summary>/// Type of class which performs conversion. This class can be generic which will be parameterized with types /// returned from "ConverterClassTypeArguments" property./// </summary>public Type ConverterImplementation { get; set; }/// <summary>/// Name of conversion method of class which is specified by "ConverterImplementation" property./// </summary>public string ConversionMethodName { get; set; }/// <summary>/// Type arguments for parameterizing generic converter specified by "ConverterImplementation" property./// </summary>public Type[] ConverterClassTypeArguments { get; set; }
}

class HashSetToListConverter<T>
{public List<T> Convert(HashSet<T> from, object state){if (from == null){return null;}return from.ToList();}
}

var mapper = ObjectMapperManager.DefaultInstance.GetMapper<Source, Destination>(new DefaultMapConfig().ConvertGeneric(typeof(HashSet<>), typeof(List<>), new DefaultCustomConverterProvider(typeof(HashSetToListConverter<>))));

class Source
{public field int? i;
}
class Destination
{public field int i;
}

var mapper = ObjectMapperManager.DefaultInstance.GetMapper<Source, Destination>(new DefaultMapConfig().NullSubstitution<int?, int>(() => -1));
var d = mapper.Map(new Source());
Assert.AreEqual(-1, d.i);

[TestMethod]
public class B
{public string str1 = "B::str1";
}public class A
{public string str1 = "A::str1";
}public void GeneralTests_Ignore()
{var a = ObjectMapperManager.DefaultInstance.GetMapper<B, A>(new DefaultMapConfig().IgnoreMembers<B, A>(new[]{"str1"})).Map(new B());Assert.AreEqual("A::str1", a.str1);
}

public class ConstructBy_Source
{public class NestedClass{public string str = "ConstructBy_Source::str";}public NestedClass field = new NestedClass();
}public class ConstructBy_Destination
{public class NestedClass{public string str;public int i;public NestedClass(int i){str = "ConstructBy_Destination::str";this.i = i;}}public NestedClass field;
}
[TestMethod]
public void ConstructByTest()
{var mapper = ObjectMapperManager.DefaultInstance.GetMapper<ConstructBy_Source, ConstructBy_Destination>(new DefaultMapConfig().ConstructBy <ConstructBy_Destination.NestedClass>(() => new ConstructBy_Destination.NestedClass(3)));var d = mapper.Map(new ConstructBy_Source());Assert.AreEqual("ConstructBy_Source::str", d.field.str);Assert.AreEqual(3, d.field.i);
}

public class A1
{public int fld1;public string fld2;
}public class A2
{public string[] fld3;
}public class A3
{public A1 a1 = new A1();public A2 a2 = new A2();
}public class B3
{public A1 a1 = new A1();public A2 a2 = new A2();
}b = new B3();
Context.objMan.GetMapper<B3, A3>(new DefaultMapConfig().ShallowMap<A1>().DeepMap<A2>()).Map(b, a);
b.a1.fld1 = 333;
b.a2.fld3 = new string[1];Assert.AreEqual(333, a.a1.fld1); // shallow map
Assert.IsNull(a.a2.fld3); // deep map

public class Source
{public string field1 = "Source::field1";public string field2 = "Source::field2";public string field3 = "Source::field3";
}public class Destination
{public string m_field1;public string m_field2;public string m_field3;
}[TestMethod]
public void GeneralTests_Example2()
{var mapper = ObjectMapperManager.DefaultInstance.GetMapper<Source, Destination>(new DefaultMapConfig().MatchMembers((m1, m2) => "m_" + m1 == m2));Source src = new Source();Destination dst = mapper.Map(src);Assert.AreEqual(src.field1, dst.m_field1);Assert.AreEqual(src.field2, dst.m_field2);Assert.AreEqual(src.field3, dst.m_field3);
}

/// <summary>
/// Define postprocessor for specified type
/// </summary>
/// <typeparam name="T">Objects of this type and all it's descendants will be postprocessed</typeparam>
/// <param name="postProcessor"></param>
/// <returns></returns>
public IMappingConfigurator PostProcess<T>(ValuesPostProcessor<T> postProcessor)

public class Destination
{public List<int> list;
}public class Source
{public int[] list;
}var mapper = ObjectMapperManager.DefaultInstance.GetMapper<Source, Destination>(new DefaultMapConfig().PostProcess<Destination>( (destination, state) => { destination.list.Sort(); return destination;} ));