using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Developpez.Dotnet.Properties;
using Developpez.Dotnet.Reflection;

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 DbProviderFactory

        /// <summary>
        /// Crée une connexion à partir d'une DbProviderFactory et d'une chaine de connexion
        /// </summary>
        /// <param name="factory">la DbProviderFactory du provider ADO.NET à utiliser</param>
        /// <param name="connectionString">la chaine de connexion</param>
        /// <returns>Une DbConnection avec la chaine de connexion spécifiée</returns>
        public static DbConnection CreateConnection(this DbProviderFactory factory, string connectionString)
        {
            var connection = factory.CreateConnection();
            if (connection != null)
                connection.ConnectionString = connectionString;
            return connection;
        }

        #endregion

        #region Méthodes d'extension pour IDbConnection/DbConnection

        /// <summary>
        /// Crée une commande à partir d'une connexion et d'une requête
        /// </summary>
        /// <param name="connection">La connexion</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 IDbCommand CreateCommand(this IDbConnection connection, string commandText)
        {
            IDbCommand command = connection.CreateCommand();
            command.CommandText = commandText;
            return command;
        }

        /// <summary>
        /// Crée une commande à partir d'une connexion et d'une requête
        /// </summary>
        /// <param name="connection">La connexion</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;
        }

        /// <summary>
        /// Exécute la requête spécifiée et renvoie les résultats sous forme d'une séquence d'enregistrements.
        /// </summary>
        /// <param name="connection">Connection sur laquelle exécuter la commande</param>
        /// <param name="commandText">Texte de la requête SQL</param>
        /// <returns>Les résultats de la requête sous forme d'une série d'enregistrements</returns>
        public static IEnumerable<IDataRecord> Query(this IDbConnection connection, string commandText)
        {
            connection.CheckArgumentNull("connection");
            commandText.CheckArgumentNull("commandText");
            return connection.QueryImpl(commandText, null);
        }

        /// <summary>
        /// Exécute la requête spécifiée avec les paramètres spécifiés, et renvoie les résultats sous forme d'une séquence d'enregistrements.
        /// </summary>
        /// <typeparam name="TParams">Type de l'objet contenant les paramètres</typeparam>
        /// <param name="connection">Connection sur laquelle exécuter la commande</param>
        /// <param name="commandText">Texte de la requête SQL</param>
        /// <param name="parameters">Objet dont les propriétés correspondent aux noms des paramètres dans la requête SQL</param>
        /// <returns>Les résultats de la requête sous forme d'une série d'enregistrements</returns>
        public static IEnumerable<IDataRecord> Query<TParams>(this IDbConnection connection, string commandText, TParams parameters)
        {
            connection.CheckArgumentNull("connection");
            commandText.CheckArgumentNull("commandText");
            
            Action<IDbCommand> setParameters = null;
            
            // ReSharper disable CompareNonConstrainedGenericWithNull
            if (parameters != null)
                setParameters = command => command.SetParameters(parameters);
            // ReSharper restore CompareNonConstrainedGenericWithNull

            return connection.QueryImpl(commandText, setParameters);
        }

        private static IEnumerable<IDataRecord> QueryImpl(this IDbConnection connection, string commandText, Action<IDbCommand> setParameters)
        {
            using (var command = connection.CreateCommand(commandText))
            {
                if (setParameters != null)
                    setParameters(command);

                using (var reader = command.ExecuteReader())
                {
                    // On ne peut pas renvoyer directement reader.AsEnumerable(),
                    // sinon le reader et la commande seront disposés trop tôt.
                    // Il faut donc utiliser un itérateur.
                    while (reader.Read())
                    {
                        yield return reader;
                    }
                }
            }
        }

        /// <summary>
        /// Exécute la requête spécifiée avec les paramètres spécifiés, et renvoie la première colonne de la première ligne du résultat.
        /// </summary>
        /// <param name="connection">Connection sur laquelle exécuter la commande</param>
        /// <param name="commandText">Texte de la requête SQL</param>
        /// <returns>La première colonne de la première ligne du résultat, ou null si la requête n'a renvoyé aucun résultat</returns>
        public static object QueryScalar(this IDbConnection connection, string commandText)
        {
            connection.CheckArgumentNull("connection");
            commandText.CheckArgumentNull("commandText");
            using (var command = connection.CreateCommand(commandText))
            {
                return command.ExecuteScalar();
            }
        }

        /// <summary>
        /// Exécute la requête spécifiée avec les paramètres spécifiés, et renvoie la première colonne de la première ligne du résultat.
        /// </summary>
        /// <typeparam name="TParams">Type de l'objet contenant les paramètres</typeparam>
        /// <param name="connection">Connection sur laquelle exécuter la commande</param>
        /// <param name="commandText">Texte de la requête SQL</param>
        /// <param name="parameters">Objet dont les propriétés correspondent aux noms des paramètres dans la requête SQL</param>
        /// <returns>La première colonne de la première ligne du résultat, ou null si la requête n'a renvoyé aucun résultat</returns>
        public static object QueryScalar<TParams>(this IDbConnection connection, string commandText, TParams parameters)
        {
            connection.CheckArgumentNull("connection");
            commandText.CheckArgumentNull("commandText");
            using (var command = connection.CreateCommand(commandText))
            {
                // ReSharper disable CompareNonConstrainedGenericWithNull
                if (parameters != null)
                    command.SetParameters(parameters);
                // ReSharper restore CompareNonConstrainedGenericWithNull
                return command.ExecuteScalar();
            }
        }

        /// <summary>
        /// Exécute la commande spécifiée et renvoie le nombre de lignes affectées
        /// </summary>
        /// <param name="connection">Connection sur laquelle exécuter la commande</param>
        /// <param name="commandText">Texte de la requête SQL</param>
        /// <returns>Le nombre de lignes affectées par la commande</returns>
        public static int Execute(this IDbConnection connection, string commandText)
        {
            connection.CheckArgumentNull("connection");
            commandText.CheckArgumentNull("commandText");
            using (var command = connection.CreateCommand(commandText))
            {
                return command.ExecuteNonQuery();
            }
        }

        /// <summary>
        /// Exécute la commande spécifiée avec les paramètres spécifiés, et renvoie le nombre de lignes affectées
        /// </summary>
        /// <typeparam name="TParams">Type de l'objet contenant les paramètres</typeparam>
        /// <param name="connection">Connection sur laquelle exécuter la commande</param>
        /// <param name="commandText">Texte de la requête SQL</param>
        /// <param name="parameters">Objet dont les propriétés correspondent aux noms des paramètres dans la requête SQL</param>
        /// <returns>Le nombre de lignes affectées par la commande</returns>
        public static int Execute<TParams>(this IDbConnection connection, string commandText, TParams parameters)
        {
            connection.CheckArgumentNull("connection");
            commandText.CheckArgumentNull("commandText");
            using (var command = connection.CreateCommand(commandText))
            {
                // ReSharper disable CompareNonConstrainedGenericWithNull
                if (parameters != null)
                    command.SetParameters(parameters);
                // ReSharper restore CompareNonConstrainedGenericWithNull
                return command.ExecuteNonQuery();
            }
        }

        #endregion

        #region Méthodes d'extension pour IDbCommand/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 IDbDataParameter AddParameter(this IDbCommand command, string name, DbType dbType)
        {
            return command.AddParameter(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 IDbDataParameter AddParameter(this IDbCommand command, string name, DbType dbType, int size)
        {
            return command.AddParameter(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 IDbDataParameter AddParameter(this IDbCommand command, string name, DbType dbType, ParameterDirection direction)
        {
            IDbDataParameter 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 IDbDataParameter AddParameter(this IDbCommand command, string name, DbType dbType, int size, ParameterDirection direction)
        {
            IDbDataParameter parameter = command.CreateParameter();
            parameter.ParameterName = name;
            parameter.DbType = dbType;
            parameter.Direction = direction;
            parameter.Size = size;
            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>
        /// <returns>Le paramètre créé</returns>
        public static DbParameter AddParameter(this DbCommand command, string name, DbType dbType)
        {
            return command.AddParameter(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 command.AddParameter(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;
        }
        
        /// <summary>
        /// Exécute la commande et renvoie les résultats sous forme d'une séquence d'éléments
        /// résultant de la projection spécifiée.
        /// </summary>
        /// <typeparam name="TResult">Le type des éléments à renvoyer</typeparam>
        /// <param name="command">La commande à exécuter</param>
        /// <param name="selector">La projection à appliquer à chaque ligne renvoyée par la requête</param>
        /// <returns>Une séquence d'éléments résultant de la projection</returns>
        public static IEnumerable<TResult> Select<TResult>(this IDbCommand command, Func<IDataRecord, TResult> selector)
        {
            command.CheckArgumentNull("command");
            selector.CheckArgumentNull("selector");
            return command.SelectImpl(selector);
        }

        private static IEnumerable<TResult> SelectImpl<TResult>(this IDbCommand command, Func<IDataRecord, TResult> selector)
        {
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    yield return selector(reader);
                }
            }
        }

        /// <summary>
        /// Définit les valeurs des paramètres d'un commande, en créant les paramètres si besoin, d'après les propriétés de l'objet passé en paramètre.
        /// </summary>
        /// <typeparam name="TParams">Type de l'objet contenant les paramètres</typeparam>
        /// <param name="command">Commande dont les valeurs des paramètres sont définies</param>
        /// <param name="parameters">Objet dont les propriétés correspondent aux noms des paramètres dans la requête SQL</param>
        /// <returns>La commande avec les valeurs de paramètres spécifiées</returns>
        public static IDbCommand SetParameters<TParams>(this IDbCommand command, TParams parameters)
        {
            ParamsReflectionCache<TParams>.CreateOrUpdateParameters(command, parameters);
            return command;
        }

        /// <summary>
        /// Définit les valeurs des paramètres d'un commande, en créant les paramètres si besoin, d'après les propriétés de l'objet passé en paramètre.
        /// </summary>
        /// <typeparam name="TParams">Type de l'objet contenant les paramètres</typeparam>
        /// <param name="command">Commande dont les valeurs des paramètres sont définies</param>
        /// <param name="parameters">Objet dont les propriétés correspondent aux noms des paramètres dans la requête SQL</param>
        /// <returns>La commande avec les valeurs de paramètres spécifiées</returns>
        public static DbCommand SetParameters<TParams>(this DbCommand command, TParams parameters)
        {
            ParamsReflectionCache<TParams>.CreateOrUpdateParameters(command, parameters);
            return command;
        }

        #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>
        /// Renvoie un IDataReader pour 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 à récupérer</param>
        /// <returns>Un IDataReader</returns>
        public static IDataReader GetData(this IDataRecord record, string name)
        {
            int i = record.GetOrdinal(name);
            return record.GetData(i);
        }

        /// <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]);
            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 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(type.GetGenericArguments()));
                }
                return ValueField;
            }

            private static TElem? NullableField<TElem>(object value) where TElem : struct
            {
                if (DBNull.Value == value)
                {
                    return null;
                }
                return (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 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(type.GetGenericArguments()));
                }
                return ValueField;
            }

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

            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 DbBinaryFieldStream(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 DbBinaryFieldStream 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 DbBinaryFieldStream : Stream
        {
            private readonly IDataRecord _record;
            private readonly int _fieldIndex;
            private long _position;
            private long _length = -1;

            /// <summary>
            /// Initialise une nouvelle instance de DbBinaryFieldStream
            /// </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 DbBinaryFieldStream(IDataRecord record, int fieldIndex)
            {
                _record = record;
                _fieldIndex = fieldIndex;
            }

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

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

            /// <summary>
            /// Indique si le flux prend en charge l'écriture.
            /// <remarks>Renvoie toujours false pour DbBinaryFieldStream</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>
        /// <remarks>ATTENTION : les données de chaque ligne doivent être récupérées avant de passer à la suivante,
        /// sinon les données renvoyées ne seront pas celles attendues. Cela implique qu'il ne faut pas utiliser
        /// <c>ToList()</c> ou <c>ToArray()</c> (par exemple) sur la séquence de <c>IDataRecord</c> obtenue.</remarks>
        public static IEnumerable<IDataRecord> AsEnumerable(this IDataReader reader)
        {
            reader.CheckArgumentNull("reader");
            return reader.AsEnumerableImpl();
        }

        private static IEnumerable<IDataRecord> AsEnumerableImpl(this IDataReader reader)
        {
            while (reader.Read())
            {
                yield return reader;
            }
        }

        #endregion

        #region Méthodes d'extension pour IDbDataAdapter

        /// <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 IDbDataAdapter 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 IDbDataAdapter 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 IDbDataAdapter 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 IDbDataAdapter 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

        #region Cache de réflexion pour les paramètres

        private static class ParamsReflectionCache<TParams>
        {
            private class ParameterDescriptor
            {
                private readonly string _name;
                private readonly DbType _dbType;
                private readonly Func<TParams, object> _getter;

                public ParameterDescriptor(string name, DbType dbType, Func<TParams, object> getter)
                {
                    _name = name;
                    _dbType = dbType;
                    _getter = getter;
                }

                public DbType DbType
                {
                    get { return _dbType; }
                }

                public string Name
                {
                    get { return _name; }
                }

                public object GetValue(TParams parameters)
                {
                    return _getter(parameters);
                }
            }

            private static readonly Dictionary<string, ParameterDescriptor> _descriptors = InitDescriptors();

            private static Dictionary<string, ParameterDescriptor> InitDescriptors()
            {
                var descriptors = new Dictionary<string, ParameterDescriptor>();
                foreach (var prop in typeof(TParams).GetProperties())
                {
                    if (!prop.CanRead)
                        continue;
                    var descriptor = new ParameterDescriptor(prop.Name, GetDbType(prop.PropertyType), MakeGetter(prop));
                    descriptors.Add(prop.Name, descriptor);
                }
                return descriptors;
            }

            private static DbType GetDbType(Type type)
            {

                if (type.IsValueType && type.IsNullable())
                    type = type.GetGenericArguments()[0];

                if (type == typeof(bool))
                    return DbType.Boolean;
                if (type == typeof(Byte))
                    return DbType.Byte;
                if (type == typeof(SByte))
                    return DbType.SByte;
                if (type == typeof(Int16))
                    return DbType.Int16;
                if (type == typeof(UInt16))
                    return DbType.UInt16;
                if (type == typeof(Int32))
                    return DbType.Int32;
                if (type == typeof(Int64))
                    return DbType.Int64;
                if (type == typeof(UInt64))
                    return DbType.UInt64;
                if (type == typeof(Decimal))
                    return DbType.Decimal;
                if (type == typeof(Double))
                    return DbType.Double;
                if (type == typeof(Single))
                    return DbType.Single;
                if (type == typeof(DateTime))
                    return DbType.DateTime;
                if (type == typeof(DateTimeOffset))
                    return DbType.DateTimeOffset;
                if (type == typeof(TimeSpan))
                    return DbType.Time;
                if (type == typeof(Guid))
                    return DbType.Guid;
                if (type == typeof(string))
                    return DbType.String;
                if (type == typeof(byte[]))
                    return DbType.Binary;
                return DbType.Object;
            }

            private static Func<TParams, object> MakeGetter(PropertyInfo prop)
            {
                var prm = Expression.Parameter(typeof(TParams), "p");
                Expression body = Expression.Property(prm, prop);
                if (prop.PropertyType.IsValueType)
                    body = Expression.Convert(body, typeof(object));
                var lambda = Expression.Lambda<Func<TParams, object>>(body, prm);
                var getter = lambda.Compile();
                return getter;
            }

            public static void CreateOrUpdateParameters(IDbCommand command, TParams parameters)
            {
                var joined =
                    from d in _descriptors.Values
                    join p in command.Parameters.Cast<IDataParameter>() on d.Name equals p.ParameterName into tmp
                    from p in tmp.DefaultIfEmpty()
                    select new { Descriptor = d, Parameter = p };

                foreach (var x in joined)
                {
                    var p = x.Parameter ?? command.CreateParameter();
                    p.ParameterName = x.Descriptor.Name;
                    p.DbType = x.Descriptor.DbType;
                    p.Value = x.Descriptor.GetValue(parameters);
                    if (x.Parameter == null)
                    {
                        Debug.Print("Added parameter {0}", p.ParameterName);
                        command.Parameters.Add(p);
                    }
                    else
                    {
                        Debug.Print("Updated parameter {0}", p.ParameterName);
                    }
                }
            }
        }

        #endregion
    }
}