using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
#if !NETFX_CORE
using System.Security.Cryptography;
#endif
using System.Text;
using System.Text.RegularExpressions;
using Developpez.Dotnet.Collections;
using Developpez.Dotnet.Properties;
using CH = Developpez.Dotnet.CompatibilityHelper;

namespace Developpez.Dotnet
{
    /// <summary>
    /// Fournit des méthodes d'extension pour les chaines de caractères
    /// </summary>
    public static class StringExtensions
    {
        /// <summary>
        /// Indique si une chaine est nulle ou vide
        /// </summary>
        /// <param name="s">la chaine à tester</param>
        /// <returns>true si la chaine est nulle ou vide, false sinon</returns>
        public static bool IsNullOrEmpty(this string s)
        {
            return string.IsNullOrEmpty(s);
        }

        /// <summary>
        /// Indique si une chaîne est nulle, vide ou composée uniquement d'espaces blancs.
        /// </summary>
        /// <param name="s">la chaine à tester</param>
        /// <returns>true si la chaine est nulle, vide ou composée uniquement d'espaces blancs, false sinon</returns>
        public static bool IsNullOrWhiteSpace(this string s)
        {
            if (string.IsNullOrEmpty(s))
                return true;
            return string.IsNullOrEmpty(s.Trim());
        }

        /// <summary>
        /// Formate la chaine avec les valeurs spécifiées, de la même façon que
        /// String.Format
        /// </summary>
        /// <param name="format">La chaine de format</param>
        /// <param name="args">les valeurs à utiliser</param>
        /// <returns>La chaine formatée</returns>
        public static string FormatWith(this string format, params object[] args)
        {
            return string.Format(format, args);
        }

        /// <summary>
        /// Inverse l'ordre des caractères d'une chaine
        /// </summary>
        /// <param name="s">La chaine à inverser</param>
        /// <returns>La chaine inversée</returns>
        public static string Reverse(this string s)
        {
            s.CheckArgumentNull("s");

#if !SILVERLIGHT && !NETFX_CORE // La normalisation Unicode n'est pas supportée en SL ni en WinRT

            bool wasFormD = false;
            if (s.IsNormalized(NormalizationForm.FormD))
            {
                wasFormD = true;
                s = s.Normalize(NormalizationForm.FormC);
            }
#endif

#if NETFX_CORE
            char[] array = s.ToCharArray();
            array.Reverse();
            s = new String(array);
#else
            s = new String((s as IEnumerable<char>).Reverse().ToArray());
#endif

#if !SILVERLIGHT && !NETFX_CORE
            if (wasFormD)
            {
                s = s.Normalize(NormalizationForm.FormD);
            }
#endif
            return s;
        }

        /// <summary>
        /// Concatène toutes les chaines de la liste en plaçant le séparateur
        /// spécifié entre chaque chaine
        /// </summary>
        /// <param name="list">La liste de chaines à concaténer</param>
        /// <param name="separator">Le séparateur à utiliser</param>
        /// <returns>La concaténation des chaines de la liste</returns>
        public static string Join(this IEnumerable<string> list, string separator)
        {
            list.CheckArgumentNull("list");
            return string.Join(separator, list.ToArray());
        }

        /// <summary>
        /// Renvoie une chaine construite à partir d'une séquence de caractères
        /// </summary>
        /// <param name="chars">La séquence de caractères à transformer en chaine</param>
        /// <returns>Une chaine constituée des caractères de la séquence</returns>
        public static string Join(this IEnumerable<char> chars)
        {
            chars.CheckArgumentNull("chars");
            return new string(chars.ToArray());
        }

        /// <summary>
        /// Enumère les lignes d'une chaine de caractères
        /// </summary>
        /// <param name="s">La chaine à découper en lignes</param>
        /// <returns>La liste des lignes de cette chaine</returns>
        public static IEnumerable<string> ReadLines(this string s)
        {
            s.CheckArgumentNull("s");
            return ReadLinesIterator(s);
        }

        private static IEnumerable<string> ReadLinesIterator(string s)
        {
            using (StringReader reader = new StringReader(s))
            {
                string line;
                while ((line = reader.ReadLine()) != null)
                {
                    yield return line;
                }
            }
        }

#if !SILVERLIGHT && !NETFX_CORE // MD5 non supporté en SL ni en WinRT

        private static MD5 _md5;

        /// <summary>
        /// Renvoie le hash MD5 de la chaîne sous forme d'une chaine hexadécimale, en
        /// se basant sur l'encodage UTF8
        /// </summary>
        /// <param name="s">la chaine dont on veut obtenir le hash MD5</param>
        /// <returns>le hash MD5 sous forme d'une chaine hexadécimale</returns>
        public static string GetMD5Digest(this string s)
        {
            return s.GetMD5Digest(Encoding.UTF8);
        }

        /// <summary>
        /// Renvoie le hash MD5 de la chaîne sous forme d'une chaine hexadécimale, en
        /// se basant sur l'encodage spécifié
        /// </summary>
        /// <param name="s">la chaine dont on veut obtenir le hash MD5</param>
        /// <param name="encoding">L'encodage à utiliser</param>
        /// <returns>le hash MD5 sous forme d'une chaine hexadécimale</returns>
        public static string GetMD5Digest(this string s, Encoding encoding)
        {
            s.CheckArgumentNull("s");
            
            if (_md5 == null)
                _md5 = MD5.Create();

            byte[] stringBytes = encoding.GetBytes(s);
            byte[] hashBytes = _md5.ComputeHash(stringBytes);
            return hashBytes.ToHexString();
        }
#endif

#if !NETFX_CORE // SHA1 non supporté en WinRT
        private static SHA1 _sha1;

        /// <summary>
        /// Renvoie le hash SHA1 de la chaîne sous forme d'une chaîne hexadécimale, en se basant sur l'encodage UTF8
        /// </summary>
        /// <param name="s">la chaine dont on veut obtenir le hash SHA1</param>
        /// <returns>le hash SHA1 sous forme d'une chaine hexadécimale</returns>
        public static string GetSHA1Digest(this string s)
        {
            return GetSHA1Digest(s, Encoding.UTF8);
        }

        /// <summary>
        /// Renvoie le hash SHA1 de la chaîne sous forme d'une chaîne hexadécimale, en se basant sur l'encodage spécifié
        /// </summary>
        /// <param name="s">la chaine dont on veut obtenir le hash SHA1</param>
        /// <param name="encoding">L'encodage à utiliser</param>
        /// <returns>le hash SHA1 sous forme d'une chaine hexadécimale</returns>
        public static string GetSHA1Digest(this string s, Encoding encoding)
        {
            s.CheckArgumentNull("s");

            if (_sha1 == null)
#if SILVERLIGHT
                _sha1 = new SHA1Managed();
#else
                _sha1 = SHA1.Create();
#endif

            byte[] stringBytes = encoding.GetBytes(s);
            byte[] hashBytes = _sha1.ComputeHash(stringBytes);
            return hashBytes.ToHexString();
        }
#endif

#if !SILVERLIGHT && !NETFX_CORE // La normalisation Unicode n'est pas supportée en SL ni en WinRT

        /// <summary>
        /// Enlève les caractères diacritiques (accents, cédilles...) d'une chaine en les remplaçant par le
        /// caractère de base.
        /// </summary>
        /// <param name="s">La chaine dont on veut enlever les diacritiques</param>
        /// <returns>La chaine sans les diacritiques</returns>
        public static string RemoveDiacritics(this string s)
        {
            s.CheckArgumentNull("s");
            string formD = s.Normalize(NormalizationForm.FormD);
            char[] chars = new char[formD.Length];
            int count = 0;
            foreach (char c in formD)
            {
                if (CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark)
                {
                    chars[count++] = c;
                }
            }
            string noDiacriticsFormD = new string(chars, 0, count);
            return noDiacriticsFormD.Normalize(NormalizationForm.FormC);
        }
#endif

        /// <summary>
        /// Retourne une chaîne contenant un nombre spécifié de caractères en partant de la gauche d'une chaîne.
        /// </summary>
        /// <param name="s">chaine dont les caractères situés le plus à gauche sont retournés</param>
        /// <param name="count">Nombre de caractères à retourner</param>
        /// <returns>une chaîne contenant le nombre spécifié de caractères en partant de la gauche de s</returns>
        public static string Left(this string s, int count)
        {
            s.CheckArgumentNull("s");
            count.CheckArgumentOutOfRange("count", 0, s.Length, ExceptionMessages.SubstringCountOutOfRange);
            return s.Substring(0, count);
        }

        /// <summary>
        /// Retourne une chaîne contenant un nombre spécifié de caractères en partant de la droite d'une chaîne.
        /// </summary>
        /// <param name="s">chaine dont les caractères situés le plus à droite sont retournés</param>
        /// <param name="count">Nombre de caractères à retourner</param>
        /// <returns>une chaîne contenant le nombre spécifié de caractères en partant de la droite de s</returns>
        public static string Right(this string s, int count)
        {
            s.CheckArgumentNull("s");
            count.CheckArgumentOutOfRange("count", 0, s.Length, ExceptionMessages.SubstringCountOutOfRange);
            return s.Substring(s.Length - count, count);
        }

        /// <summary>
        /// Retourne une chaine tronquée au nombre de caractères spécifié.
        /// </summary>
        /// <param name="s">chaine à tronquer</param>
        /// <param name="count">Nombre maximal de caractères à retourner</param>
        /// <returns>une chaîne tronquée au nombre de caractères spécifié</returns>
        public static string Truncate(this string s, int count)
        {
            s.CheckArgumentNull("s");
            count.CheckArgumentOutOfRange("count", 0, int.MaxValue,
                                          ExceptionMessages.NumberMustBePositiveOrZero.FormatWith("count"));
            if (count > s.Length)
                return s;
            return s.Substring(0, count);
        }

#if !SILVERLIGHT && !NETFX_CORE // ToTitleCase n'est pas supporté en SL ni en WinRT

        /// <summary>
        /// Convertit la chaine spécifiée en initiales majuscules, selon les paramètres de la culture courante.
        /// </summary>
        /// <param name="s">La chaine à convertir en initiales majuscules</param>
        /// <returns>La chaine spécifiée convertie en initiales majuscules</returns>
        public static string ToTitleCase(this string s)
        {
            return s.ToTitleCase(null);
        }

        /// <summary>
        /// Convertit la chaine spécifiée en initiales majuscules, selon les paramètres de la culture spécifiée.
        /// </summary>
        /// <param name="s">La chaine à convertir en initiales majuscules</param>
        /// <param name="culture">La culture à utiliser</param>
        /// <returns>La chaine spécifiée convertie en initiales majuscules</returns>
        public static string ToTitleCase(this string s, CultureInfo culture)
        {
            s.CheckArgumentNull("s");
            culture = culture ?? CultureInfo.CurrentCulture;
            return culture.TextInfo.ToTitleCase(s);
        }

#endif

        /// <summary>
        /// Met en majuscule le premier caractère de la chaine spécifiée, selon les paramètres de la culture courante.
        /// </summary>
        /// <param name="s">La chaine dont le premier caractère est mis en majuscule</param>
        /// <returns>La chaine spécifiée avec le premier caractère en majuscule</returns>
        public static string Capitalize(this string s)
        {
            return s.Capitalize(null);
        }

        /// <summary>
        /// Met en majuscule le premier caractère de la chaine spécifiée, selon les paramètres de la culture spécifiée.
        /// </summary>
        /// <param name="s">La chaine dont le premier caractère est mis en majuscule</param>
        /// <param name="culture">La culture à utiliser</param>
        /// <returns>La chaine spécifiée avec le premier caractère en majuscule</returns>
        public static string Capitalize(this string s, CultureInfo culture)
        {
            s.CheckArgumentNull("s");
            culture = culture ?? CultureInfo.CurrentCulture;
            if (s.Length == 0)
                return s;
            StringBuilder builder = new StringBuilder(s);
            builder[0] = culture.TextInfo.ToUpper(builder[0]);
            return builder.ToString();
        }

        /// <summary>
        /// Renvoie un dictionnaire contenant le nombre d'occurences de chaque caractère de la chaine
        /// </summary>
        /// <param name="s">La chaine pour laquelle on veut compter les caractères</param>
        /// <returns>Un dictionnaire contenant le nombre d'occurences de chaque caractère</returns>
        public static IDictionary<char, int> GetCharFrequencies(this string s)
        {
            s.CheckArgumentNull("s");
            var frequencies = new DefaultDictionary<char, int>();
            foreach (char c in s) frequencies[c]++;
            return frequencies;
        }

        /// <summary>
        /// Renvoie le caractère à la position spécifiée, ou le caractère nul (0)
        /// si la position spécifiée est la fin de la chaine.
        /// </summary>
        /// <param name="s">Chaine dont un caractère doit être renvoyé</param>
        /// <param name="index">Position du caractère à renvoyer</param>
        /// <returns>le caractère à la position spécifiée, ou le caractère nul (0)
        /// si la position spécifiée est la fin de la chaine.</returns>
        public static char CharAt(this string s, int index)
        {
            s.CheckArgumentNull("s");
            index.CheckArgumentOutOfRange("index", 0, s.Length);
            if (index < s.Length)
                return s[index];
            return '\0';
        }

