Analyse des chaînes de caractères pour les doubler avec une virgule et un point

Question

J'essaie d'écrire une fonction qui convertit un tableau de chaînes de caractères en un tableau de chaînes de caractères où tous les doubles du tableau sont arrondis au nombre de décimales que j'ai fixé. Il peut aussi y avoir des chaînes dans le tableau qui ne sont pas du tout des valeurs doubles.

string[,] values = new string[1, 3];

values[0, 0] = "hello";
values[0, 1] = "0.123";
values[0, 2] = "0,123";

int decimalPlaces = 2;

double tmp;
string format = "F" + decimalPlaces.ToString();
IFormatProvider provider = CultureInfo.InvariantCulture;
for (int i = 0; i < values.GetLength(0); i++)
{
    for (int j = 0; j < values.GetLength(1); j++)
    {
        if (double.TryParse(values[i, j], out tmp))
        {
            values[i, j] = tmp.ToString(format, provider);
        }
    }
}

Console.ReadLine();

Le résultat doit être : "hello" , "0.12", "0.12" mais "hello", "123.00", "0.12" traitera la virgule de la mauvaise manière. Quelqu'un a-t-il une solution simple et efficace ?

Answer 1

Utilisation simple :

double.Parse("3.5", CultureInfo.InvariantCulture)

Answer 2

Utilisez cette surcharge de double.TryParse pour spécifier les formats autorisés :

Méthode Double.TryParse (String, NumberStyles, IFormatProvider, Double%)

Par défaut, double.TryParse analyse les données en fonction des formats spécifiques à la culture actuelle.

Answer 3

Extension permettant d'analyser un nombre décimal à partir d'une chaîne de caractères.

• Peu importe le nombre qui se trouve au début, à la fin ou au milieu d'une chaîne.
• Peu importe qu'il n'y ait qu'un certain nombre ou un grand nombre de lettres "poubelles".
• Quel que soit le délimiteur configuré dans les paramètres culturels du PC, il analysera correctement le point et la virgule.

• Possibilité de définir manuellement le symbole décimal.

  public static class StringExtension
  {
      public static double DoubleParseAdvanced(this string strToParse, char decimalSymbol = ',')
      {
          string tmp = Regex.Match(strToParse, @"([-]?[0-9]+)([\s])?([0-9]+)?[." + decimalSymbol + "]?([0-9 ]+)?([0-9]+)?").Value;
  
          if (tmp.Length > 0 && strToParse.Contains(tmp))
          {
              var currDecSeparator = System.Windows.Forms.Application.CurrentCulture.NumberFormat.NumberDecimalSeparator;
  
              tmp = tmp.Replace(".", currDecSeparator).Replace(decimalSymbol.ToString(), currDecSeparator);
  
              return double.Parse(tmp);
          }
  
          return 0;
      }
  }

Comment l'utiliser ?

"It's 4.45 O'clock now".DoubleParseAdvanced(); // will return 4.45
"It's 4,45 O'clock now".DoubleParseAdvanced(); // will return 4.45
"It's 4:45 O'clock now".DoubleParseAdvanced(':'); // will return 4.45

Answer 4

J'utilise l'extrait suivant si je veux analyser un nombre avec un séparateur décimal et rien d'autre :

public bool TryParseDecimal(string value, out decimal result) {
    const string your_separator = ",";

    var numberFormat = new NumberFormatInfo {
            NumberDecimalSeparator = your_separator
    };

    return decimal.TryParse(value, NumberStyles.AllowDecimalPoint, numberFormat, out result);
}

Je ne pense pas que l'utilisation d'une culture ou d'une manipulation de chaîne exprime l'intention de convertir un nombre avec un point décimal autre que '.

Answer 5

Pour moi, l'utilisation de l'info culture n'était pas une option, car l'application fonctionnait sur des systèmes de cultures différentes, mais les chaînes d'entrée à analyser étaient de culture inconnue.

Je me suis donc référé à la normalisation de la représentation de la chaîne, puis à sa conversion à l'aide de CultureInfo.InvariantCulture :

    private static double NormalizeAndParse(string strDouble)
    {
        string strDoubleNormalized;

        if (strDouble.Contains(","))
        {
            var strReplaced = strDouble.Replace(",", ".");
            var decimalSeparatorPos = strReplaced.LastIndexOf('.');
            var strInteger = strReplaced.Substring(0, decimalSeparatorPos);
            var strFractional = strReplaced.Substring(decimalSeparatorPos);

            strInteger = strInteger.Replace(".", string.Empty);
            strDoubleNormalized = strInteger + strFractional;
        }
        else
        {
            strDoubleNormalized = strDouble;
        }

        return Double.Parse(strDoubleNormalized, NumberStyles.Any, CultureInfo.InvariantCulture);
    }