So formatieren Sie eine Zeichenfolge als Telefonnummer in C #

Ich habe eine Zeichenfolge "1112224444", es ist eine Telefonnummer. Ich möchte sie als 111-222-4444 formatieren, bevor ich sie in einer Datei speichere. Sie befindet sich in einem Datenkabel und ich würde es vorziehen, dies zu tun, ohne eine neue zuzuweisen Variable.

Ich dachte:

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

aber das scheint nicht den Trick zu tun.

** UPDATE **

OK. Ich habe mich für diese Lösung entschieden

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

Jetzt wird es durcheinander gebracht, wenn die Nebenstelle weniger als 4 Stellen hat. Es wird die Zahlen von rechts ausfüllen. so

1112224444 333  becomes

11-221-244 3334

Irgendwelche Ideen?

Bitte beachten Sie, dass diese Antwort mit numerischen Datentypen (int, long) funktioniert. Wenn Sie mit einer Zeichenfolge beginnen, müssen Sie diese zuerst in eine Zahl konvertieren. Beachten Sie außerdem, dass Sie überprüfen müssen, ob die ursprüngliche Zeichenfolge mindestens 10 Zeichen lang ist.

Von einer guten Seite voller Beispiele:

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

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

Obwohl ein Regex möglicherweise noch besser funktioniert, beachten Sie das alte Programmierzitat:

Einige Leute denken, wenn sie mit einem Problem konfrontiert werden: "Ich weiß, ich werde reguläre Ausdrücke verwenden." Jetzt haben sie zwei Probleme.
- Jamie Zawinski, in comp.lang.emacs

Ich bevorzuge reguläre Ausdrücke:

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

Sie müssen es in Teilzeichenfolgen aufteilen. Sie könnten dies zwar ohne zusätzliche Variablen tun, aber es wäre nicht besonders schön. Hier ist eine mögliche Lösung:

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

Ich schlage dies als saubere Lösung für US-Nummern vor.

public static string PhoneNumber(string value)
{ 
    if (string.IsNullOrEmpty(value)) return string.Empty;
    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;
}

Soweit ich weiß, können Sie dies nicht mit string.Format ... tun, Sie müssten dies selbst erledigen. Sie können einfach alle nicht numerischen Zeichen entfernen und dann Folgendes tun:

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

Dies setzt voraus, dass die Daten korrekt eingegeben wurden, und Sie können reguläre Ausdrücke zur Validierung verwenden.

Das sollte funktionieren:

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

ODER in Ihrem Fall:

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

Wenn Sie bekommen können i["MyPhone"]als long, können Sie das verwenden long.ToString()Methode zu formatieren:

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

Weitere Informationen finden Sie auf der MSDN-Seite zu Zeichenfolgen im numerischen Format .

Verwenden Sie lieber long als int: int könnte überlaufen.

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

Wenn Sie nach einer (US-) Telefonnummer suchen, die in Echtzeit konvertiert werden soll. Ich schlage vor, diese Erweiterung zu verwenden. Diese Methode funktioniert perfekt, ohne die Zahlen rückwärts einzugeben. Die String.FormatLösung scheint rückwärts zu funktionieren. Wenden Sie diese Erweiterung einfach auf Ihre Zeichenfolge an.

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

Sie können dies auch versuchen:

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

Ausgabe:

Möglicherweise befinden Sie sich in einer Situation, in der Benutzer versuchen, Telefonnummern mit allen möglichen Trennzeichen zwischen der Vorwahl und dem Hauptnummernblock einzugeben (z. B. Leerzeichen, Bindestriche, Punkte usw.) Entfernen Sie die Eingabe aller Zeichen, die keine Zahlen sind, damit Sie die Eingabe, mit der Sie arbeiten, sterilisieren können. Der einfachste Weg, dies zu tun, ist mit einem RegEx-Ausdruck.

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

Dann sollte die Antwort, die Sie aufgelistet haben, in den meisten Fällen funktionieren.

Um zu beantworten, was Sie über Ihr Nebenstellenproblem haben, können Sie alles entfernen, was länger als die erwartete Länge von zehn ist (für eine normale Telefonnummer), und dies am Ende mit hinzufügen

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

Bevor Sie dies tun, sollten Sie eine "Wenn" -Prüfung durchführen, um festzustellen, ob die Länge Ihrer Eingabe größer als 10 ist. Wenn nicht, verwenden Sie einfach:

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

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

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

Versuche dies

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;

Prost.

Verwenden Sie Match in Regex, um zu teilen, und geben Sie dann eine formatierte Zeichenfolge mit match.groups aus

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

Das Folgende funktioniert ohne Verwendung von regulären Ausdrücken

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

Wenn wir long.Parse nicht verwenden, funktioniert das string.format nicht.

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

Die Ausgabe lautet: 001-568-895623

Bitte verwenden Sie den folgenden Link für C # http://www.beansoftware.com/NET-Tutorials/format-string-phone-number.aspx

Der einfachste Weg, das Format zu erstellen, ist die Verwendung von 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;
}

Übergeben Sie Ihre Telefonnummer als Zeichenfolge 2021231234 mit bis zu 15 Zeichen.

FormatPhoneNumber(string phoneNum)

Ein anderer Ansatz wäre die Verwendung von Teilzeichenfolgen

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

Wie wäre es mit: Um Ihr Erweiterungsproblem zu lösen:

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

Um eine alte Frage nicht wiederzubeleben, dachte ich mir, ich könnte zumindest eine etwas einfacher zu verwendende Methode anbieten, wenn auch ein etwas komplizierteres Setup.

Wenn wir also einen neuen benutzerdefinierten Formatierer erstellen, können wir die einfachere Formatierung von verwenden, string.Formatohne unsere Telefonnummer in eine konvertieren zu müssenlong

Erstellen wir also zuerst den benutzerdefinierten Formatierer:

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

Wenn Sie dies also verwenden möchten, würden Sie Folgendes tun:

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

Einige andere Dinge, über die man nachdenken sollte:

Wenn Sie jetzt einen längeren Formatierer angegeben haben als eine Zeichenfolge zum Formatieren, werden die zusätzlichen # -Zeichen einfach ignoriert. Dies String.Format(new NumericStringFormatter(),"{0:###-###-####}", "12345");würde beispielsweise zu 123-45 führen, sodass Sie möglicherweise möchten, dass im Konstruktor ein mögliches Füllzeichen verwendet wird.

Außerdem habe ich keine Möglichkeit bereitgestellt, einem # -Zeichen zu entkommen. Wenn Sie dies also in Ihre Ausgabezeichenfolge aufnehmen möchten, können Sie nicht so sein, wie es jetzt ist.

Der Grund, warum ich diese Methode Regex vorziehe, ist, dass ich häufig Anforderungen habe, die es Benutzern ermöglichen, das Format selbst anzugeben, und es für mich erheblich einfacher ist, die Verwendung dieses Formats zu erklären, als zu versuchen, einem Benutzer Regex beizubringen.

Auch der Klassenname ist ein bisschen falsch, da er tatsächlich funktioniert, um eine beliebige Zeichenfolge zu formatieren, solange Sie sie in derselben Reihenfolge halten und nur Zeichen in sie einfügen möchten.

Sie können {0: (000) 000 - ####} versuchen, wenn Ihre Zielnummer mit 0 beginnt.

Hier ist eine andere Möglichkeit, dies zu tun.

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