        /// <summary>
        /// Vérifie si une chaine correspond à un motif avec des caractères "joker" ('*' et '?')
        /// </summary>
        /// <param name="text">Chaine à vérifier</param>
        /// <param name="pattern">Motif avec lequel comparer la chaine</param>
        /// <returns>true si la chaine correspond au motif, false sinon.</returns>
        public static bool MatchesWildcard(this string text, string pattern)
        {
            text.CheckArgumentNull("text");
            pattern.CheckArgumentNull("pattern");

            int it = 0;
            while (text.CharAt(it) != 0 &&
                   pattern.CharAt(it) != '*')
            {
                if (pattern.CharAt(it) != text.CharAt(it) && pattern.CharAt(it) != '?')
                    return false;
                it++;
            }

            int cp = 0;
            int mp = 0;
            int ip = it;

            while (text.CharAt(it) != 0)
            {
                if (pattern.CharAt(ip) == '*')
                {
                    if (pattern.CharAt(++ip) == 0)
                        return true;
                    mp = ip;
                    cp = it + 1;
                }
                else if (pattern.CharAt(ip) == text.CharAt(it) || pattern.CharAt(ip) == '?')
                {
                    ip++;
                    it++;
                }
                else
                {
                    ip = mp;
                    it = cp++;
                }
            }

            while (pattern.CharAt(ip) == '*')
            {
                ip++;
            }
            return pattern.CharAt(ip) == 0;
        }

        /// <summary>
        /// Tronque une chaine de caractères à la longueur spécifiée, en remplaçant les derniers
        /// caractères par des points de suspension le cas échéant.
        /// </summary>
        /// <param name="s">La chaine à tronquer</param>
        /// <param name="maxLength">La longueur maximale souhaitée</param>
        /// <returns>La chaine tronquée</returns>
        public static string Ellipsis(this string s, int maxLength)
        {
            const string ellipsisString = "...";
            if (maxLength < ellipsisString.Length)
                throw new ArgumentException(string.Format(ExceptionMessages.MaxLengthCantBeLessThan, ellipsisString.Length));
            return s.Ellipsis(maxLength, ellipsisString);
        }

        /// <summary>
        /// Tronque une chaine de caractères à la longueur spécifiée, en remplaçant les derniers
        /// caractères par la chaine spécifiée le cas échéant.
        /// </summary>
        /// <param name="s">La chaine à tronquer</param>
        /// <param name="maxLength">La longueur maximale souhaitée</param>
        /// <param name="ellipsisString">La chaine à utiliser pour indiquer que la chaine est tronquée</param>
        /// <returns>La chaine tronquée</returns>
        public static string Ellipsis(this string s, int maxLength, string ellipsisString)
        {
            s.CheckArgumentNull("s");
            ellipsisString.CheckArgumentNull("ellipsisString");
            if (maxLength < ellipsisString.Length)
                throw new ArgumentException(ExceptionMessages.MaxLengthCantBeLessThanLengthOfEllipsisString);

            if (s.Length <= maxLength)
                return s;

            return s.Substring(0, maxLength - ellipsisString.Length) + ellipsisString;
        }

        #region From/To/Take

        /// <summary>
        /// Renvoie une portion de chaine à partir de la position spécifiée
        /// </summary>
        /// <param name="s">Chaine dont on veut extraire une portion</param>
        /// <param name="start">Position de début de la portion</param>
        /// <returns>La portion de chaine demandée </returns>
        public static SubStringFrom From(this string s, int start)
        {
            return new SubStringFrom(s, start);
        }

        /// <summary>
        /// Termine une portion de chaine à la position spécifiée
        /// </summary>
        /// <param name="subStringFrom">Portion de chaine à terminer</param>
        /// <param name="end">Position de fin</param>
        /// <returns>La portion de chaine demandée</returns>
        public static string To(this SubStringFrom subStringFrom, int end)
        {
            return subStringFrom.String.Substring(subStringFrom.Start, end - subStringFrom.Start + 1);
        }

