webentwicklung-frage-antwort-db.com.de

So formatieren Sie eine Zeichenfolge als Telefonnummer in C #

Ich habe eine Zeichenfolge "1112224444". Dies ist eine Telefonnummer. Ich möchte sie als 111-222-4444 formatieren, bevor ich sie in einer Datei speichere. Sie befindet sich auf einem Daten-Datensatz 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 den Trick nicht zu tun.

** UPDATE **

Okay. 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 werden die Zahlen von rechts eingetragen. so

1112224444 333  becomes

11-221-244 3334

Irgendwelche Ideen?

149
Brian G

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 Anfangszeichenfolge mindestens 10 Zeichen lang ist.

Von einer guten Seite voller Beispiele:

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

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

Obwohl ein regulärer Ausdruck möglicherweise noch besser funktioniert, sollten Sie das alte Programmierungszitat beachten:

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

188
Sean

Ich bevorzuge reguläre Ausdrücke:

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

Sie müssen es in Teilzeichenfolgen aufteilen. Während Sie könnte das ohne zusätzliche Variablen tun, wäre es 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);
42
Jon Skeet

Ich empfehle dies als eine saubere Lösung für US-Nummern.

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

Soweit ich weiß, können Sie das nicht mit String machen. Format ... Sie müssten das selbst machen. Sie könnten einfach alle nicht numerischen Zeichen entfernen und dann etwas tun wie:

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, was Sie mit regulären Ausdrücken überprüfen können.

21
mattruma

Das sollte funktionieren:

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

ODER in Ihrem Fall:

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

Wenn Sie i["MyPhone"] Als long erhalten, können Sie es mit der long.ToString() -Methode formatieren:

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

Siehe die MSDN-Seite unter Numeric Format Strings .

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

14
Joel Coehoorn

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. Das String.Format Lösung scheint rückwärts zu funktionieren. Wenden Sie diese Erweiterung einfach auf Ihren String 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;
}
5
James Copeland
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
5
underscore

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:

enter image description here

3
atik sarker
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
3
Arin

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. Am einfachsten geht dies mit einem RegEx-Ausdruck.

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

Dann sollte die von Ihnen aufgeführte Antwort in den meisten Fällen funktionieren.

Um zu beantworten, was Sie zu Ihrem Nebenstellenproblem haben, können Sie alles entfernen, was länger als die erwartete Länge von zehn ist (für eine normale Telefonnummer) und das zum Ende hinzufügen, indem Sie verwenden

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

Bevor Sie dies tun, sollten Sie überprüfen, ob die Länge Ihrer Eingabe größer als 10 ist. Wenn nicht, verwenden Sie einfach:

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

Verwenden Sie Match in Regex zum Teilen und Ausgeben einer formatierten Zeichenfolge mit 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();
2
Sachin Ranadive

Das Folgende funktioniert ohne Verwendung eines regulären Ausdrucks

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

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

2
Rama Krshna Ila

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.

2
Humberto Moreno
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

1
Mak

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

Die einfachste Methode zum Formatieren 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;
}

Geben Sie Ihre Telefonnummer als Zeichenfolge 2021231234 mit bis zu 15 Zeichen ein.

FormatPhoneNumber(string phoneNum)

Ein anderer Ansatz wäre die Verwendung von 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;
    }
1
Mohammed Hossen

Um eine alte Frage nicht wieder aufleben zu lassen, dachte ich mir, ich könnte zumindest eine etwas einfacher zu verwendende Methode anbieten, wenn die Einrichtung etwas komplizierter wäre.

Wenn wir also einen neuen benutzerdefinierten Formatierer erstellen, können wir die einfachere Formatierung von string.Format Verwenden, ohne unsere Telefonnummer in ein long konvertieren zu müssen.

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 im Moment einen längeren Formatierer als einen String zum Formatieren angegeben haben, werden die zusätzlichen # -Zeichen ignoriert. Zum Beispiel würde diese String.Format(new NumericStringFormatter(),"{0:###-###-####}", "12345"); zu 123-45- führen, daher möchten Sie vielleicht, dass es eine Art mögliches Füllzeichen im Konstruktor annimmt.

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

Der Grund, warum ich diese Methode gegenüber Regex bevorzuge, ist, dass ich den Benutzern häufig die Möglichkeit gebe, das Format selbst festzulegen, 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 zum Formatieren beliebiger Zeichenfolgen dient, solange Sie die Reihenfolge beibehalten und nur Zeichen in die Zeichenfolge einfügen möchten.

0
Kent Cooper

Wie wäre es mit:

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

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

0
Alice Guo