Como formatar uma seqüência de caracteres como um número de telefone em c #

Eu tenho uma string “1112224444” é um número de telefone. Eu quero formatar como 111-222-4444 antes de armazená-lo em um arquivo. Ele está em um datarecord e eu preferiria ser capaz de fazer isso sem atribuir um novo variável.

Eu estava pensando:

String.Format("{0:###-###-####}", i["MyPhone"].ToString() ); 

mas isso não parece fazer o truque.

** ATUALIZAÇÃO **

Está bem. Eu fui com essa solução

 Convert.ToInt64(i["Customer Phone"]).ToString("###-###-#### ####") 

Agora fica confuso quando a extensão é menor que 4 dígitos. Ele irá preencher os números da direita. assim

 1112224444 333 becomes 11-221-244 3334 

Alguma ideia?

    Por favor, note que esta resposta funciona com tipos de dados numéricos (int, long). Se você está começando com uma string, você precisará convertê-lo para um número primeiro. Além disso, leve em consideração que você precisará validar se a string inicial tem pelo menos 10 caracteres de comprimento.

    De uma boa página cheia de exemplos:

     String.Format("{0:(###) ###-####}", 8005551212); This will output "(800) 555-1212". 

    Embora um regex possa funcionar ainda melhor, tenha em mente a antiga citação de programação:

    Algumas pessoas, quando confrontadas com um problema, pensam “eu sei, usarei expressões regulares”. Agora elas têm dois problemas.
    – Jamie Zawinski, em comp.lang.emacs

    Eu prefiro usar expressões regulares:

     Regex.Replace("1112224444", @"(\d{3})(\d{3})(\d{4})", "$1-$2-$3"); 

    Você precisará dividi-lo em substrings. Enquanto você poderia fazer isso sem quaisquer variables ​​extras, não seria particularmente agradável. Aqui está uma solução em potencial:

     string phone = i["MyPhone"].ToString(); string area = phone.Substring(0, 3); string major = phone.Substring(3, 3); string minor = phone.Substring(6); string formatted = string.Format("{0}-{1}-{2}", area, major, minor); 

    Tanto quanto eu sei que você não pode fazer isso com string.Format … você teria que lidar com isso sozinho. Você pode remover todos os caracteres não numéricos e fazer algo como:

     string.Format("({0}) {1}-{2}", phoneNumber.Substring(0, 3), phoneNumber.Substring(3, 3), phoneNumber.Substring(6)); 

    Isso pressupõe que os dados foram inseridos corretamente, que você pode usar expressões regulares para validar.

    Eu sugiro isso como uma solução limpa para os números dos EUA.

     public static string PhoneNumber(string value) { value = new System.Text.RegularExpressions.Regex(@"\D") .Replace(value, string.Empty); value = value.TrimStart('1'); if (value.Length == 7) return Convert.ToInt64(value).ToString("###-####"); if (value.Length == 10) return Convert.ToInt64(value).ToString("###-###-####"); if (value.Length > 10) return Convert.ToInt64(value) .ToString("###-###-#### " + new String('#', (value.Length - 10))); return value; } 

    Isso deve funcionar:

     String.Format("{0:(###)###-####}", Convert.ToInt64("1112224444")); 

    OU no seu caso:

     String.Format("{0:###-###-####}", Convert.ToInt64("1112224444")); 

    Se você conseguir i["MyPhone"] por long , você pode usar o método long.ToString() para formatá-lo:

     Convert.ToLong(i["MyPhone"]).ToString("###-###-####"); 

    Veja a página do MSDN em Cadeias de Formato Numérico .

    Tenha o cuidado de usar long em vez de int: int poderia transbordar.

     static string FormatPhoneNumber( string phoneNumber ) { if ( String.IsNullOrEmpty(phoneNumber) ) return phoneNumber; Regex phoneParser = null; string format = ""; switch( phoneNumber.Length ) { case 5 : phoneParser = new Regex(@"(\d{3})(\d{2})"); format = "$1 $2"; break; case 6 : phoneParser = new Regex(@"(\d{2})(\d{2})(\d{2})"); format = "$1 $2 $3"; break; case 7 : phoneParser = new Regex(@"(\d{3})(\d{2})(\d{2})"); format = "$1 $2 $3"; break; case 8 : phoneParser = new Regex(@"(\d{4})(\d{2})(\d{2})"); format = "$1 $2 $3"; break; case 9 : phoneParser = new Regex(@"(\d{4})(\d{3})(\d{2})(\d{2})"); format = "$1 $2 $3 $4"; break; case 10 : phoneParser = new Regex(@"(\d{3})(\d{3})(\d{2})(\d{2})"); format = "$1 $2 $3 $4"; break; case 11 : phoneParser = new Regex(@"(\d{4})(\d{3})(\d{2})(\d{2})"); format = "$1 $2 $3 $4"; break; default: return phoneNumber; }//switch return phoneParser.Replace( phoneNumber, format ); }//FormatPhoneNumber enter code here 

    Se você está procurando o número de telefone a ser convertido em tempo real. Eu sugiro usar um ajudante. Eu tentei usar String.Format sozinho, no entanto, o resultado da interface do usuário foi decepcionante. Este método funciona perfeitamente sem preencher os números para trás como String.Format solução faz. Basta aplicar o formatador ao seu valor de class.

     private string PhoneNumberFormatter(string value) { value = new Regex(@"\D").Replace(value, string.Empty); value = value.TrimStart('1'); if (value.Length > 0 & value.Length < 4) { value = string.Format("({0})", value.Substring(0, value.Length)); return value; } if (value.Length > 3 & value.Length < 7) { value = string.Format("({0}) {1}", value.Substring(0, 3), value.Substring(3, value.Length - 3)); return value; } if (value.Length > 6 & value.Length < 11) { value = string.Format("({0}) {1}-{2}", value.Substring(0, 3), value.Substring(3, 3), value.Substring(6)); return value; } if (value.Length > 10) { value = value.Remove(value.Length - 1, 1); value = string.Format("({0}) {1}-{2}", value.Substring(0, 3), value.Substring(3, 3), value.Substring(6)); return value; } return value; } 
     Function FormatPhoneNumber(ByVal myNumber As String) Dim mynewNumber As String mynewNumber = "" myNumber = myNumber.Replace("(", "").Replace(")", "").Replace("-", "") If myNumber.Length < 10 Then mynewNumber = myNumber ElseIf myNumber.Length = 10 Then mynewNumber = "(" & myNumber.Substring(0, 3) & ") " & myNumber.Substring(3, 3) & "-" & myNumber.Substring(6, 3) ElseIf myNumber.Length > 10 Then mynewNumber = "(" & myNumber.Substring(0, 3) & ") " & myNumber.Substring(3, 3) & "-" & myNumber.Substring(6, 3) & " " & myNumber.Substring(10) End If Return mynewNumber End Function 

    Você pode se encontrar na situação em que você tem usuários tentando digitar números de telefone com todos os tipos de separadores entre o código de área e o bloco do número principal (por exemplo, espaços, traços, pontos, etc.). tira a input de todos os caracteres que não são números para que você possa esterilizar a input com a qual está trabalhando. A maneira mais fácil de fazer isso é com uma expressão RegEx.

     string formattedPhoneNumber = new System.Text.RegularExpressions.Regex(@"\D") .Replace(originalPhoneNumber, string.Empty); 

    Então a resposta que você listou deve funcionar na maioria dos casos.

    Para responder o que você tem sobre o seu problema de extensão, você pode retirar tudo o que for maior do que o tamanho esperado de dez (para um número de telefone normal) e adicioná-lo ao final usando

     formattedPhoneNumber = Convert.ToInt64(formattedPhoneNumber) .ToString("###-###-#### " + new String('#', (value.Length - 10))); 

    Você desejará fazer uma verificação ‘if’ para determinar se o tamanho de sua input é maior que 10 antes de fazer isso, se não, basta usar:

     formattedPhoneNumber = Convert.ToInt64(value).ToString("###-###-####"); 

    Use Match no Regex para dividir e, em seguida, imprima a string formatada com o match.groups

     Regex regex = new Regex(@"(?\d{3})(?\d{3})(?\d{4})"); Match match = regex.Match(phone); if (match.Success) return "(" + match.Groups["first3chr"].ToString() + ")" + " " + match.Groups["next3chr"].ToString() + "-" + match.Groups["next4chr"].ToString(); 

    Você também pode tentar isto:

      public string GetFormattedPhoneNumber(string phone) { if (phone != null && phone.Trim().Length == 10) return string.Format("({0}) {1}-{2}", phone.Substring(0, 3), phone.Substring(3, 3), phone.Substring(6, 4)); return phone; } 

    Saída:

    insira a descrição da imagem aqui

    Tente isso

     string result; if ( (!string.IsNullOrEmpty(phoneNumber)) && (phoneNumber.Length >= 10 ) ) result = string.Format("{0:(###)###-"+new string('#',phoneNumber.Length-6)+"}", Convert.ToInt64(phoneNumber) ); else result = phoneNumber; return result; 

    Felicidades.

     public string phoneformat(string phnumber) { String phone=phnumber; string countrycode = phone.Substring(0, 3); string Areacode = phone.Substring(3, 3); string number = phone.Substring(6,phone.Length); phnumber="("+countrycode+")" +Areacode+"-" +number ; return phnumber; } 

    A saída será: 001-568-895623

    O seguinte irá funcionar sem o uso de expressão regular

     string primaryContactNumber = !string.IsNullOrEmpty(formData.Profile.Phone) ? String.Format("{0:###-###-####}", long.Parse(formData.Profile.Phone)) : ""; 

    Se não usamos long.Parse, o string.format não funcionará.

    Para cuidar do seu problema de extensão, que tal:

     string formatString = "###-###-#### ####"; returnValue = Convert.ToInt64(phoneNumber) .ToString(formatString.Substring(0,phoneNumber.Length+3)) .Trim(); 

    Não para ressuscitar uma pergunta antiga, mas imaginei que poderia oferecer pelo menos um método um pouco mais fácil de usar, se um pouco mais complicado de uma configuração.

    Portanto, se criarmos um novo formatador personalizado, poderemos usar a formatação mais simples de string.Format sem precisar converter nosso número de telefone em um long

    Então, primeiro vamos criar o formatador personalizado:

     using System; using System.Globalization; using System.Text; namespace System { ///  /// A formatter that will apply a format to a string of numeric values. ///  ///  /// The following example converts a string of numbers and inserts dashes between them. ///  /// public class Example /// { /// public static void Main() /// { /// string stringValue = "123456789"; /// /// Console.WriteLine(String.Format(new NumericStringFormatter(), /// "{0} (formatted: {0:###-##-####})",stringValue)); /// } /// } /// // The example displays the following output: /// // 123456789 (formatted: 123-45-6789) ///  ///  public class NumericStringFormatter : IFormatProvider, ICustomFormatter { ///  /// Converts the value of a specified object to an equivalent string representation using specified format and /// culture-specific formatting information. ///  /// A format string containing formatting specifications. /// An object to format. /// An object that supplies format information about the current instance. ///  /// The string representation of the value of , formatted as specified by ///  and . ///  ///  public string Format(string format, object arg, IFormatProvider formatProvider) { var strArg = arg as string; // If the arg is not a string then determine if it can be handled by another formatter if (strArg == null) { try { return HandleOtherFormats(format, arg); } catch (FormatException e) { throw new FormatException(string.Format("The format of '{0}' is invalid.", format), e); } } // If the format is not set then determine if it can be handled by another formatter if (string.IsNullOrEmpty(format)) { try { return HandleOtherFormats(format, arg); } catch (FormatException e) { throw new FormatException(string.Format("The format of '{0}' is invalid.", format), e); } } var sb = new StringBuilder(); var i = 0; foreach (var c in format) { if (c == '#') { if (i < strArg.Length) { sb.Append(strArg[i]); } i++; } else { sb.Append(c); } } return sb.ToString(); } ///  /// Returns an object that provides formatting services for the specified type. ///  /// An object that specifies the type of format object to return. ///  /// An instance of the object specified by , if the ///  implementation can supply that type of object; otherwise, null. ///  public object GetFormat(Type formatType) { // Determine whether custom formatting object is requested. return formatType == typeof(ICustomFormatter) ? this : null; } private string HandleOtherFormats(string format, object arg) { if (arg is IFormattable) return ((IFormattable)arg).ToString(format, CultureInfo.CurrentCulture); else if (arg != null) return arg.ToString(); else return string.Empty; } } } 

    Então, se você quiser usar isso, você faria algo assim:

     String.Format(new NumericStringFormatter(),"{0:###-###-####}", i["MyPhone"].ToString()); 

    Algumas outras coisas para pensar:

    No momento, se você especificou um formatador mais longo do que uma string para formatá-lo, ele simplesmente ignorará os sinais # adicionais. Por exemplo, este String.Format(new NumericStringFormatter(),"{0:###-###-####}", "12345"); resultaria em 123-45- então você pode querer ter algum tipo de caractere de preenchimento possível no construtor.

    Também não forneci uma maneira de escaping de um sinal #, por isso, se você quisesse include isso em sua string de saída, você não seria capaz de fazê-lo agora.

    A razão pela qual eu prefiro esse método em relação ao Regex é que eu geralmente tenho requisitos para permitir que os usuários especifiquem o formato em si e é consideravelmente mais fácil para mim explicar como usar esse formato do que tentar ensinar um regex de usuário.

    Além disso, o nome da class é um pouco inadequado, pois funciona para formatar qualquer string, desde que você queira mantê-la na mesma ordem e apenas inserir caracteres dentro dela.

    Por favor, use o seguinte link para C # http://www.beansoftware.com/NET-Tutorials/format-string-phone-number.aspx

    A maneira mais fácil de fazer o formato é usando o Regex.

     private string FormatPhoneNumber(string phoneNum) { string phoneFormat = "(###) ###-#### x####"; Regex regexObj = new Regex(@"[^\d]"); phoneNum = regexObj.Replace(phoneNum, ""); if (phoneNum.Length > 0) { phoneNum = Convert.ToInt64(phoneNum).ToString(phoneFormat); } return phoneNum; } 

    Passe o seu phoneNum como string 2021231234 até 15 caracteres.

     FormatPhoneNumber(string phoneNum) 

    Outra abordagem seria usar Substring

     private string PhoneFormat(string phoneNum) { int max = 15, min = 10; string areaCode = phoneNum.Substring(0, 3); string mid = phoneNum.Substring(3, 3); string lastFour = phoneNum.Substring(6, 4); string extension = phoneNum.Substring(10, phoneNum.Length - min); if (phoneNum.Length == min) { return $"({areaCode}) {mid}-{lastFour}"; } else if (phoneNum.Length > min && phoneNum.Length <= max) { return $"({areaCode}) {mid}-{lastFour} x{extension}"; } return phoneNum; }