        /// <summary>
        /// Prend le nombre de caractères spécifié à partir du début de la portion
        /// </summary>
        /// <param name="subStringFrom">Portion de chaine à partir de laquelle prendre les caractères</param>
        /// <param name="count">Nombre de caractères à prendre</param>
        /// <returns>La portion de chaine demandée</returns>
        public static string Take(this SubStringFrom subStringFrom, int count)
        {
            return subStringFrom.String.Substring(subStringFrom.Start, count);
        }

        /// <summary>
        /// Renvoie une portion de chaine à partir de la sous-chaine spécifiée, sans inclure cette dernière
        /// </summary>
        /// <param name="s">Chaine dont on veut extraire une portion</param>
        /// <param name="start">Sous-chaine de début de la portion</param>
        /// <returns>La portion de chaine demandée </returns>
        public static SubStringFrom From(this string s, string start)
        {
            return s.From(start, false);
        }

        /// <summary>
        /// Renvoie une portion de chaine à partir de la sous-chaine spécifiée, en incluant éventuellement cette dernière
        /// </summary>
        /// <param name="s">Chaine dont on veut extraire une portion</param>
        /// <param name="start">Sous-chaine de début de la portion</param>
        /// <param name="includeBoundary">true pour inclure la chaine de début spécifiée dans le résultat, false sinon</param>
        /// <returns>La portion de chaine demandée </returns>
        public static SubStringFrom From(this string s, string start, bool includeBoundary)
        {
            int iStart = s.IndexOf(start);
            if (!includeBoundary && iStart >= 0)
                iStart += start.Length;
            return new SubStringFrom(s, iStart);
        }

        /// <summary>
        /// Termine une portion de chaine à la sous-chaine spécifiée, sans inclure cette dernière
        /// </summary>
        /// <param name="subStringFrom">Portion de chaine à terminer</param>
        /// <param name="end">Sous-chaine de fin</param>
        /// <returns>La portion de chaine demandée</returns>
        public static string To(this SubStringFrom subStringFrom, string end)
        {
            return subStringFrom.To(end, false);
        }

        /// <summary>
        /// Termine une portion de chaine à la sous-chaine spécifiée, en incluant éventuellement cette dernière
        /// </summary>
        /// <param name="subStringFrom">Portion de chaine à terminer</param>
        /// <param name="end">Sous-chaine de fin</param>
        /// <param name="includeBoundary">true pour inclure la chaine de fin spécifiée, false sinon</param>
        /// <returns>La portion de chaine demandée</returns>
        public static string To(this SubStringFrom subStringFrom, string end, bool includeBoundary)
        {
            string s = subStringFrom.String;
            int iStart = subStringFrom.Start;
            int iEnd = s.IndexOf(end, iStart + 1);
            if (includeBoundary && iEnd > 0)
                iEnd += end.Length;
            if (iStart < 0)
                return string.Empty;
            if (iEnd < 0)
                return s.Substring(iStart);
            return s.Substring(iStart, iEnd - iStart);
        }

        /// <summary>
        /// Représente une portion d'une chaine de caractères à partir d'une position donnée
        /// </summary>
        public struct SubStringFrom
        {
            internal SubStringFrom(string s, int start)
                : this()
            {
                this.String = s;
                this.Start = start;
            }

            /// <summary>
            /// La chaine dont cet objet représente une portion
            /// </summary>
            public string String { get; private set; }

            /// <summary>
            /// La position de départ de la portion de chaine
            /// </summary>
            public int Start { get; private set; }

            /// <summary>
            /// Convertit implicitement un SubStringForm en String
            /// </summary>
            /// <param name="subStringFrom">SubStringForm à convertir</param>
            /// <returns>La chaine correspondante</returns>
            public static implicit operator string(SubStringFrom subStringFrom)
            {
                return subStringFrom.ToString();
            }

            /// <summary>
            /// Renvoie une chaine équivalente à la portion de chaine
            /// </summary>
            /// <returns>Une chaine équivalente à la portion de chaine</returns>
            public override string ToString()
            {
                if (this.Start < 0)
                    return String.Empty;
                return this.String.Substring(this.Start);
            }
        }

        #endregion

        /// <summary>
        /// Vérifie qu'une chaine se termine par le suffixe spécifié et l'ajoute si ce n'est pas le cas.
        /// </summary>
        /// <param name="s">Chaine originale</param>
        /// <param name="suffix">Suffixe à vérifier et éventuellement ajouter</param>
        /// <returns>La chaine originale si elle se termine par le le suffixe spécifié, sinon la chaine originale suivie du suffixe</returns>
        public static string EnsureEndsWith(this string s, string suffix)
        {
            s.CheckArgumentNull("s");
            if (!s.EndsWith(suffix))
                return s + suffix;
            return s;
        }

