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





numero solo (17)


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á.

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("###-###-####");



Si puede obtener i["MyPhone"] como long , puede usar el método long.ToString() para formatearlo:

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

Consulte la página de MSDN en cadenas de formato numérico .

Tenga cuidado de usar long en lugar de int: int podría desbordarse.




Utilice el siguiente enlace para C # http://www.beansoftware.com/NET-Tutorials/format-string-phone-number.aspx

La forma más fácil de hacer formato es usar 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;
}

Pase su número de teléfono como cadena 2021231234 hasta 15 caracteres.

FormatPhoneNumber(string phoneNum)

Otro enfoque sería 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;
    }



Para ocuparse de su problema de extensión, qué tal:

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



Sugiero esto como una solución limpia para los números de EE. UU.

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;
}



Si buscas el número de teléfono para convertir en tiempo real. Sugiero usar un ayudante. Intenté usar String.Format solo, sin embargo, el resultado de UI fue decepcionante. Este método funciona perfectamente sin completar los números al revés como lo String.Format solución String.Format . Simplemente aplique el formateador a su valor de clase.

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;
}



Esto debería funcionar:

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

O en tu caso:

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



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



Tendrá que dividirlo en subcadenas. Si bien podría hacerlo sin variables adicionales, no sería particularmente agradable. Aquí hay una solución 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);



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



Prefiero usar expresiones regulares:

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



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.




Tenga en cuenta que esta respuesta funciona con tipos de datos numéricos (int, largo). Si está comenzando con una cadena, primero tendrá que convertirla en un número. Además, tenga en cuenta que deberá validar que la cadena inicial tiene al menos 10 caracteres de longitud.

De una buena página llena de ejemplos:

String.Format("{0:(###) ###-####}", 8005551212);

    This will output "(800) 555-1212".

Aunque una expresión regular puede funcionar aún mejor, tenga en cuenta la antigua cita de programación:

Algunas personas, cuando se enfrentan con un problema, piensan "Lo sé, usaré expresiones regulares". Ahora tienen dos problemas.
--Jamie Zawinski, en comp.lang.emacs




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;
}

La salida será: 001-568-895623




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();



Integer.decode

También puede usar public static Integer decode(String nm) throws NumberFormatException .

También funciona para base 8 y 16:

// base 10
Integer.parseInt("12");     // 12 - int
Integer.valueOf("12");      // 12 - Integer
Integer.decode("12");       // 12 - Integer
// base 8
// 10 (0,1,...,7,10,11,12)
Integer.parseInt("12", 8);  // 10 - int
Integer.valueOf("12", 8);   // 10 - Integer
Integer.decode("012");      // 10 - Integer
// base 16
// 18 (0,1,...,F,10,11,12)
Integer.parseInt("12",16);  // 18 - int
Integer.valueOf("12",16);   // 18 - Integer
Integer.decode("#12");      // 18 - Integer
Integer.decode("0x12");     // 18 - Integer
Integer.decode("0X12");     // 18 - Integer
// base 2
Integer.parseInt("11",2);   // 3 - int
Integer.valueOf("11",2);    // 3 - Integer

Si quieres obtener int lugar de Integer puedes usar:

  1. Unboxing:

    int val = Integer.decode("12"); 
    
  2. intValue() :

    Integer.decode("12").intValue();
    




c# string formatting phone-number