using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Developpez.Dotnet.Properties;
using Developpez.Dotnet.Text;
using JetBrains.Annotations;
using CH = Developpez.Dotnet.CompatibilityHelper;

namespace Developpez.Dotnet
{
    /// <summary>
    /// Fournit des méthodes d'extensions à usage générique
    /// </summary>
    public static class CoreExtensions
    {
        #region Null handling

        /// <summary>
        /// Renvoie la valeur courante si elle est non nulle. Sinon, renvoie la valeur par défaut spécifiée.
        /// Equivalent à l'opérateur C# <c>??</c>
        /// </summary>
        /// <typeparam name="T">Type de la valeur courante</typeparam>
        /// <param name="obj">Valeur courante</param>
        /// <param name="defaultValue">Valeur par défaut à renvoyer si la valeur courante est nulle</param>
        /// <returns>La valeur courante si elle est non nulle. Sinon, la valeur par défaut</returns>
        public static T Default<T>(this T obj, T defaultValue)
            where T : class
        {
            return obj ?? defaultValue;
        }

        /// <summary>
        /// Si la valeur courante n'est pas nulle, renvoie la valeur spécifiée par le sélecteur. Sinon,
        /// renvoie la valeur par défaut spécifiée.
        /// </summary>
        /// <typeparam name="T">Type de la valeur courante</typeparam>
        /// <typeparam name="TResult">Type de retour du sélecteur</typeparam>
        /// <param name="obj">Valeur courante</param>
        /// <param name="selector">Sélecteur indiquant la valeur à renvoyer</param>
        /// <param name="valueIfNull">Valeur par défaut à renvoyer si la valeur courante est nulle</param>
        /// <returns>Si la valeur courante n'est pas nulle, la valeur spécifiée par le sélecteur. Sinon, la valeur par défaut</returns>
        public static TResult IfNotNull<T, TResult>(
            this T obj,
            [NotNull] Func<T, TResult> selector,
            TResult valueIfNull)
            where T : class
        {
            selector.CheckArgumentNull("selector");
            if (obj == null)
                return valueIfNull;
            return selector(obj);
        }

        /// <summary>
        /// Si la valeur courante n'est pas nulle, renvoie la valeur spécifiée par le sélecteur. Sinon,
        /// renvoie la valeur par défaut du type de retour spécifié.
        /// </summary>
        /// <typeparam name="T">Type de la valeur courante</typeparam>
        /// <typeparam name="TResult">Type de retour du sélecteur</typeparam>
        /// <param name="obj">Valeur courante</param>
        /// <param name="selector">Sélecteur indiquant la valeur à renvoyer</param>
        /// <returns>Si la valeur courante n'est pas nulle, la valeur spécifiée par le sélecteur. Sinon, la valeur par défaut du type de retour spécifié</returns>
        public static TResult IfNotNull<T, TResult>(
            this T obj,
            [NotNull] Func<T, TResult> selector)
            where T : class
        {
            return obj.IfNotNull(selector, default(TResult));
        }

        /// <summary>
        /// Teste l'égalité de 2 objets, sans risque de NullReferenceException si l'un des objets
        /// est null.
        /// </summary>
        /// <typeparam name="T">Type des objets à comparer</typeparam>
        /// <param name="obj">Premier objet à comparer</param>
        /// <param name="other">Second objet à comparer</param>
        /// <returns>true si les objets sont égaux ou tous les 2 null, sinon false.</returns>
        public static bool SafeEquals<T>(this T obj, T other)
        {
            return EqualityComparer<T>.Default.Equals(obj, other);
        }

        #endregion

        #region Between, StrictlyBetween

        /// <summary>
        /// Teste si une valeur est entre les 2 valeurs spécifiées (bornes inclues)
        /// </summary>
        /// <typeparam name="T">Type de la valeur</typeparam>
        /// <param name="value">Valeur à tester</param>
        /// <param name="min">Borne inférieure</param>
        /// <param name="max">Borne supérieure</param>
        /// <returns>true si <c>min &lt;= value &lt;= max</c>, sinon false</returns>
        public static bool Between<T>(
            this T value,
            T min,
            T max)
            where T : IComparable<T>
        {
            var comparer = Comparer<T>.Default;
            int compMin = comparer.Compare(min, value);
            int compMax = comparer.Compare(value, max);
            return compMin <= 0 && compMax <= 0;
        }

        /// <summary>
        /// Teste si une valeur est strictement entre les bornes spécifiées (bornes non inclues)
        /// </summary>
        /// <typeparam name="T">Type de la valeur</typeparam>
        /// <param name="value">Valeur à tester</param>
        /// <param name="min">Borne inférieure</param>
        /// <param name="max">Borne supérieure</param>
        /// <returns>true si <c>min &lt; value &lt; max</c>, sinon false</returns>
        public static bool StrictlyBetween<T>(this T value, T min, T max)
            where T : IComparable<T>
        {
            var comparer = Comparer<T>.Default;
            int compMin = comparer.Compare(min, value);
            int compMax = comparer.Compare(value, max);
            return compMin < 0 && compMax < 0;
        }

        #endregion

        #region In

        /// <summary>
        /// Teste si une valeur appartient à la liste spécifiée
        /// </summary>
        /// <typeparam name="T">Type de la valeur</typeparam>
        /// <param name="value">Valeur à tester</param>
        /// <param name="list">Liste à laquelle la valeur doit appartenir</param>
        /// <returns>true si la valeur appartient à la liste, sinon false</returns>
        public static bool In<T>(
            this T value,
            [NotNull] params T[] list)
        {
            list.CheckArgumentNull("list");
            return list.Contains(value);
        }

        /// <summary>
        /// Teste si une valeur appartient à la liste spécifiée
        /// </summary>
        /// <typeparam name="T">Type de la valeur</typeparam>
        /// <param name="value">Valeur à tester</param>
        /// <param name="list">Liste à laquelle la valeur doit appartenir</param>
        /// <returns>true si la valeur appartient à la liste, sinon false</returns>
        public static bool In<T>(
            this T value,
            [NotNull] IEnumerable<T> list)
        {
            list.CheckArgumentNull("list");
            return list.Contains(value);
        }

        #endregion

        #region Argument checking

        /// <summary>
        /// Vérifie si un argument est null, et lève une ArgumentNullException
        /// si c'est le cas.
        /// </summary>
        /// <typeparam name="T">Type du paramètre</typeparam>
        /// <param name="value">Valeur de l'argument</param>
        /// <param name="paramName">Nom du paramètre</param>
        [AssertionMethod]
        public static void CheckArgumentNull<T>(
            [AssertionCondition(AssertionConditionType.IS_NOT_NULL), NoEnumeration] this T value,
            [InvokerParameterName] string paramName)
            where T : class
        {
            if (value == null)
                throw new ArgumentNullException(paramName);
        }

        /// <summary>
        /// Vérifie si un argument est null, et lève une ArgumentNullException
        /// avec le message spécifié si c'est le cas.
        /// </summary>
        /// <typeparam name="T">Type du paramètre</typeparam>
        /// <param name="value">Valeur de l'argument</param>
        /// <param name="paramName">Nom du paramètre</param>
        /// <param name="message">Message de l'exception</param>
        [AssertionMethod]
        public static void CheckArgumentNull<T>(
            [AssertionCondition(AssertionConditionType.IS_NOT_NULL), NoEnumeration] this T value,
            [InvokerParameterName] string paramName,
            string message)
            where T : class
        {
            if (value == null)
                throw new ArgumentNullException(paramName, message);
        }

        /// <summary>
        /// Vérifie qu'un argument est dans la plage de valeurs spécifiées, et lève une
        /// ArgumentOutOfRangeException si ce n'est pas le cas
        /// </summary>
        /// <typeparam name="T">Type du paramètre</typeparam>
        /// <param name="value">Valeur de l'argument</param>
        /// <param name="paramName">Nom du paramètre</param>
        /// <param name="min">Valeur minimale de l'argument</param>
        /// <param name="max">Valeur maximale de l'argument</param>
        public static void CheckArgumentOutOfRange<T>(
            this T value,
            [InvokerParameterName] string paramName,
            T min,
            T max)
            where T : IComparable<T>
        {
            if (value.CompareTo(min) < 0 || value.CompareTo(max) > 0)
                throw new ArgumentOutOfRangeException(paramName);
        }

