[c#] Cómo formatear una cadena como un número de teléfono en C #


Answers

Prefiero usar expresiones regulares:

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

Tengo un string "1112224444" es un número de teléfono. Quiero formatear como 111-222-4444 antes de almacenarlo en un archivo. Está en un registro de datos y preferiría poder hacer esto sin asignar un nuevo variable.

Yo estaba pensando:

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

pero eso no parece hacer el truco.

** ACTUALIZACIÓN **

De acuerdo. Fui con esta solución

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

Ahora se ensucia cuando la extensión tiene menos de 4 dígitos. Completará los números de la derecha. asi que

1112224444 333  becomes

11-221-244 3334

¿Algunas ideas?




Puede encontrarse en la situación en la que los usuarios intentan ingresar números de teléfono con todo tipo de separadores entre el código de área y el bloque de números principal (por ejemplo, espacios, guiones, puntos, etc.). Así que querrá quite la entrada de todos los caracteres que no son números para que pueda esterilizar la entrada con la que está trabajando. La forma más fácil de hacerlo es con una expresión RegEx.

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

Entonces, la respuesta que ha enumerado debería funcionar en la mayoría de los casos.

Para responder a lo que tiene sobre su problema de extensión, puede quitar cualquier cosa que sea más larga que la longitud esperada de diez (para un número de teléfono normal) y agregar eso hasta el final usando

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

Deberá hacer una comprobación 'si' para determinar si la longitud de su entrada es mayor que 10 antes de hacer esto, de lo contrario, simplemente use:

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



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



No para resucitar una vieja pregunta, pero pensé que podría ofrecer al menos un método un poco más fácil de usar, aunque un poco más complicado de configurar.

Entonces, si creamos un nuevo formateador personalizado, podemos usar el formato más simple de la string.Format sin tener que convertir nuestro número de teléfono a un formato long

Primero, creemos el formateador personalizado:

using System;
using System.Globalization;
using System.Text;

namespace System
{
    /// <summary>
    ///     A formatter that will apply a format to a string of numeric values.
    /// </summary>
    /// <example>
    ///     The following example converts a string of numbers and inserts dashes between them.
    ///     <code>
    /// 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)
    ///  </code>
    /// </example>
    public class NumericStringFormatter : IFormatProvider, ICustomFormatter
    {
        /// <summary>
        ///     Converts the value of a specified object to an equivalent string representation using specified format and
        ///     culture-specific formatting information.
        /// </summary>
        /// <param name="format">A format string containing formatting specifications.</param>
        /// <param name="arg">An object to format.</param>
        /// <param name="formatProvider">An object that supplies format information about the current instance.</param>
        /// <returns>
        ///     The string representation of the value of <paramref name="arg" />, formatted as specified by
        ///     <paramref name="format" /> and <paramref name="formatProvider" />.
        /// </returns>
        /// <exception cref="System.NotImplementedException"></exception>
        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();
        }

        /// <summary>
        ///     Returns an object that provides formatting services for the specified type.
        /// </summary>
        /// <param name="formatType">An object that specifies the type of format object to return.</param>
        /// <returns>
        ///     An instance of the object specified by <paramref name="formatType" />, if the
        ///     <see cref="T:System.IFormatProvider" /> implementation can supply that type of object; otherwise, null.
        /// </returns>
        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;
        }
    }
}

Entonces, si quieres usar esto, harías algo así:

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

Algunas otras cosas para pensar:

En este momento, si especificó un formateador más largo de lo que usó una cadena para formatearlo, simplemente ignorará los # signos adicionales. Por ejemplo, este String.Format(new NumericStringFormatter(),"{0:###-###-####}", "12345"); daría como resultado 123-45, por lo que es posible que desee que tenga algún tipo de carácter de relleno posible en el constructor.

Además, no proporcioné una forma de escapar de un signo #, por lo que si desea incluir eso en la cadena de salida, no podría hacerlo como está ahora.

La razón por la que prefiero este método a través de Regex es que a menudo tengo requisitos para permitirles a los usuarios especificar el formato ellos mismos y es considerablemente más fácil para mí explicar cómo usar este formato que tratar de enseñar a un usuario regular.

Además, el nombre de la clase es un nombre poco apropiado, ya que realmente funciona para formatear cualquier cadena, siempre que quieras mantenerla en el mismo orden y solo inyectar caracteres dentro de ella.




Lo siguiente funcionará sin el uso de expresiones regulares

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

Si no usamos long.Parse, el string.format no funcionará.




Por lo que sé, no puedes hacer esto con una cuerda. Formato ... deberías manejar esto tú mismo. Podrías quitar todos los caracteres no numéricos y luego hacer algo como:

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

Esto supone que los datos se han ingresado correctamente, que puede usar expresiones regulares para validar.




Prueba esto

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;

Aclamaciones.




Usa Match en Regex para dividir, luego da salida a la cadena formateada con match.groups

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



Esto debería funcionar:

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

O en tu caso:

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



Related