        /// <summary>
        /// Vérifie qu'une chaine commence par le préfixe spécifié et l'ajoute si ce n'est pas le cas.
        /// </summary>
        /// <param name="s">Chaine originale</param>
        /// <param name="prefix">Préfixe à vérifier et éventuellement ajouter</param>
        /// <returns>La chaine originale si elle commence par le le préfixe spécifié, sinon la chaine originale précédée du préfixe</returns>
        public static string EnsureStartsWith(this string s, string prefix)
        {
            s.CheckArgumentNull("s");
            if (!s.StartsWith(prefix))
                return prefix + s;
            return s;
        }

        private static readonly Regex _emailRegex = new Regex(@"^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+[a-z]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$", CH.RegexOptions.Compiled | RegexOptions.IgnoreCase);

        ///<summary>
        /// Vérifie si une chaine de caractères est une adresse email valide
        ///</summary>
        ///<param name="email">La chaine à vérifier</param>
        ///<returns>true si la chaine est une adresse email valide, false sinon</returns>
        public static bool IsValidEmail(this string email)
        {
            email.CheckArgumentNull("email");
            return _emailRegex.IsMatch(email);
        }

        /// <summary>
        /// Détermine si deux objets String ont la même valeur. Null et string.Empty sont considérés comme égaux
        /// </summary>
        /// <param name="baseString">chaîne servant de base à la comparaison</param>
        /// <param name="comparedString">chaîne à comparer</param>
        /// <returns>booléen indiquant si les deux chaînes sont égales</returns>
        public static bool EqualsWithNullAsEmpty(this string baseString, string comparedString)
        {
            if (string.IsNullOrEmpty(baseString))
                return string.IsNullOrEmpty(comparedString);
            return baseString.Equals(comparedString);
        }

        /// <summary>
        /// Détermine si deux objets String ont la même valeur. Null et string.Empty sont considérés comme égaux
        /// </summary>
        /// <param name="baseString">chaîne servant de base à la comparaison</param>
        /// <param name="comparedString">chaîne à comparer</param>
        /// <param name="comparisonType">l'une des valeurs System.StringComparison</param>
        /// <returns>booléen indiquant si les deux chaînes sont égales</returns>
        public static bool EqualsWithNullAsEmpty(this string baseString, string comparedString, StringComparison comparisonType)
        {
            if (string.IsNullOrEmpty(baseString))
                return string.IsNullOrEmpty(comparedString);
            return baseString.Equals(comparedString, comparisonType);
        }

        ///<summary>
        /// Détermine si une chaine de caractères contient la sous-chaine spécifiée, en utilisant le type de comparison spécifié.
        ///</summary>
        ///<param name="s">chaine dans laquelle on recherche la sous-chaine</param>
        ///<param name="subString">sous-chaine recherchée</param>
        ///<param name="comparisonType">l'une des valeurs System.StringComparison</param>
        ///<returns>true si <c>s</c> contient <c>subString</c>, sinon false</returns>
        public static bool Contains(this string s, string subString, StringComparison comparisonType)
        {
            s.CheckArgumentNull("s");
            subString.CheckArgumentNull("subString");
            comparisonType.CheckArgumentInEnum("comparisonType");
            return s.IndexOf(subString, comparisonType) >= 0;
        }

        /// <summary>
        /// Remplace le caractère à la position spécifiée d'une chaine par le caractère spécifié.
        /// </summary>
        /// <param name="s">Chaine dans laquelle remplacer un caractère</param>
        /// <param name="index">Position à laquelle remplacer le caractère</param>
        /// <param name="newChar">Caractère de remplacement</param>
        /// <returns>La chaine modifiée.</returns>
        /// <remarks>Tout comme la méthode Replace, cette méthode ne modifie pas
        /// la chaine d'origine, mais renvoie une nouvelle chaine qui contient la
        /// modification.</remarks>
        public static string ReplaceAt(this string s, int index, char newChar)
        {
            s.CheckArgumentNull("s");
            index.CheckArgumentOutOfRange("index", 0, s.Length - 1);

            var chars = s.ToCharArray();
            chars[index] = newChar;
            return new string(chars);
        }
    }
}