        /// <summary>
        /// Vérifie qu'un argument est dans la plage de valeurs spécifiées, et lève une
        /// ArgumentOutOfRangeException avec le message spécifié si ce n'est pas le cas
        /// </summary>
        /// <typeparam name="T">Type du paramètre</typeparam>
        /// <param name="value">Valeur de l'argument</param>
        /// <param name="paramName">Nom du paramètre</param>
        /// <param name="min">Valeur minimale de l'argument</param>
        /// <param name="max">Valeur maximale de l'argument</param>
        /// <param name="message">Message de l'exception</param>
        public static void CheckArgumentOutOfRange<T>(
            this T value,
            [InvokerParameterName] string paramName,
            T min,
            T max,
            string message)
            where T : IComparable<T>
        {
            if (value.CompareTo(min) < 0 || value.CompareTo(max) > 0)
                throw new ArgumentOutOfRangeException(paramName, message);
        }

        /// <summary>
        /// Vérifie qu'un argument est une valeur d'enum valide, et lève une
        /// ArgumentOutOfRangeException si ce n'est pas le cas.
        /// </summary>
        /// <param name="value">Valeur de l'argument</param>
        /// <param name="paramName">Nom du paramètre</param>
        public static void CheckArgumentInEnum(
            this Enum value,
            [InvokerParameterName] string paramName)
        {
            if (!Enum.IsDefined(value.GetType(), value))
                throw new ArgumentOutOfRangeException(paramName);
        }

        /// <summary>
        /// Vérifie qu'un argument est une valeur d'enum valide, et lève une
        /// ArgumentOutOfRangeException avec le message spécifié si ce n'est pas le cas.
        /// </summary>
        /// <param name="value">Valeur de l'argument</param>
        /// <param name="paramName">Nom du paramètre</param>
        /// <param name="message">Message de l'exception</param>
        public static void CheckArgumentInEnum(
            this Enum value,
            [InvokerParameterName] string paramName,
            string message)
        {
            if (!Enum.IsDefined(value.GetType(), value))
                throw new ArgumentOutOfRangeException(paramName, message);
        }

        #endregion

        #region Switch

        /// <summary>
        /// Commence un bloc Switch sous forme de méthode d'extension. Le bloc renverra
        /// la valeur correspondant au premier cas évalué à true, ou à défault, la valeur
        /// par défaut spécifiée.
        /// </summary>
        /// <typeparam name="T">Type de la valeur à tester</typeparam>
        /// <typeparam name="TResult">Type de la valeur de retour</typeparam>
        /// <param name="testValue">Valeur à tester</param>
        /// <param name="defaultResult">Valeur de retour par défaut</param>
        /// <returns>la valeur correspondant au premier cas évalué à true, ou à défault, la valeur par défaut spécifiée</returns>
        public static SwitchContext<T, TResult> Switch<T, TResult>(this T testValue, TResult defaultResult)
        {
            return new SwitchContext<T, TResult>(testValue, defaultResult);
        }

        /// <summary>
        /// Commence un bloc Switch sous forme de méthode d'extension. Le bloc renverra
        /// la valeur correspondant au premier cas évalué à true, ou à défault, la valeur
        /// par défaut du type de retour.
        /// </summary>
        /// <typeparam name="T">Type de la valeur à tester</typeparam>
        /// <typeparam name="TResult">Type de la valeur de retour</typeparam>
        /// <param name="testValue">Valeur à tester</param>
        /// <returns>la valeur correspondant au premier cas évalué à true, ou à défault, la valeur par défaut du type de retour</returns>
        public static SwitchContext<T, TResult> Switch<T, TResult>(this T testValue)
        {
            return new SwitchContext<T, TResult>(testValue, default(TResult));
        }

        /// <summary>
        /// Représente un bloc Switch en cours d'évaluation
        /// </summary>
        /// <typeparam name="T">Type de la valeur à tester</typeparam>
        /// <typeparam name="TResult">Type de la valeur de retour</typeparam>
        public class SwitchContext<T, TResult>
        {
            private readonly T _testValue;
            private TResult _result;
            private bool _matchFound;

            internal SwitchContext(T testValue, TResult defaultResult)
            {
                this._testValue = testValue;
                this._result = defaultResult;
            }

