Méthodes utilitaires pour le développement backend en C#

Cet article présente une collection de méthodes statiques essnetielles pour les applications backend ASP.NET. Ces fonctions couvrent la validation des données, la manipulation de chaînes, le chiffrement et la gestion des sessions.

Méthodes de validation courantes

public static class ValidateurDonnees
{
    public static bool ValiderCompte(string valeur)
    {
        return Regex.IsMatch(valeur, @"^[a-zA-Z][a-zA-Z0-9_]{4,15}$", RegexOptions.IgnoreCase);
    }

    public static bool ValiderMotDePasse(string valeur)
    {
        return Regex.IsMatch(valeur, @"^[a-zA-Z]\w{5,17}$", RegexOptions.IgnoreCase);
    }

    public static bool ValiderAdresseEmail(string valeur)
    {
        return Regex.IsMatch(valeur, @"^[A-Za-z0-9](([_\.\-]?[a-zA-Z0-9]+)*)@([A-Za-z0-9]+)(([\.\-]?[a-zA-Z0-9]+)*)\.([A-Za-z]{2,})$", RegexOptions.IgnoreCase);
    }

    public static bool ValiderTelephone(string valeur)
    {
        return Regex.IsMatch(valeur, @"^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$", RegexOptions.IgnoreCase);
    }

    public static bool VerifierNumeroPieceIdentite(string numero)
    {
        if (numero.Length == 18)
        {
            return VerifierPieceIdentite18(numero);
        }
        else if (numero.Length == 15)
        {
            return VerifierPieceIdentite15(numero);
        }
        return false;
    }

    private static bool VerifierPieceIdentite18(string numero)
    {
        long testValeur;
        if (long.TryParse(numero.Remove(17), out testValeur) == false || 
            testValeur < Math.Pow(10, 16) || 
            long.TryParse(numero.Replace('x', '0').Replace('X', '0'), out testValeur) == false)
        {
            return false;
        }

        const string regions = "11x22x35x44x53x12x23x36x45x54x13x31x37x46x61x14x32x41x50x62x15x33x42x51x63x21x34x43x52x64x65x71x81x82x91";
        if (regions.IndexOf(numero.Remove(2), StringComparison.Ordinal) == -1)
        {
            return false;
        }

        string dateNaissance = numero.Substring(6, 8).Insert(6, "-").Insert(4, "-");
        DateTime dateTest;
        if (DateTime.TryParse(dateNaissance, out dateTest) == false)
        {
            return false;
        }

        string[] codesVerification = ("1,0,x,9,8,7,6,5,4,3,2").Split(',');
        string[] poids = ("7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2").Split(',');
        char[] caracteres = numero.Remove(17).ToCharArray();

        int sommeCalculee = 0;
        for (int indice = 0; indice < 17; indice++)
        {
            sommeCalculee += int.Parse(poids[indice]) * int.Parse(caracteres[indice].ToString());
        }

        int reste;
        Math.DivRem(sommeCalculee, 11, out reste);

        return codesVerification[reste].Equals(numero.Substring(17, 1), StringComparison.OrdinalIgnoreCase);
    }

    private static bool VerifierPieceIdentite15(string numero)
    {
        long testValeur;
        if (long.TryParse(numero, out testValeur) == false || testValeur < Math.Pow(10, 14))
        {
            return false;
        }

        const string regions = "11x22x35x44x53x12x23x36x45x54x13x31x37x46x61x14x32x41x50x62x15x33x42x51x63x21x34x43x52x64x65x71x81x82x91";
        if (regions.IndexOf(numero.Remove(2), StringComparison.Ordinal) == -1)
        {
            return false;
        }

        string dateNaissance = numero.Substring(6, 6).Insert(4, "-").Insert(2, "-");
        DateTime dateTest;
        if (DateTime.TryParse(dateNaissance, out dateTest) == false)
        {
            return false;
        }

        return true;
    }
}

View Code

Génération d'horodatage

public static class GenerateurHorodatage
{
    public static string CreerHorodatage()
    {
        TimeSpan intervalle = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
        return Convert.ToInt64(intervalle.TotalSeconds).ToString(CultureInfo.InvariantCulture);
    }
}

View Code

Génération de nombres aléatoires

public static class GenerateurAleatoire
{
    public static string CreerCode(int longueur, int type)
    {
        int valeurNumerique;
        char caractere;
        string resultat = string.Empty;
        var generateur = new Random();

        switch (type)
        {
            case 1:
                for (int i = 0; i < longueur; i++)
                {
                    valeurNumerique = generateur.Next();
                    if (valeurNumerique % 2 == 0)
                        caractere = (char)('0' + (char)(valeurNumerique % 10));
                    else
                        caractere = (char)('A' + (char)(valeurNumerique % 26));

                    resultat += caractere.ToString(CultureInfo.InvariantCulture);
                }
                break;

            case 2:
                for (int i = 0; i < longueur; i++)
                {
                    valeurNumerique = generateur.Next();
                    caractere = (char)('0' + (char)(valeurNumerique % 10));
                    resultat += caractere.ToString(CultureInfo.InvariantCulture);
                }
                break;

            case 3:
                for (int i = 0; i < longueur; i++)
                {
                    valeurNumerique = generateur.Next();
                    caractere = (char)('A' + (char)(valeurNumerique % 26));
                    resultat += caractere.ToString(CultureInfo.InvariantCulture);
                }
                break;
        }

        return resultat;
    }
}

