public class DataRowAdapter : IDataRecord
{
    #region Members
    private DataRow _Row;
    #endregion

    #region Properties
    public DataRow Row
    {
        get { return _Row; }
    }
    #endregion

    #region Constructors
    public DataRowAdapter(DataRow row)
    {
        _Row = row;
    }
    #endregion

    #region IDataRecord Implementation
    public object this[string name]
    {
        get { return _Row[name]; }
    }

    public object this[int i]
    {
        get { return _Row[i]; }
    }

    public int FieldCount
    {
        get { return _Row.Table.Columns.Count; }
    }

    public bool GetBoolean(int i)
    {
        return Convert.ToBoolean(_Row[i]);
    }

    public byte GetByte(int i)
    {
        return Convert.ToByte(_Row[i]);
    }

    public long GetBytes(int i, long fieldOffset, byte[] buffer, int bufferoffset, int length)
    {
        throw new NotSupportedException("GetBytes is not supported.");
    }

    public char GetChar(int i)
    {
        return Convert.ToChar(_Row[i]);
    }

    public long GetChars(int i, long fieldoffset, char[] buffer, int bufferoffset, int length)
    {
        throw new NotSupportedException("GetChars is not supported.");
    }

    public IDataReader GetData(int i)
    {
        throw new NotSupportedException("GetData is not supported.");
    }

    public string GetDataTypeName(int i)
    {
        return _Row[i].GetType().Name;
    }

    public DateTime GetDateTime(int i)
    {
        return Convert.ToDateTime(_Row[i]);
    }

    public decimal GetDecimal(int i)
    {
        return Convert.ToDecimal(_Row[i]);
    }

    public double GetDouble(int i)
    {
        return Convert.ToDouble(_Row[i]);
    }

    public Type GetFieldType(int i)
    {
        return _Row[i].GetType();
    }

    public float GetFloat(int i)
    {
        return Convert.ToSingle(_Row[i]);
    }

    public Guid GetGuid(int i)
    {
        return (Guid)_Row[i];
    }

    public short GetInt16(int i)
    {
        return Convert.ToInt16(_Row[i]);
    }

    public int GetInt32(int i)
    {
        return Convert.ToInt32(_Row[i]);
    }

    public long GetInt64(int i)
    {
        return Convert.ToInt64(_Row[i]);
    }

    public string GetName(int i)
    {
        return _Row.Table.Columns[i].ColumnName;
    }

    public int GetOrdinal(string name)
    {
        return _Row.Table.Columns.IndexOf(name);
    }

    public string GetString(int i)
    {
        return _Row[i].ToString();
    }

    public object GetValue(int i)
    {
        return _Row[i];
    }

    public int GetValues(object[] values)
    {
        values = _Row.ItemArray;
        return _Row.ItemArray.GetLength(0);
    }

    public bool IsDBNull(int i)
    {
        return Convert.IsDBNull(_Row[i]);
    }
    #endregion
}

public class Human
{
    public int ID { get; set; }
    public string FirstName { get; set; }
}

public class Human
{
    public int ID { get; set; }
    public string FirstName { get; set; }
    public string FooX { get; set; }
    public int? Foo2 { get; set; }
}

/// <summary>
/// Маппер
/// </summary>
public class DataMapper
{
    /// <summary>
    /// Выбор сопоставления из словаря
    /// </summary>
    /// <param name="columnName"></param>
    /// <param name="expressions"></param>
    /// <returns></returns>
    private static string ResolveSchema(string columnName, Dictionary<string, string> expressions)
    {
        string result = columnName;
        if (expressions.ContainsKey(columnName))
        {
            result = expressions[columnName];
        }
        return result;
    }

    /// <summary>
    /// Словарь сопоставлений
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="obj"></param>
    /// <param name="schema"></param>
    /// <returns></returns>
    private static Dictionary<string, string> ResolveExpression<T>(T obj, Expression<Func<T, object, object>>[] schema)
    {
        var result = new Dictionary<string, string>();
        foreach (var sch in schema)
        {
            var compile = sch.Compile()(obj, null);
            var value = compile.GetType().GetProperties()[1].GetValue(compile, null);
            result.Add(value.ToString(), (sch.Body as NewExpression).Members[0].Name);
        }
        return result;
    }

    /// <summary>
    /// Маппинг DataRow
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="row"></param>
    /// <returns></returns>
    public static T Map<T>(DataRow row, params Expression<Func<T, object, object>>[] schema) where T : new()
    {
        T result = new T();
        var expressions = ResolveExpression<T>(result, schema);

        foreach (DataColumn column in row.Table.Columns)
        {
            string propname = ResolveSchema(column.ColumnName, expressions);

            var property = typeof(T).GetProperty(propname);
            if (property != null)
            {
                TypeCode codeObj = property.PropertyType.IsGenericType ?
                    Type.GetTypeCode(property.PropertyType.GetGenericArguments()[0]) :
                    Type.GetTypeCode(property.PropertyType);

                TypeCode codeRow = Type.GetTypeCode(row[column.ColumnName].GetType());

                if (codeObj == codeRow)
                {
                    object value = row[column.ColumnName] == DBNull.Value ? null : row[column.ColumnName];
                    property.SetValue(result, value, null);
                }
            }
        }
        return result;
    }

    /// <summary>
    /// Маппинг DataTable
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="table"></param>
    /// <returns></returns>
    /// <example>
    /// var list = DataMapper.Map<BusinessClass>(table,
    ///        (a, b) => new { a.PropertyForMapA, f = "PropertyForMap1" }, 
    ///        (a, b) => new { a.PropertyForMapB, f = "PropertyForMap2" }
    ///    );
    /// </example>
    public static IEnumerable<T> Map<T>(DataTable table, params Expression<Func<T, object, object>>[] schema) where T : new()
    {
        return table.AsEnumerable().Select(d => Map<T>(d, schema));
    }

    /// <summary>
    /// Маппинг IDataReader
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="reader"></param>
    /// <param name="schema"></param>
    /// <returns></returns>
    public static IEnumerable<T> Map<T>(IDataReader reader, params Expression<Func<T, object, object>>[] schema) where T : new()
    {
        DataTable table = new DataTable();
        table.Load(reader);
        return Map<T>(table, schema);
    }
}