            /// <summary>
            /// Ajoute un nouveau cas évalué à true si la valeur à tester est égale à la valeur spécifiée.
            /// La valeur à renvoyer est spécifiée sous forme d'une valeur fixe.
            /// </summary>
            /// <param name="caseValue">La valeur à laquelle comparer la valeur à tester</param>
            /// <param name="caseResult">La valeur à renvoyer si ce cas est évalué à true</param>
            /// <returns>Le bloc Switch courant</returns>
            public SwitchContext<T, TResult> Case(T caseValue, TResult caseResult)
            {
                return Case(v => caseValue.SafeEquals(v), v => caseResult);
            }

            /// <summary>
            /// Ajoute un nouveau cas évalué à true si la valeur à tester est égale à la valeur spécifiée.
            /// La valeur à renvoyer est évaluée par la fonction spécifiée
            /// </summary>
            /// <param name="caseValue">La valeur à laquelle comparer la valeur à tester</param>
            /// <param name="caseEvaluator">La fonction qui évalue le résultat si ce cas est évalué à true</param>
            /// <returns>Le bloc Switch courant</returns>
            public SwitchContext<T, TResult> Case(
                T caseValue,
                [NotNull] Func<T, TResult> caseEvaluator)
            {
                caseEvaluator.CheckArgumentNull("caseEvaluator");
                return Case(v => caseValue.SafeEquals(v), caseEvaluator);
            }

            /// <summary>
            /// Ajoute un nouveau cas évalué à true si le prédicat spécifié est évalué à true.
            /// La valeur à renvoyer est spécifiée sous forme d'une valeur fixe.
            /// </summary>
            /// <param name="casePredicate">Le prédicat à évaluer par rapport à la valeur à tester</param>
            /// <param name="caseResult">La valeur à renvoyer si ce cas est évalué à true</param>
            /// <returns>Le bloc Switch courant</returns>
            public SwitchContext<T, TResult> Case(
                [NotNull] Func<T, bool> casePredicate,
                TResult caseResult)
            {
                casePredicate.CheckArgumentNull("casePredicate");
                return Case(casePredicate, v => caseResult);
            }

            /// <summary>
            /// Ajoute un nouveau cas évalué à true si le prédicat spécifié est évalué à true.
            /// La valeur à renvoyer est évaluée par la fonction spécifiée
            /// </summary>
            /// <param name="casePredicate">Le prédicat à évaluer par rapport à la valeur à tester</param>
            /// <param name="caseEvaluator">La fonction qui évalue le résultat si ce cas est évalué à true</param>
            /// <returns>Le bloc Switch courant</returns>
            public SwitchContext<T, TResult> Case(
                [NotNull] Func<T, bool> casePredicate,
                [NotNull] Func<T, TResult> caseEvaluator)
            {
                casePredicate.CheckArgumentNull("casePredicate");
                caseEvaluator.CheckArgumentNull("caseEvaluator");

                if (_matchFound)
                    return this;

                if (casePredicate(_testValue))
                {
                    _result = caseEvaluator(_testValue);
                    _matchFound = true;
                }
                return this;
            }

            /// <summary>
            /// Spécifie la valeur par défaut à renvoyer si tous les cas précédents ont été évalués à false.
            /// Cette méthode doit être la dernière appelée sur le bloc Switch, faute de quoi les cas suivants
            /// ne seront pas évalués.
            /// </summary>
            /// <param name="defaultResult">Valeur par défaut à renvoyer</param>
            /// <returns>Le bloc Switch courant</returns>
            public SwitchContext<T, TResult> Else(TResult defaultResult)
            {
                return Else(v => defaultResult);
            }

            /// <summary>
            /// Spécifie la fonction qui évaluera le résultat par défaut si tous les cas précédents ont été évalués à false.
            /// Cette méthode doit être la dernière appelée sur le bloc Switch, faute de quoi les cas suivants
            /// ne seront pas évalués.
            /// </summary>
            /// <param name="defaultEvaluator">Fonction qui évalue le résultat par défaut</param>
            /// <returns>Le bloc Switch courant</returns>
            public SwitchContext<T, TResult> Else([NotNull] Func<T, TResult> defaultEvaluator)
            {
                defaultEvaluator.CheckArgumentNull("defaultEvaluator");

                if (_matchFound)
                    return this;

                _result = defaultEvaluator(_testValue);
                _matchFound = true;

                return this;
            }

            /// <summary>
            /// Lève une exception si aucun cas correspondant n'a été trouvé
            /// </summary>
            /// <returns>Le bloc Switch courant</returns>
            public SwitchContext<T, TResult> ElseThrow()
            {
                if (_matchFound)
                    return this;

                throw new NoMatchFoundException();
            }

            /// <summary>
            /// Lève une exception avec le message spécifié si aucun cas correspondant n'a été trouvé
            /// </summary>
            /// <param name="message">Message à utiliser pour l'exception</param>
            /// <returns>Le bloc Switch courant</returns>
            public SwitchContext<T, TResult> ElseThrow(string message)
            {
                if (_matchFound)
                    return this;

                throw new NoMatchFoundException(message);
            }

            /// <summary>
            /// Renvoie le résultat du bloc Switch
            /// </summary>
            public TResult Result
            {
                get { return _result; }
            }

            /// <summary>
            /// Renvoie le résultat du block Switch
            /// </summary>
            /// <param name="context">Le bloc Switch à convertir</param>
            /// <returns>Le résultat du bloc Switch</returns>
            public static implicit operator TResult([NotNull] SwitchContext<T, TResult> context)
            {
                context.CheckArgumentNull("context");
                return context._result;
            }

            /// <summary>
            /// Cette exception est levée quand aucun cas correspondant à la valeur testée n'a été trouvé dans le bloc Switch
            /// </summary>
#if !SILVERLIGHT && !NETFX_CORE
            [Serializable]
#endif
            public class NoMatchFoundException : Exception
            {
                /// <summary>
                /// Initialise une nouvelle instance de NoMatchFoundException avec le message par défaut
                /// </summary>
                public NoMatchFoundException() : base(ExceptionMessages.NoMatchFound) { }
                /// <summary>
                /// Initialise une nouvelle instance de NoMatchFoundException avec le message spécifié
                /// </summary>
                /// <param name="message">Message de l'exception</param>
                public NoMatchFoundException(string message) : base(message) { }
                /// <summary>
                /// Initialise une nouvelle instance de NoMatchFoundException avec le message spécifié et l'exception interne spécifiée
                /// </summary>
                /// <param name="message">Message de l'exception</param>
                /// <param name="inner">Exception interne</param>
                public NoMatchFoundException(string message, Exception inner) : base(message, inner) { }

#if !SILVERLIGHT && !NETFX_CORE
                /// <summary>
                /// Initialise une nouvelle instance de NoMatchFoundException à partir de données sérialisées
                /// </summary>
                /// <param name="info">SerializationInfo qui contient les données d'objet sérialisées relatives à l'exception levée.</param>
                /// <param name="context">StreamingContext qui contient des informations contextuelles sur la source ou la destination.</param>
                protected NoMatchFoundException(
                  System.Runtime.Serialization.SerializationInfo info,
                  System.Runtime.Serialization.StreamingContext context)
                    : base(info, context) { }
#endif
            }
        }

        #endregion

        #region MakeHashCode

        private const int HashSeed1 = 983;
        private const int HashSeed2 = 457;

        /// <summary>
        /// Génère un code de hachage pour un objet à partir des éléments spécifiés, en utilisant les valeurs de seeds spécifiées
        /// </summary>
        /// <typeparam name="T">Type de l'objet pour lequel le hashcode est généré</typeparam>
        /// <param name="obj">Objet pour lequel on génère le code de hachage (voir Remarques)</param>
        /// <param name="seed1">Première seed pour générer le code de hachage</param>
        /// <param name="seed2">Seconde seed pour générer le code de hachage</param>
        /// <param name="items">Eléments à partir desquels on génère le code de hachage</param>
        /// <returns>Un code de hachage pour l'objet</returns>
        /// <remarks>Le premier paramètre <c>obj</c> n'est pas utilisé dans le calcul ; il n'est présent que pour
        /// raisons pratiques afin d'exposer la méthode comme une méthode d'extension. Il est recommandé d'utiliser
        /// des nombres premiers pour les valeurs des seeds, de façons à obtenir une meilleure distribution des codes
        /// de hachage.</remarks>
// ReSharper disable UnusedParameter.Global
        public static int MakeHashCodeWithSeeds<T>(
            this T obj,
            int seed1,
            int seed2,
            [NotNull] IEnumerable items)
// ReSharper restore UnusedParameter.Global
        {
            items.CheckArgumentNull("items");
            return items
                    .Cast<object>()
                    .Aggregate(
                        seed1,
                        (hash, item) =>
                            item != null
                                ? unchecked(seed2 * hash ^ item.GetHashCode())
                                : hash);
        }