View Code

Conversion de chaînes avec séparateurs

public static class ConvertisseurChaines
{
    public static int[] VersTableauEntiers(string entree)
    {
        int[] tableauResultat = null;
        if (!string.IsNullOrEmpty(entree))
        {
            string nouvelleChaine = entree.TrimEnd(',');
            tableauResultat = nouvelleChaine.Split(',').Select(v => Convert.ToInt32(v)).ToArray();
        }
        return tableauResultat;
    }

    public static string[] VersTableauChaines(string entree)
    {
        string[] tableauResultat = null;
        if (!string.IsNullOrEmpty(entree))
        {
            string nouvelleChaine = entree.TrimEnd(',');
            tableauResultat = nouvelleChaine.Split(',');
        }
        return tableauResultat;
    }
}

View Code

Chiffrement MD5

public static class ChiffrementMD5
{
    public static string Chiffrer16(string texte)
    {
        using (var provider = new MD5CryptoServiceProvider())
        {
            string resultat = BitConverter.ToString(provider.ComputeHash(Encoding.Default.GetBytes(texte)), 4, 8);
            return resultat.Replace("-", "");
        }
    }

    public static string Chiffrer32(string texte)
    {
        using (MD5 algorithm = MD5.Create())
        {
            byte[] octets = algorithm.ComputeHash(Encoding.UTF8.GetBytes(texte));
            string motDePasse = octets.Aggregate("", (actuel, octet) => actuel + octet.ToString("X"));
            return motDePasse.ToLower();
        }
    }
}

View Code

Gestion des sessions

public static class GestionnaireSession
{
    public static void DefinirSession(string nom, string valeur, int dureeExpiration)
    {
        HttpContext.Current.Session[nom] = valeur;
        HttpContext.Current.Session.Timeout = dureeExpiration;
    }

    public static object ObtenirSession(string nom)
    {
        return HttpContext.Current.Session[nom];
    }

    public static void SupprimerSession(string nom)
    {
        HttpContext.Current.Session.Remove(nom);
    }
}

View Code

Exemple d'utilisation :

GestionnaireSession.DefinirSession("utilisateur", "administrateur", 30);
var sessionUtilisateur = GestionnaireSession.ObtenirSession("utilisateur");
GestionnaireSession.SupprimerSession("utilisateur");

Système de journalisation

public static class Journaliseur
{
    public static void EnregistrerEntree(Exception exception)
    {
        if (exception == null) return;

        DateTime maintenant = DateTime.Now;
        string horodatage = maintenant.ToString("yyyy-MM-dd HH:mm:ss");
        string nomFichier = maintenant.ToString("yyyy-MM-dd");
        string repertoire = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "logs");
        string cheminFichier = Path.Combine(repertoire, string.Format("{0}.log", nomFichier));

        try
        {
            var fichierInfo = new FileInfo(cheminFichier);
            if (fichierInfo.Directory != null && !fichierInfo.Directory.Exists)
            {
                fichierInfo.Directory.Create();
            }

            using (var writer = new StreamWriter(cheminFichier, true, Encoding.GetEncoding("utf-8")))
            {
                writer.WriteLine(horodatage);
                writer.WriteLine(exception.Message);
                writer.WriteLine("Détails : " + exception);
                writer.WriteLine("Trace : " + exception.StackTrace);
                writer.WriteLine("Résumé : " + exception.Message);
                writer.WriteLine("\r\n----------------------------------\r\n");
                writer.Flush();
            }
        }
        catch (Exception)
        {
            throw;
        }
    }
}

View Code

Exemple d'utilisation :

try
{
    // Opération susceptible de générer une exception
}
catch (Exception ex)
{
    Journaliseur.EnregistrerEntree(ex);
}

Récupération de l'adresse IP client

public static class InformationsClient
{
    public static string ObtenirAdresseIP()
    {
        string adresse = HttpContext.Current.Request.Headers["X-Real-IP"];
        
        if (!string.IsNullOrEmpty(adresse))
        {
            return adresse;
        }

        if (HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"] != null)
        {
            adresse = HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"].ToString(CultureInfo.InvariantCulture);
        }
        else if (HttpContext.Current.Request.ServerVariables["HTTP_VIA"] != null)
        {
            if (HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"] != null)
            {
                adresse = HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"].ToString(CultureInfo.InvariantCulture);
            }
            else
            {
                adresse = HttpContext.Current.Request.UserHostAddress;
            }
        }
        else
        {
            adresse = HttpContext.Current.Request.UserHostAddress;
        }

        return adresse == "::1" ? string.Empty : adresse;
    }
}

View Code

Publié le 15 octobre à 14h32

L'Atelier Monstre

Méthodes utilitaires pour le développement backend en C#

Étiquettes Populaires