String.Format Numéros de téléphone avec extension

Question

J'essaie de créer une fonction qui formate les numéros de téléphone américains, en espérant ne pas avoir à parcourir chaque chiffre en boucle.

Lorsque 10 chiffres sont introduits, tout va bien. Cependant, lorsque plus de 10 chiffres sont entrés, le problème se pose. Je veux que la méthode String.Format ajoute les chiffres de l'extension sur la droite. Par exemple :

Lorsque 14 chiffres sont entrés, le résultat devrait être :(444)555-2222 x8888 Si l'on introduit 12 chiffres, le résultat devrait être :(444)555-2222 x8888 etc. Cependant, le résultat que j'obtiens avec ma tentative actuelle est le suivant : En passant par 12 chiffres, on obtient cette chaîne '() -949 x555444433'.

Voici ce que j'ai jusqu'à présent.

public static string _FormatPhone(object phonevalue)
{
    Int64 phoneDigits;

    if (Int64.TryParse(phonevalue.ToString(), out phoneDigits))
    {
        string cleanPhoneDigits = phoneDigits.ToString();
        int digitCount = cleanPhoneDigits.Length;

        if (digitCount == 10)
            return String.Format("{0:(###) ###-####}", phoneDigits);
        else if (digitCount > 10)
            return String.Format("{0:(###) ###-#### x#########}", phoneDigits);
        else
            return cleanPhoneDigits;
    }

    return "Format Err#";
}

Merci d'avance.

Answer 1

Le problème réside dans votre else if condition où vous avez un nombre déterminé de # des espaces réservés pour gérer l'extension du numéro de téléphone. Au lieu de cela, nous pouvons définir le format de manière dynamique pour tenir compte des différentes longueurs.

Pourquoi passez-vous dans un object ? Vous utilisez ToString() partout. Pourquoi ne pas passer dans un string dès le départ ? Si l'élément que vous passez n'est pas une chaîne de caractères, alors appelez ToString avant de le transmettre, ou sauvegarder le ToString() se traduisent par une variable dans la méthode, comme indiqué ci-dessous.

Voici une version actualisée de votre méthode :

public static string _FormatPhone(object phonevalue)
{
    string returnPhone = "Format Err#";

    Int64 phoneDigits;
    string phoneNumber = phonevalue.ToString();

    if (Int64.TryParse(phoneNumber, out phoneDigits))
    {
        if (phoneNumber.Length == 10)
        {
            return phoneDigits.ToString("(###) ###-####");
        }
        else if (phoneNumber.Length > 10)
        {
            // determine the length of placeholders needed for the format
            string format = "(###) ###-#### x"
                                + new string('#', phoneNumber.Length - 10);
            return phoneDigits.ToString(format);
        }
        else
        {
            return phoneNumber;
        }
    }

    return returnPhone;
}

Pour le tester :

string[] inputs = { "456", "4445552222", "444555222288", "44455522226789" };
foreach (string input in inputs)
{
    Console.WriteLine("Format Result: " + _FormatPhone(input));
}

Il n'y a pas besoin d'une regex dans ce cas. Si vous voulez vraiment en utiliser une, votre méthode de remplacement doit déterminer la longueur afin d'ajouter l'extension si nécessaire, comme indiqué ci-dessous :

string[] inputs = { "456", "4445552222", "444555222288", "44455522226789" };
string pattern = @"(\d{3})(\d{3})(\d{4})(\d*)";
foreach (string input in inputs)
{
    string result = Regex.Replace(input, pattern, m =>
    {
        if (m.Value.Length >= 10)
        {
            return String.Format("({0}) {1}-{2}",
                m.Groups[1].Value, m.Groups[2].Value, m.Groups[3].Value)
                    + (m.Value.Length > 10 ? " x" + m.Groups[4].Value : "");
        }
        return m.Value;
    });
    Console.WriteLine("Regex result: " + result);
}