        /// <summary>
        /// Génère un code de hachage pour un objet à partir des éléments spécifiés.
        /// </summary>
        /// <typeparam name="T">Type de l'objet pour lequel le hashcode est généré</typeparam>
        /// <param name="obj">Objet pour lequel on génère le code de hachage (voir Remarques)</param>
        /// <param name="items">Eléments à partir desquels on génère le code de hachage</param>
        /// <returns>Un code de hachage pour l'objet</returns>
        /// <remarks>Le premier paramètre <c>obj</c> n'est pas utilisé dans le calcul ; il n'est présent que pour
        /// raisons pratiques afin d'exposer la méthode comme une méthode d'extension.</remarks>
        public static int MakeHashCode<T>(
            this T obj,
            [NotNull] IEnumerable items)
        {
            return obj.MakeHashCodeWithSeeds(HashSeed1, HashSeed2, items);
        }

        /// <summary>
        /// Génère un code de hachage pour un objet à partir des éléments spécifiés, en utilisant les valeurs de seeds spécifiées
        /// </summary>
        /// <typeparam name="T">Type de l'objet pour lequel le hashcode est généré</typeparam>
        /// <param name="obj">Objet pour lequel on génère le code de hachage (voir Remarques)</param>
        /// <param name="seed1">Première seed pour générer le code de hachage</param>
        /// <param name="seed2">Seconde seed pour générer le code de hachage</param>
        /// <param name="first">Premier élément à partir duquel générer le code de hachage</param>
        /// <param name="second">Second élément à partir duquel générer le code de hachage</param>
        /// <param name="others">Autres éléments à partir desquels on génère le code de hachage</param>
        /// <returns>Un code de hachage pour l'objet</returns>
        /// <remarks>Le premier paramètre <c>obj</c> n'est pas utilisé dans le calcul ; il n'est présent que pour
        /// raisons pratiques afin d'exposer la méthode comme une méthode d'extension. Il est recommandé d'utiliser
        /// des nombres premiers pour les valeurs des seeds, de façons à obtenir une meilleure distribution des codes
        /// de hachage.</remarks>
        public static int MakeHashCodeWithSeeds<T>(
            this T obj,
            int seed1,
            int seed2,
            object first,
            object second,
            [NotNull] params object[] others)
        {
            others.CheckArgumentNull("others");
            return obj.MakeHashCodeWithSeeds(seed1, seed2, new[] { first, second }.Concat(others));
        }

        /// <summary>
        /// Génère un code de hachage pour un objet à partir des éléments spécifiés.
        /// </summary>
        /// <typeparam name="T">Type de l'objet pour lequel le hashcode est généré</typeparam>
        /// <param name="obj">Objet pour lequel on génère le code de hachage (voir Remarques)</param>
        /// <param name="first">Premier élément à partir duquel générer le code de hachage</param>
        /// <param name="second">Second élément à partir duquel générer le code de hachage</param>
        /// <param name="others">Autres éléments à partir desquels on génère le code de hachage</param>
        /// <returns>Un code de hachage pour l'objet</returns>
        /// <remarks>Le premier paramètre <c>obj</c> n'est pas utilisé dans le calcul ; il n'est présent que pour
        /// raisons pratiques afin d'exposer la méthode comme une méthode d'extension.</remarks>
        public static int MakeHashCode<T>(
            this T obj,
            object first,
            object second,
            params object[] others)
        {
            others.CheckArgumentNull("others");
            return obj.MakeHashCodeWithSeeds(HashSeed1, HashSeed2, new[] { first, second }.Concat(others));
        }

        #endregion

        #region Misc

