Conversion d'une chaîne en double en C#

Question

J'ai une longue chaîne de caractères avec des valeurs de type double séparées par des # - value1#value2#value3# etc.

Je l'ai divisé en tables de cordes. Ensuite, je veux convertir chaque élément de ce tableau en type double et j'obtiens une erreur. Qu'est-ce qui ne va pas avec la conversion de type ici ?

string a = "52.8725945#18.69872650000002#50.9028073#14.971600200000012#51.260062#15.5859949000000662452.23862099999999#19.372202799999250800000045#51.7808372#19.474096499999973#";
string[] someArray = a.Split(new char[] { '#' });
for (int i = 0; i < someArray.Length; i++)
{
    Console.WriteLine(someArray[i]); // correct value
    Convert.ToDouble(someArray[i]); // error
}

Answer 1

Il y a trois problèmes.

1) Séparateur décimal incorrect

Des cultures différentes utilisent des séparateurs décimaux différents (à savoir , y . ).

Si vous remplacez . con , il devrait fonctionner comme prévu :

Console.WriteLine(Convert.ToDouble("52,8725945"));

Vous pouvez analyser vos doubles en utilisant une méthode surchargée qui prend la culture comme second paramètre. Dans ce cas, vous pouvez utiliser InvariantCulture ( Quelle est la culture invariante ), par exemple en utilisant double.Parse :

double.Parse("52.8725945", System.Globalization.CultureInfo.InvariantCulture);

Vous pouvez également consulter double.TryParse Vous pouvez l'utiliser avec de nombreuses options et il est particulièrement utile pour vérifier si votre chaîne de caractères est valide ou non. double .

2) Vous avez un double incorrect

L'une de vos valeurs est incorrecte, car elle contient deux points :

15.5859949000000662452.23862099999999

3) Votre tableau a une valeur vide à la fin, ce qui est un double incorrect.

Vous pouvez utiliser des Split qui supprime les valeurs vides :

string[] someArray = a.Split(new char[] { '#' }, StringSplitOptions.RemoveEmptyEntries);

Answer 2

Ajouter une classe en tant que Public et l'utiliser très facilement comme convertToInt32()

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Web;

  /// <summary>
  /// Summary description for Common
  /// </summary>
  public static class Common
  {
     public static double ConvertToDouble(string Value) {
        if (Value == null) {
           return 0;
        }
        else {
           double OutVal;
           double.TryParse(Value, out OutVal);

           if (double.IsNaN(OutVal) || double.IsInfinity(OutVal)) {
              return 0;
           }
           return OutVal;
        }
     }
  }

Puis appeler la fonction

double DirectExpense =  Common.ConvertToDouble(dr["DrAmount"].ToString());

Answer 3

La plupart des personnes ont déjà essayé de répondre à vos questions.
Si vous êtes toujours en train de déboguer, avez-vous pensé à utiliser :

Double.TryParse(String, Double);

Cela vous aidera à déterminer ce qui ne va pas dans chacune des chaînes avant de procéder à l'analyse proprement dite.
Si vous avez un problème lié à la culture, vous pouvez envisager d'utiliser :

Double.TryParse(String, NumberStyles, IFormatProvider, Double);

Le présent http://msdn.microsoft.com/en-us/library/system.double.tryparse.aspx donne un très bon exemple de leur utilisation.

Si vous avez besoin d'un long, Int64.TryParse est également disponible : http://msdn.microsoft.com/en-us/library/system.int64.tryparse.aspx

J'espère que cela vous aidera.

Answer 4

private double ConvertToDouble(string s)
    {
        char systemSeparator = Thread.CurrentThread.CurrentCulture.NumberFormat.CurrencyDecimalSeparator[0];
        double result = 0;
        try
        {
            if (s != null)
                if (!s.Contains(","))
                    result = double.Parse(s, CultureInfo.InvariantCulture);
                else
                    result = Convert.ToDouble(s.Replace(".", systemSeparator.ToString()).Replace(",", systemSeparator.ToString()));
        }
        catch (Exception e)
        {
            try
            {
                result = Convert.ToDouble(s);
            }
            catch
            {
                try
                {
                    result = Convert.ToDouble(s.Replace(",", ";").Replace(".", ",").Replace(";", "."));
                }
                catch {
                    throw new Exception("Wrong string-to-double format");
                }
            }
        }
        return result;
    }

et les tests réussis sont les suivants :

        Debug.Assert(ConvertToDouble("1.000.007") == 1000007.00);
        Debug.Assert(ConvertToDouble("1.000.007,00") == 1000007.00);
        Debug.Assert(ConvertToDouble("1.000,07") == 1000.07);
        Debug.Assert(ConvertToDouble("1,000,007") == 1000007.00);
        Debug.Assert(ConvertToDouble("1,000,000.07") == 1000000.07);
        Debug.Assert(ConvertToDouble("1,007") == 1.007);
        Debug.Assert(ConvertToDouble("1.07") == 1.07);
        Debug.Assert(ConvertToDouble("1.007") == 1007.00);
        Debug.Assert(ConvertToDouble("1.000.007E-08") == 0.07);
        Debug.Assert(ConvertToDouble("1,000,007E-08") == 0.07);

Answer 5

Vous pouvez essayer cet exemple. Un programme C# simple pour convertir une chaîne de caractères en un nombre double

class Calculations{

protected double length;
protected double height;
protected double width;

public void get_data(){

this.length = Convert.ToDouble(Console.ReadLine());
this.width  = Convert.ToDouble(Console.ReadLine());
this.height = Convert.ToDouble(Console.ReadLine());

   }
}