using System;
using System.Data.Common;
using System.Data;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.IO;

namespace Developpez.Dotnet.Data
{
    /// <summary>
    /// Fournit des méthodes d'extension pour faciliter l'utilisation des classes ADO.NET
    /// </summary>
    public static class DataExtensions
    {
        #region Méthodes d'extension pour DbConnection

        /// <summary>
        /// Crée une commande à partir d'une connection et d'une requête
        /// </summary>
        /// <param name="connection">La connection</param>
        /// <param name="commandText">Le texte de la requête</param>
        /// <returns>Une commande pour la connexion et la requête spécifiées</returns>
        public static DbCommand CreateCommand(this DbConnection connection, string commandText)
        {
            DbCommand command = connection.CreateCommand();
            command.CommandText = commandText;
            return command;
        }

        #endregion

        #region Méthodes d'extension pour DbCommand

        /// <summary>
        /// Ajoute à la commande un paramètre avec les options spécifiées
        /// </summary>
        /// <param name="command">La commande à laquelle ajouter un paramètre</param>
        /// <param name="name">Le nom du paramètre</param>
        /// <param name="dbType">Le type du paramètre</param>
        /// <returns>Le paramètre créé</returns>
        public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType)
        {
            return AddParameter(command, name, dbType, 0, ParameterDirection.Input);
        }

        /// <summary>
        /// Ajoute à la commande un paramètre avec les options spécifiées
        /// </summary>
        /// <param name="command">La commande à laquelle ajouter un paramètre</param>
        /// <param name="name">Le nom du paramètre</param>
        /// <param name="dbType">Le type du paramètre</param>
        /// <param name="size">La taille du paramètre</param>
        /// <returns>Le paramètre créé</returns>
        public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType, int size)
        {
            return AddParameter(command, name, dbType, size, ParameterDirection.Input);
        }

        /// <summary>
        /// Ajoute à la commande un paramètre avec les options spécifiées
        /// </summary>
        /// <param name="command">La commande à laquelle ajouter un paramètre</param>
        /// <param name="name">Le nom du paramètre</param>
        /// <param name="dbType">Le type du paramètre</param>
        /// <param name="direction">La direction du paramètre</param>
        /// <returns>Le paramètre créé</returns>
        public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType, ParameterDirection direction)
        {
            DbParameter parameter = command.CreateParameter();
            parameter.ParameterName = name;
            parameter.DbType = dbType;
            parameter.Direction = direction;
            command.Parameters.Add(parameter);
            return parameter;
        }

        /// <summary>
        /// Ajoute à la commande un paramètre avec les options spécifiées
        /// </summary>
        /// <param name="command">La commande à laquelle ajouter un paramètre</param>
        /// <param name="name">Le nom du paramètre</param>
        /// <param name="dbType">Le type du paramètre</param>
        /// <param name="size">La taille du paramètre</param>
        /// <param name="direction">La direction du paramètre</param>
        /// <returns>Le paramètre créé</returns>
        public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType, int size, ParameterDirection direction)
        {
            DbParameter parameter = command.CreateParameter();
            parameter.ParameterName = name;
            parameter.DbType = dbType;
            parameter.Direction = direction;
            parameter.Size = size;
            command.Parameters.Add(parameter);
            return parameter;
        }

        #endregion

        #region Méthodes d'extension pour IDataRecord

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Boolean
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static bool GetBoolean(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetBoolean(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Boolean, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static bool GetBooleanOrDefault(this IDataRecord record, string name, bool defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetBoolean(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Byte
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static byte GetByte(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetByte(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Byte, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static byte GetByteOrDefault(this IDataRecord record, string name, byte defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetByte(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Char
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static char GetChar(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetChar(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Char, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static char GetCharOrDefault(this IDataRecord record, string name, char defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetChar(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que DateTime
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static DateTime GetDateTime(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetDateTime(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que DateTime, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static DateTime GetDateTimeOrDefault(this IDataRecord record, string name, DateTime defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetDateTime(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Decimal
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static decimal GetDecimal(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetDecimal(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Decimal, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static decimal GetDecimalOrDefault(this IDataRecord record, string name, decimal defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetDecimal(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Double
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static double GetDouble(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetDouble(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Double, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static double GetDoubleOrDefault(this IDataRecord record, string name, double defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetDouble(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Float
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static float GetFloat(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetFloat(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Float, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static float GetFloatOrDefault(this IDataRecord record, string name, float defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetFloat(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Guid
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static Guid GetGuid(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetGuid(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Guid, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static Guid GetGuidOrDefault(this IDataRecord record, string name, Guid defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetGuid(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Int16
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static short GetInt16(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetInt16(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Int16, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static short GetInt16OrDefault(this IDataRecord record, string name, short defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetInt16(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Int32
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static int GetInt32(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetInt32(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Int32, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static int GetInt32OrDefault(this IDataRecord record, string name, int defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetInt32(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Int64
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static long GetInt64(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetInt64(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que Int64, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static long GetInt64OrDefault(this IDataRecord record, string name, long defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetInt64(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que String
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static string GetString(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetString(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée en tant que String, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static string GetStringOrDefault(this IDataRecord record, string name, string defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetString(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        public static object GetValue(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetValue(i);
        }

        /// <summary>
        /// Récupère la valeur de le colonne spécifiée, ou la valeur par défaut spécifiée si la colonne est DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="defaultValue">La valeur par défault à renvoyer si la colonne vaut DBNull</param>
        /// <returns>La valeur de la colonne, ou la valeur par défaut spécifiée  si la colonne vaut DBNull</returns>
        public static object GetValueOrDefault(this IDataRecord record, string name, object defaultValue)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i) ? defaultValue : record.GetValue(i);
        }


        /// <summary>
        /// Lit un flux binaire de la colonne spécifiée
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à lire</param>
        /// <param name="dataOffset">La position à laquelle commence la lecture dans la colonne</param>
        /// <param name="buffer">Le buffer de destination</param>
        /// <param name="bufferOffset">La position à laquelle commence l'écriture dans le buffer</param>
        /// <param name="length">Le nombre maximum d'octets à lire</param>
        /// <returns>Le nombre d'octets lus</returns>
        public static long GetBytes(this IDataRecord record, string name, long dataOffset, byte[] buffer, int bufferOffset, int length)
        {
            int i = record.GetOrdinal(name);
            return record.GetBytes(i, dataOffset, buffer, bufferOffset, length);
        }

        /// <summary>
        /// Lit un flux de caractères de la colonne spécifiée
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à lire</param>
        /// <param name="dataOffset">La position à laquelle commence la lecture dans la colonne</param>
        /// <param name="buffer">Le buffer de destination</param>
        /// <param name="bufferOffset">La position à laquelle commence l'écriture dans le buffer</param>
        /// <param name="length">Le nombre maximum de caractères à lire</param>
        /// <returns>Le nombre de caractères lus</returns>
        public static long GetChars(this IDataRecord record, string name, long dataOffset, char[] buffer, int bufferOffset, int length)
        {
            int i = record.GetOrdinal(name);
            return record.GetChars(i, dataOffset, buffer, bufferOffset, length);
        }

        /// <summary>
        /// Indique si la colonne spécifiée a la valeur DBNull
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à lire</param>
        /// <returns>True si la colonne vaut DBNull, false sinon</returns>
        public static bool IsDBNull(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.IsDBNull(i);
        }

        /// <summary>
        /// Renvoie le nom du type de données de la colonne spécifiée
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne dont on veut obtenir le type de données</param>
        /// <returns>Le nom du type de données de la colonne</returns>
        public static string GetDataTypeName(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetDataTypeName(i);
        }

        /// <summary>
        /// Renvoie le type .NET de la colonne spécifiée
        /// </summary>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne dont on veut obtenir le type .NET</param>
        /// <returns>Le nom type .NET de la colonne</returns>
        public static Type GetFieldType(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetFieldType(i);
        }

        /// <summary>
        /// Renvoie la valeur de la colonne spécifiée en tant que valeur du type spécifié
        /// </summary>
        /// <typeparam name="T">Le type de retour souhaité</typeparam>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="ordinal">L'index de la colonne à récupérer</param>
        /// <param name="tryConvert">true pour tenter de convertir la valeur si elle n'est pas de type T ; false pour effectuer un cast direct</param>
        /// <returns>La valeur de la colonne</returns>
        /// <exception cref="InvalidCastException">La conversion spécifiée n'est pas valide</exception>
        public static T Field<T>(this IDataRecord record, int ordinal, bool tryConvert)
        {
            if (tryConvert)
                return ConvertT<T>.Convert(record[ordinal]);
            else
                return UnboxT<T>.Unbox(record[ordinal]);
        }

        /// <summary>
        /// Renvoie la valeur de la colonne spécifiée en tant que valeur du type spécifié
        /// </summary>
        /// <typeparam name="T">Le type de retour souhaité</typeparam>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="ordinal">L'index de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        /// <exception cref="InvalidCastException">La conversion spécifiée n'est pas valide</exception>
        public static T Field<T>(this IDataRecord record, int ordinal)
        {
            return record.Field<T>(ordinal, false);
        }

        /// <summary>
        /// Renvoie la valeur de la colonne spécifiée en tant que valeur du type spécifié
        /// </summary>
        /// <typeparam name="T">Le type de retour souhaité</typeparam>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <param name="tryConvert">true pour tenter de convertir la valeur si elle n'est pas de type T ; false pour effectuer un cast direct</param>
        /// <returns>La valeur de la colonne</returns>
        /// <exception cref="InvalidCastException">La conversion spécifiée n'est pas valide</exception>
        public static T Field<T>(this IDataRecord record, string name, bool tryConvert)
        {
            int i = record.GetOrdinal(name);
            return record.Field<T>(i, tryConvert);
        }

        /// <summary>
        /// Renvoie la valeur de la colonne spécifiée en tant que valeur du type spécifié
        /// </summary>
        /// <typeparam name="T">Le type de retour souhaité</typeparam>
        /// <param name="record">Le IDataRecord qui contient les données</param>
        /// <param name="name">Le nom de la colonne à récupérer</param>
        /// <returns>La valeur de la colonne</returns>
        /// <exception cref="InvalidCastException">La conversion spécifiée n'est pas valide</exception>
        public static T Field<T>(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.Field<T>(i, false);
        }

        #region Classes utilitaires UnboxT<T> et ConvertT<T> pour convertir les valeurs de champ

        // Tiré de la classe System.Data.DataRowExtensions de .NET 3.5
        private static class UnboxT<T>
        {
            internal static readonly Converter<object, T> Unbox;

            static UnboxT()
            {
                Unbox = Create(typeof(T));
            }

            private static Converter<object, T> Create(Type type)
            {
                if (!type.IsValueType)
                {
                    return new Converter<object, T>(ReferenceField);
                }
                if ((type.IsGenericType && !type.IsGenericTypeDefinition) && (typeof(Nullable<>) == type.GetGenericTypeDefinition()))
                {
                    return (Converter<object, T>)Delegate.CreateDelegate(typeof(Converter<object, T>), typeof(UnboxT<T>).GetMethod("NullableField", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(new Type[] { type.GetGenericArguments()[0] }));
                }
                return new Converter<object, T>(ValueField);
            }

            private static TElem? NullableField<TElem>(object value) where TElem : struct
            {
                if (DBNull.Value == value)
                {
                    return null;
                }
                return new TElem?((TElem)value);
            }

            private static T ReferenceField(object value)
            {
                if (DBNull.Value != value)
                {
                    return (T)value;
                }
                return default(T);
            }

            private static T ValueField(object value)
            {
                if (DBNull.Value == value)
                {
                    throw new InvalidCastException(string.Format(ExceptionMessages.InvalidCastFromTo, typeof(DBNull), typeof(T)));
                }
                return (T)value;
            }
        }

        private static class ConvertT<T>
        {
            internal static readonly Converter<object, T> Convert;

            static ConvertT()
            {
                Convert = Create(typeof(T));
            }

            private static Converter<object, T> Create(Type type)
            {
                if (!type.IsValueType)
                {
                    return new Converter<object, T>(ReferenceField);
                }
                if ((type.IsGenericType && !type.IsGenericTypeDefinition) && (typeof(Nullable<>) == type.GetGenericTypeDefinition()))
                {
                    return (Converter<object, T>)Delegate.CreateDelegate(typeof(Converter<object, T>), typeof(ConvertT<T>).GetMethod("NullableField", BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(new Type[] { type.GetGenericArguments()[0] }));
                }
                return new Converter<object, T>(ValueField);
            }

            private static TElem? NullableField<TElem>(object value) where TElem : struct
            {
                if (null == value || DBNull.Value == value)
                {
                    return null;
                }
                TElem nonNullValue = (TElem)System.Convert.ChangeType(value, typeof(TElem));
                return new TElem?(nonNullValue);
            }

            private static T ReferenceField(object value)
            {
                if (null != value && DBNull.Value != value)
                {
                    return (T)System.Convert.ChangeType(value, typeof(T));
                }
                return default(T);
            }

            private static T ValueField(object value)
            {
                if (DBNull.Value == value)
                {
                    throw new InvalidCastException(string.Format(ExceptionMessages.InvalidCastFromTo, typeof(DBNull), typeof(T)));
                }
                if (null == value)
                {
                    throw new InvalidCastException(ExceptionMessages.InvalidCastFromNullToValueType);
                }
                return (T)System.Convert.ChangeType(value, typeof(T));
            }
        }

        #endregion

        /// <summary>
        /// Renvoie un flux permettant d'accéder aux données d'un champ binaire (BLOB) du IDataRecord
        /// </summary>
        /// <param name="record">IDataRecord à partir duquel lire les données</param>
        /// <param name="ordinal">Index du champ qui contient les données</param>
        /// <returns>Un flux permettant de lire les données du champ spécifié</returns>
        public static Stream GetStream(this IDataRecord record, int ordinal)
        {
            return new DataStream(record, ordinal);
        }

        /// <summary>
        /// Renvoie un flux en lecture seule permettant d'accéder aux données d'un champ binaire (BLOB) du IDataRecord
        /// </summary>
        /// <param name="record">IDataRecord à partir duquel lire les données</param>
        /// <param name="name">Nom du champ qui contient les données</param>
        /// <returns>Un flux permettant de lire les données du champ spécifié</returns>
        public static Stream GetStream(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetStream(i);
        }

        #region Classe DataStream pour lire un champ binaire (BLOB) d'un IDataRecord

        /// <summary>
        /// Permet d'accéder à un champ binaire d'un IDataRecord sous forme de flux
        /// </summary>
        private class DataStream : Stream
        {
            private IDataRecord _record;
            private int _fieldIndex;
            private long _position;
            private long _length = -1;

            /// <summary>
            /// Initialise une nouvelle instance de DataStream
            /// </summary>
            /// <param name="record">IDataRecord à partir duquel lire les données</param>
            /// <param name="fieldIndex">Index du champ dans lequel se trouvent les données</param>
            public DataStream(IDataRecord record, int fieldIndex)
            {
                _record = record;
                _fieldIndex = fieldIndex;
            }

            /// <summary>
            /// Indique si le flux prend en charge la lecture.
            /// <remarks>Renvoie toujours true pour DataStream</remarks>
            /// </summary>
            public override bool CanRead
            {
                get { return true; }
            }

            /// <summary>
            /// Indique si le flux prend en charge la recherche.
            /// <remarks>Renvoie toujours true pour DataStream</remarks>
            /// </summary>
            public override bool CanSeek
            {
                get { return true; }
            }

            /// <summary>
            /// Indique si le flux prend en charge l'écriture.
            /// <remarks>Renvoie toujours false pour DataStream</remarks>
            /// </summary>
            public override bool CanWrite
            {
                get { return false; }
            }

            /// <summary>
            /// Non supporté.
            /// </summary>
            public override void Flush()
            {
                throw new NotSupportedException();
            }

            /// <summary>
            /// Renvoie la longueur du flux.
            /// </summary>
            public override long Length
            {
                get
                {
                    if (_length < 0)
                    {
                        _length = _record.GetBytes(_fieldIndex, 0, null, 0, 0);
                    }
                    return _length;
                }
            }

            /// <summary>
            /// Obtient ou définit la position courante dans le flux.
            /// </summary>
            public override long Position
            {
                get
                {
                    return _position;
                }
                set
                {
                    _position = value;
                }
            }

            /// <summary>
            /// Lit une séquence d'octets à partir du flux et avance la position dans le flux du nombre d'octets lus
            /// </summary>
            /// <param name="buffer">Buffer dans lequel copier les données</param>
            /// <param name="offset">Position dans le buffer à partir de laquelle copier les données</param>
            /// <param name="count">Nombre maximum d'octets à lire</param>
            /// <returns>Le nombre d'octets lus</returns>
            public override int Read(byte[] buffer, int offset, int count)
            {
                long nRead = _record.GetBytes(_fieldIndex, _position, buffer, offset, count);
                _position += nRead;
                return (int)nRead;
            }

            /// <summary>
            /// Définit la position courante dans le flux
            /// </summary>
            /// <param name="offset">Position désirée par rapport au paramètre <c>origin</c></param>
            /// <param name="origin">Valeur indiquant le point de référence utilisé pour obtenir la nouvelle position</param>
            /// <returns></returns>
            public override long Seek(long offset, SeekOrigin origin)
            {
                long newPosition = _position;
                switch (origin)
                {
                    case SeekOrigin.Begin:
                        newPosition = offset;
                        break;
                    case SeekOrigin.Current:
                        newPosition = _position + offset;
                        break;
                    case SeekOrigin.End:
                        newPosition = this.Length - offset;
                        break;
                    default:
                        break;
                };
                if (newPosition < 0)
                    throw new ArgumentOutOfRangeException("offset");
                _position = newPosition;
                return _position;
            }

            /// <summary>
            /// Non supporté.
            /// </summary>
            /// <param name="value">Nouvelle longueur du flux</param>
            public override void SetLength(long value)
            {
                throw new NotSupportedException();
            }

            /// <summary>
            /// Non supporté
            /// </summary>
            /// <param name="buffer">Buffer à partir duquel copier les données</param>
            /// <param name="offset">Position dans le buffer à partir de laquelle copier les données</param>
            /// <param name="count">Nombre maximum d'octets à copier</param>
            public override void Write(byte[] buffer, int offset, int count)
            {
                throw new NotSupportedException();
            }
        }

        #endregion

        #endregion

        #region Méthodes d'extension pour IDataReader

        /// <summary>
        /// Renvoie un IDataReader comme une séquence de IDataRecord
        /// </summary>
        /// <param name="reader">Le IDataReader à énumérer</param>
        /// <returns>Une séquence de IDataRecord</returns>
        public static IEnumerable<IDataRecord> AsEnumerable(this IDataReader reader)
        {
            //return reader.Cast<IDataRecord>();
            while (reader.Read())
            {
                yield return reader;
            }
        }

        #endregion

        #region Méthodes d'extension pour DbDataAdapter

        /// <summary>
        /// Ajoute un handler d'évènement RowUpdating à un DbDataAdapter
        /// </summary>
        /// <param name="adapter">L'adapteur pour lequel ajouter un handler d'évènement</param>
        /// <param name="handler">Le handler d'évènement à ajouter</param>
        public static void AddRowUpdatingHandler(this DbDataAdapter adapter, EventHandler<RowUpdatingEventArgs> handler)
        {
            adapter.CheckArgumentNull("adapter");
            handler.CheckArgumentNull("handler");
            AddEventHandler(adapter, "RowUpdating", handler);
        }

        /// <summary>
        /// Ajoute un handler d'évènement RowUpdated à un DbDataAdapter
        /// </summary>
        /// <param name="adapter">L'adapteur pour lequel ajouter un handler d'évènement</param>
        /// <param name="handler">Le handler d'évènement à ajouter</param>
        public static void AddRowUpdatedHandler(this DbDataAdapter adapter, EventHandler<RowUpdatedEventArgs> handler)
        {
            adapter.CheckArgumentNull("adapter");
            handler.CheckArgumentNull("handler");
            AddEventHandler(adapter, "RowUpdated", handler);
        }

        /// <summary>
        /// Enlève un handler d'évènement RowUpdating d'un DbDataAdapter
        /// </summary>
        /// <param name="adapter">L'adapteur pour lequel enlever un handler d'évènement</param>
        /// <param name="handler">Le handler d'évènement à enlever</param>
        public static void RemoveRowUpdatingHandler(this DbDataAdapter adapter, EventHandler<RowUpdatingEventArgs> handler)
        {
            adapter.CheckArgumentNull("adapter");
            handler.CheckArgumentNull("handler");
            RemoveEventHandler(adapter, "RowUpdating", handler);
        }

        /// <summary>
        /// Enlève un handler d'évènement RowUpdated d'un DbDataAdapter
        /// </summary>
        /// <param name="adapter">L'adapteur pour lequel enlever un handler d'évènement</param>
        /// <param name="handler">Le handler d'évènement à enlever</param>
        public static void RemoveRowUpdatedHandler(this DbDataAdapter adapter, EventHandler<RowUpdatedEventArgs> handler)
        {
            adapter.CheckArgumentNull("adapter");
            handler.CheckArgumentNull("handler");
            RemoveEventHandler(adapter, "RowUpdated", handler);
        }

        private static void AddEventHandler(object target, string eventName, Delegate handler)
        {
            Type targetType = target.GetType();
            EventInfo evt = targetType.GetEvent(eventName);
            if (evt == null)
            {
                throw new InvalidOperationException(string.Format(ExceptionMessages.TypeDoesntImplementEvent, targetType, eventName));
            }
            evt.AddEventHandler(target, ChangeType(evt.EventHandlerType, handler));
        }

        private static void RemoveEventHandler(object target, string eventName, Delegate handler)
        {
            Type targetType = target.GetType();
            EventInfo evt = targetType.GetEvent(eventName);
            if (evt == null)
            {
                throw new InvalidOperationException(string.Format(ExceptionMessages.TypeDoesntImplementEvent, targetType, eventName));
            }
            evt.RemoveEventHandler(target, ChangeType(evt.EventHandlerType, handler));
        }

        private static Delegate ChangeType(Type targetType, Delegate d)
        {
            return Delegate.CreateDelegate(targetType, d.Target, d.Method);
        }

        #endregion
    }
}