        /// <summary>
        /// Obtient le service du type spécifié
        /// </summary>
        /// <typeparam name="T">Type de service souhaité</typeparam>
        /// <param name="provider">IServiceProvider qui fournit le service</param>
        /// <returns>Un service du type souhaité</returns>
        public static T GetService<T>([NotNull] this IServiceProvider provider)
        {
            provider.CheckArgumentNull("provider");
            return (T)provider.GetService(typeof(T));
        }

        /// <summary>
        /// Convertit un objet vers le type spécifié. Lève une exception si la conversion
        /// n'est pas possible.
        /// </summary>
        /// <typeparam name="T">Type de destination</typeparam>
        /// <param name="value">Object à convertir</param>
        /// <returns>La valeur convertie</returns>
        public static T ConvertTo<T>(this object value)
        {
            return (T)Convert.ChangeType(value, typeof(T), null);
        }

        static readonly char[] _hexDigits = "0123456789abcdef".ToCharArray();
        
        /// <summary>
        /// Renvoie la représentation hexadécimale d'un tableau d'octets
        /// </summary>
        /// <param name="bytes">Un tableau d'octets</param>
        /// <returns>La représentation hexadécimale du tableau d'octets, avec des lettres minuscules et sans séparateur</returns>
        public static string ToHexString([NotNull] this byte[] bytes)
        {
            bytes.CheckArgumentNull("bytes");
            char[] digits = new char[bytes.Length * 2];
            for (int i = 0; i < bytes.Length; i++)
            {
                int d1, d2;
                d1 = CH.Math.DivRem(bytes[i], 16, out d2) ;
                digits[2 * i] = _hexDigits[d1];
                digits[2 * i + 1] = _hexDigits[d2];
            }
            return new string(digits);
        }

        /// <summary>
        /// Renvoie la représentation en base64 d'un tableau d'octets
        /// </summary>
        /// <param name="bytes">Un tableau d'octets</param>
        /// <returns>La représentation base64 du tableau d'octets</returns>
        public static string ToBase64String([NotNull] this byte[] bytes)
        {
            bytes.CheckArgumentNull("bytes");
            return Convert.ToBase64String(bytes);
        }

        /// <summary>
        /// Formate un objet en utilisant le modèle fournit en paramètre.
        /// </summary>
        /// <typeparam name="T">Type de l'objet à formater</typeparam>
        /// <param name="obj">Objet à formater</param>
        /// <param name="template">Modèle à utiliser pour formater l'objet</param>
        /// <returns>L'objet formaté selon le modèle fourni</returns>
        /// <remarks>Voir la classe StringTemplate pour plus de détails sur la syntaxe du modèle.</remarks>
        public static string FormatWithTemplate<T>(
            [NotNull] this T obj,
            [NotNull] string template)
        {
            // ReSharper disable CompareNonConstrainedGenericWithNull
            if (obj == null)
                throw new ArgumentNullException("obj");
            // ReSharper restore CompareNonConstrainedGenericWithNull
            template.CheckArgumentNull("template");
            return StringTemplate.Format(template, obj);
        }

        /// <summary>
        /// Ajoute un offset à la valeur d'un pointeur
        /// </summary>
        /// <param name="ptr">Pointeur auquel ajouter l'offset</param>
        /// <param name="offset">Offset à ajouter</param>
        /// <returns>Nouveau pointeur qui reflète l'addition de l'offset au pointeur</returns>
        public static IntPtr Add(this IntPtr ptr, int offset)
        {
            if (IntPtr.Size == 8)
                return new IntPtr(ptr.ToInt64() + offset);
            return new IntPtr(ptr.ToInt32() + offset);
        }

        /// <summary>
        /// Soustrait un offset de la valeur d'un pointeur
        /// </summary>
        /// <param name="ptr">Pointeur duquel soustraire l'offset</param>
        /// <param name="offset">Offset à soustraire</param>
        /// <returns>Nouveau pointeur qui reflète la soustraction de l'offset du pointeur</returns>
        public static IntPtr Subtract(this IntPtr ptr, int offset)
        {
            if (IntPtr.Size == 8)
                return new IntPtr(ptr.ToInt64() - offset);
            return new IntPtr(ptr.ToInt32() - offset);
        }

        #endregion
    }
}