Question

我有一个字符串“1112224444”这是一个电话号码。我想将其格式化为111-222-4444，然后将其存储在一个文件中。它在数据线上，我宁愿能够这样做而不用分配一个新变量。

我在想：

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

但这似乎没有成功。

**更新**

确定。我选择了这个解决方案

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

现在，当扩展名小于4位时，它会搞砸。它将填写右边的数字。所以

1112224444 333  becomes

11-221-244 3334

有什么想法吗？

Answer 1

请注意，此答案适用于数字数据类型（int，long）。如果您从字符串开始，则需要先将其转换为数字。另外，请注意您需要验证初始字符串的长度至少为10个字符。

来自good page的例子：

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

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

虽然正则表达式可能会更好，但请记住旧的编程引用：

有些人在面对的时候问题，想想“我知道，我会用正则表达式。“现在他们有两个问题。
--Jamie Zawinski，comp.lang.emacs

Answer 2

我更喜欢使用正则表达式：

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

Answer 3

你需要将其分解为子串。虽然你可以在没有任何额外变量的情况下做到这一点，但它并不是特别好。这是一个潜在的解决方案：

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

Answer 4

据我所知，你不能用string.Format做到这一点......你必须自己处理这个问题。您可以删除所有非数字字符，然后执行以下操作：

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

这假定数据输入正确，您可以使用正则表达式进行验证。

Answer 5

我建议将此作为美国数字的清洁解决方案。

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

Answer 6

这应该有效：

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

或者在你的情况下：

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

Answer 7

如果您可以i["MyPhone"]作为long，则可以使用long.ToString()方法对其进行格式化：

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

请参阅Numeric Format Strings上的MSDN页面。

小心使用long而不是int：int可能溢出。

Answer 8

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

Answer 9

如果您正在寻找实时转换的（美国）电话号码。我建议使用这个扩展名。这种方法可以完美地工作，而不会向后填充数字。 String.Format解决方案似乎可以倒退。只需将此扩展名应用于您的字符串。

public static string PhoneNumberFormatter(this string value)
{
    value = new Regex(@"\D").Replace(value, string.Empty);
    value = value.TrimStart('1');

    if (value.Length == 0)
        value = string.Empty;
    else if (value.Length < 3)
        value = string.Format("({0})", value.Substring(0, value.Length));
    else if (value.Length < 7)
        value = string.Format("({0}) {1}", value.Substring(0, 3), value.Substring(3, value.Length - 3));
    else if (value.Length < 11)
        value = string.Format("({0}) {1}-{2}", value.Substring(0, 3), value.Substring(3, 3), value.Substring(6));
    else 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;
}

Answer 10

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

Answer 11

您可能会发现自己处于这样的情况：用户试图在区号和主号码区之间输入各种分隔符的电话号码（例如，空格，破折号，句点等等）所以你＆＃ 39;我想删除所有不是数字的字符的输入，这样你就可以消毒你正在使用的输入。最简单的方法是使用RegEx表达式。

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

然后你列出的答案应该适用于大多数情况。

要回答有关扩展程序问题的内容，您可以删除超过预期长度10的任何内容（对于常规电话号码）并使用

将其添加到最后

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

你会想做一个＆＃39;如果＆＃39;在执行此操作之前，请检查以确定输入的长度是否大于10，如果不是，请使用：

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

Answer 12

        string phoneNum;
        string phoneFormat = "0#-###-###-####";
        phoneNum = Convert.ToInt64("011234567891").ToString(phoneFormat);

Answer 13

使用字符串插值和新数组index/range

var p = "1234567890";
var formatted = $"({p[0..3]}) {p[3..6]}-{p[6..10]}"

输出：(123) 456-7890

Answer 14

The following will work with out use of regular expression

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

If we dont use long.Parse , the string.format will not work.

Answer 15

使用Regex中的Match进行拆分，然后使用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();

Answer 16

你也可以试试这个：

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

输出：

Answer 17

试试这个

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;

干杯。

Answer 18

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

输出将为：001-568-895623

Answer 19

请使用以下链接获取C＃ http://www.beansoftware.com/NET-Tutorials/format-string-phone-number.aspx

最简单的格式化方法是使用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;
}

将您的phoneNum作为字符串2021231234传递至15个字符。

FormatPhoneNumber(string phoneNum)

另一种方法是使用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;
    }

Answer 20

要处理您的扩展程序问题，请执行以下操作：

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

Answer 21

不要重新提出一个旧问题，但我认为如果设置稍微复杂一点，我可能会提供至少一种稍微容易使用的方法。

因此，如果我们创建新的自定义格式化程序，我们可以使用string.Format的更简单格式，而无需将我们的电话号码转换为long

首先让我们创建自定义格式化程序：

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

那么如果你想使用它，你会做一些事情：

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

需要考虑的其他一些事项：

现在，如果您指定的格式化程序比格式化的字符串长，则只需忽略其他＃符号。例如，此String.Format(new NumericStringFormatter(),"{0:###-###-####}", "12345");将导致123-45- 所以你可能想让它在构造函数中使用某种可能的填充字符。

此外，我没有提供一种逃避＃符号的方法，所以如果你想在你的输出字符串中包含它，你将无法按照现在的方式进行。

我更喜欢这种方法而不是正则表达式的原因是我经常要求允许用户自己指定格式，而且我更容易解释如何使用这种格式而不是尝试教用户正则表达式。

类名也有点用词不当，因为它实际上可以格式化任何字符串，只要你想保持它的顺序相同而只是在其中注入字符。

Answer 22

如果目标号码以0开头，则可以尝试{0：（000）000-####}。

Answer 23

这是另一种方式。

public string formatPhoneNumber(string _phoneNum)
{
    string phoneNum = _phoneNum;
    if (phoneNum == null)
        phoneNum = "";
    phoneNum = phoneNum.PadRight(10 - phoneNum.Length);
    phoneNum = phoneNum.Insert(0, "(").Insert(4,") ").Insert(9,"-");
    return phoneNum;
}

Answer 24

 Label12.Text = Convert.ToInt64(reader[6]).ToString("(###) ###-#### ");

这是我的例子！希望可以帮到您。问候

Answer 25

这是@Jon Skeet 答案的改进版本，带有空检查和扩展方法。

public static string ToTelephoneNumberFormat(this string value, string format = "({0}) {1}-{2}") {
  if (string.IsNullOrWhiteSpace(value)) 
  {
    return value;
  } 
  else 
  {
    string area = value.Substring(0, 3) ?? "";
    string major = value.Substring(3, 3) ?? "";
    string minor = value.Substring(6) ?? "";
    return string.Format(format, area, major, minor);
  }
}

如何在C＃中将字符串格式化为电话号码

25 个答案: