我想解析一个像"3.5"双精度的字符串。然而，
double.Parse("3.5")
产量 35 和
double.Parse("3.5", System.Globalization.NumberStyles.AllowDecimalPoint)
抛出一个FormatException.
现在我的计算机的语言环境设置为德语，其中逗号用作小数分隔符。它可能必须对此做一些事情并double.Parse()期望"3,5"作为输入，但我不确定。
如何解析包含十进制数的字符串，该十进制数可能会或可能不会按照我当前的语言环境中指定的格式进行格式化？
double.Parse("3.5", CultureInfo.InvariantCulture)
我通常使用多文化功能来解析用户输入，主要是因为如果有人习惯了小键盘并且正在使用使用逗号作为小数分隔符的文化，那么该人将使用小键盘的点而不是逗号。
public static double GetDouble(string value, double defaultValue)
{
double result;
//Try parsing in the current culture
if (!double.TryParse(value, System.Globalization.NumberStyles.Any, CultureInfo.CurrentCulture, out result) &&
//Then try in US english
!double.TryParse(value, System.Globalization.NumberStyles.Any, CultureInfo.GetCultureInfo("en-US"), out result) &&
//Then in neutral language
!double.TryParse(value, System.Globalization.NumberStyles.Any, CultureInfo.InvariantCulture, out result))
{
result = defaultValue;
}
return result;
}
但请注意，@nikie 的评论是真实的。为了我的辩护，我在受控环境中使用此功能，我知道文化可以是 en-US、en-CA 或 fr-CA。我使用这个函数是因为在法语中，我们使用逗号作为小数分隔符，但是任何曾经在金融界工作过的人都会在小键盘上使用小数分隔符，但这是一个点，而不是逗号。因此，即使在 fr-CA 文化中，我也需要解析将点作为小数点分隔符的数字。
我不能写评论，所以我在这里写：
double.Parse("3.5", CultureInfo.InvariantCulture)不是一个好主意，因为在加拿大我们写的是 3,5 而不是 3.5，结果这个函数给了我们 35。
我在我的电脑上测试了两者：
double.Parse("3.5", CultureInfo.InvariantCulture) --> 3.5 OK
double.Parse("3,5", CultureInfo.InvariantCulture) --> 35 not OK
这是Pierre-Alain Vigeant提到的正确方法
public static double GetDouble(string value, double defaultValue)
{
double result;
// Try parsing in the current culture
if (!double.TryParse(value, System.Globalization.NumberStyles.Any, CultureInfo.CurrentCulture, out result) &&
// Then try in US english
!double.TryParse(value, System.Globalization.NumberStyles.Any, CultureInfo.GetCultureInfo("en-US"), out result) &&
// Then in neutral language
!double.TryParse(value, System.Globalization.NumberStyles.Any, CultureInfo.InvariantCulture, out result))
{
result = defaultValue;
}
return result;
}
Double.Parse("3,5".Replace(',', '.'), CultureInfo.InvariantCulture)
在解析之前用点替换逗号。在以逗号作为小数分隔符的国家/地区很有用。考虑将用户输入（如有必要）限制为一个逗号或一个点。
看，上面建议用常量字符串替换字符串的每个答案都可能是错误的。为什么？因为你不尊重Windows的区域设置！Windows 保证用户可以自由设置他/她想要的任何分隔符。他/她可以打开控制面板，进入区域面板，点击高级，随时更改角色。即使在您的程序运行期间。想想这个。一个好的解决方案必须意识到这一点。
所以，首先你必须问自己，这个数字来自哪里，你想要解析。如果它来自 .NET Framework 中的输入，则没有问题，因为它将采用相同的格式。但也许它来自外部，也许来自外部服务器，也许来自仅支持字符串属性的旧数据库。在那里，数据库管理员应该给出一个规则，以何种格式存储数字。例如，如果您知道它将是一个美国格式的美国数据库，您可以使用这段代码：
CultureInfo usCulture = new CultureInfo("en-US");
NumberFormatInfo dbNumberFormat = usCulture.NumberFormat;
decimal number = decimal.Parse(db.numberString, dbNumberFormat);
这在世界任何地方都可以正常工作。请不要使用“Convert.ToXxxx”。'Convert' 类仅被认为是任何方向转换的基础。此外：您也可以对 DateTimes 使用类似的机制。
诀窍是使用不变的文化，解析所有文化中的点。
double.Parse("3.5", System.Globalization.NumberStyles.AllowDecimalPoint, System.Globalization.NumberFormatInfo.InvariantInfo);
string testString1 = "2,457";
string testString2 = "2.457";
double testNum = 0.5;
char decimalSepparator;
decimalSepparator = testNum.ToString()[1];
Console.WriteLine(double.Parse(testString1.Replace('.', decimalSepparator).Replace(',', decimalSepparator)));
Console.WriteLine(double.Parse(testString2.Replace('.', decimalSepparator).Replace(',', decimalSepparator)));
我在这个主题上的两分钱，试图提供一个通用的，双重转换方法：
private static double ParseDouble(object value)
{
double result;
string doubleAsString = value.ToString();
IEnumerable<char> doubleAsCharList = doubleAsString.ToList();
if (doubleAsCharList.Where(ch => ch == '.' || ch == ',').Count() <= 1)
{
double.TryParse(doubleAsString.Replace(',', '.'),
System.Globalization.NumberStyles.Any,
CultureInfo.InvariantCulture,
out result);
}
else
{
if (doubleAsCharList.Where(ch => ch == '.').Count() <= 1
&& doubleAsCharList.Where(ch => ch == ',').Count() > 1)
{
double.TryParse(doubleAsString.Replace(",", string.Empty),
System.Globalization.NumberStyles.Any,
CultureInfo.InvariantCulture,
out result);
}
else if (doubleAsCharList.Where(ch => ch == ',').Count() <= 1
&& doubleAsCharList.Where(ch => ch == '.').Count() > 1)
{
double.TryParse(doubleAsString.Replace(".", string.Empty).Replace(',', '.'),
System.Globalization.NumberStyles.Any,
CultureInfo.InvariantCulture,
out result);
}
else
{
throw new ParsingException($"Error parsing {doubleAsString} as double, try removing thousand separators (if any)");
}
}
return result;
}
按预期工作：
1.3,14没有实现默认转换，因此尝试 parse1,3.14或类似情况将失败。
以下代码在任何情况下都可以完成这项工作。这有点解析。
List<string> inputs = new List<string>()
{
"1.234.567,89",
"1 234 567,89",
"1 234 567.89",
"1,234,567.89",
"123456789",
"1234567,89",
"1234567.89",
};
string output;
foreach (string input in inputs)
{
// Unify string (no spaces, only .)
output = input.Trim().Replace(" ", "").Replace(",", ".");
// Split it on points
string[] split = output.Split('.');
if (split.Count() > 1)
{
// Take all parts except last
output = string.Join("", split.Take(split.Count()-1).ToArray());
// Combine token parts with last part
output = string.Format("{0}.{1}", output, split.Last());
}
// Parse double invariant
double d = double.Parse(output, CultureInfo.InvariantCulture);
Console.WriteLine(d);
}
如果值来自用户输入，我认为不可能 100% 正确转换。例如，如果值为 123.456，它可以是一个分组，也可以是一个小数点。如果你真的需要 100%，你必须描述你的格式，如果不正确则抛出异常。
但是我改进了 JanW 的代码，所以我们在 100% 之前得到了一点点。背后的想法是，如果最后一个分隔符是 groupSeparator，这将是一个整数类型，而不是一个双精度类型。
添加的代码位于GetDouble的第一个if中。
void Main()
{
List<string> inputs = new List<string>() {
"1.234.567,89",
"1 234 567,89",
"1 234 567.89",
"1,234,567.89",
"1234567,89",
"1234567.89",
"123456789",
"123.456.789",
"123,456,789,"
};
foreach(string input in inputs) {
Console.WriteLine(GetDouble(input,0d));
}
}
public static double GetDouble(string value, double defaultValue) {
double result;
string output;
// Check if last seperator==groupSeperator
string groupSep = System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberGroupSeparator;
if (value.LastIndexOf(groupSep) + 4 == value.Count())
{
bool tryParse = double.TryParse(value, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.CurrentCulture, out result);
result = tryParse ? result : defaultValue;
}
else
{
// Unify string (no spaces, only . )
output = value.Trim().Replace(" ", string.Empty).Replace(",", ".");
// Split it on points
string[] split = output.Split('.');
if (split.Count() > 1)
{
// Take all parts except last
output = string.Join(string.Empty, split.Take(split.Count()-1).ToArray());
// Combine token parts with last part
output = string.Format("{0}.{1}", output, split.Last());
}
// Parse double invariant
result = double.Parse(output, System.Globalization.CultureInfo.InvariantCulture);
}
return result;
}
var doublePattern = @"(?<integer>[0-9]+)(?:\,|\.)(?<fraction>[0-9]+)";
var sourceDoubleString = "03444,44426";
var match = Regex.Match(sourceDoubleString, doublePattern);
var doubleResult = match.Success ? double.Parse(match.Groups["integer"].Value) + (match.Groups["fraction"].Value == null ? 0 : double.Parse(match.Groups["fraction"].Value) / Math.Pow(10, match.Groups["fraction"].Value.Length)): 0;
Console.WriteLine("Double of string '{0}' is {1}", sourceDoubleString, doubleResult);
不必在所有解析中指定语言环境，我更喜欢设置应用程序范围的语言环境，尽管如果字符串格式在整个应用程序中不一致，这可能不起作用。
CultureInfo.DefaultThreadCurrentCulture = new CultureInfo("pt-PT");
CultureInfo.DefaultThreadCurrentUICulture = new CultureInfo("pt-PT");
在您的应用程序开始时定义它将使所有双重解析都期望逗号作为小数分隔符。您可以设置适当的语言环境，以便十进制和千位分隔符适合您正在解析的字符串。
我也改进了@JanW 的代码......
我需要它来格式化医疗仪器的结果，它们还发送“>1000”、“23.3e02”、“350E-02”和“NEGATIVE”。
private string FormatResult(string vResult)
{
string output;
string input = vResult;
// Unify string (no spaces, only .)
output = input.Trim().Replace(" ", "").Replace(",", ".");
// Split it on points
string[] split = output.Split('.');
if (split.Count() > 1)
{
// Take all parts except last
output = string.Join("", split.Take(split.Count() - 1).ToArray());
// Combine token parts with last part
output = string.Format("{0}.{1}", output, split.Last());
}
string sfirst = output.Substring(0, 1);
try
{
if (sfirst == "<" || sfirst == ">")
{
output = output.Replace(sfirst, "");
double res = Double.Parse(output);
return String.Format("{1}{0:0.####}", res, sfirst);
}
else
{
double res = Double.Parse(output);
return String.Format("{0:0.####}", res);
}
}
catch
{
return output;
}
}
不指定要查找的小数分隔符很困难，但如果你这样做，这就是我正在使用的：
public static double Parse(string str, char decimalSep)
{
string s = GetInvariantParseString(str, decimalSep);
return double.Parse(s, System.Globalization.CultureInfo.InvariantCulture);
}
public static bool TryParse(string str, char decimalSep, out double result)
{
// NumberStyles.Float | NumberStyles.AllowThousands got from Reflector
return double.TryParse(GetInvariantParseString(str, decimalSep), NumberStyles.Float | NumberStyles.AllowThousands, System.Globalization.CultureInfo.InvariantCulture, out result);
}
private static string GetInvariantParseString(string str, char decimalSep)
{
str = str.Replace(" ", "");
if (decimalSep != '.')
str = SwapChar(str, decimalSep, '.');
return str;
}
public static string SwapChar(string value, char from, char to)
{
if (value == null)
throw new ArgumentNullException("value");
StringBuilder builder = new StringBuilder();
foreach (var item in value)
{
char c = item;
if (c == from)
c = to;
else if (c == to)
c = from;
builder.Append(c);
}
return builder.ToString();
}
private static void ParseTestErr(string p, char p_2)
{
double res;
bool b = TryParse(p, p_2, out res);
if (b)
throw new Exception();
}
private static void ParseTest(double p, string p_2, char p_3)
{
double d = Parse(p_2, p_3);
if (d != p)
throw new Exception();
}
static void Main(string[] args)
{
ParseTest(100100100.100, "100.100.100,100", ',');
ParseTest(100100100.100, "100,100,100.100", '.');
ParseTest(100100100100, "100.100.100.100", ',');
ParseTest(100100100100, "100,100,100,100", '.');
ParseTestErr("100,100,100,100", ',');
ParseTestErr("100.100.100.100", '.');
ParseTest(100100100100, "100 100 100 100.0", '.');
ParseTest(100100100.100, "100 100 100.100", '.');
ParseTest(100100100.100, "100 100 100,100", ',');
ParseTest(100100100100, "100 100 100,100", '.');
ParseTest(1234567.89, "1.234.567,89", ',');
ParseTest(1234567.89, "1 234 567,89", ',');
ParseTest(1234567.89, "1 234 567.89", '.');
ParseTest(1234567.89, "1,234,567.89", '.');
ParseTest(1234567.89, "1234567,89", ',');
ParseTest(1234567.89, "1234567.89", '.');
ParseTest(123456789, "123456789", '.');
ParseTest(123456789, "123456789", ',');
ParseTest(123456789, "123.456.789", ',');
ParseTest(1234567890, "1.234.567.890", ',');
}
这应该适用于任何文化。它无法正确解析具有多个小数分隔符的字符串，这与替换而不是交换的实现不同。
这是一个处理任何包含逗号和句点的数字字符串的解决方案。此解决方案特别适用于货币金额，因此预计只有十分之一和百分之一。任何更多都被视为一个整数。
首先删除任何不是数字、逗号、句点或负号的内容。
string stringAmount = Regex.Replace(originalString, @"[^0-9\.\-,]", "");
然后我们把数字分成整数和十进制数。
string[] decimalParsed = Regex.Split(stringAmount, @"(?:\.|,)(?=\d{2}$)");
（此 Regex 表达式选择一个逗号或句点，它是字符串末尾的两个数字。）
现在我们取整数并去掉任何逗号和句点。
string wholeAmount = decimalParsed[0].Replace(",", "").Replace(".", "");
if (wholeAmount.IsNullOrEmpty())
wholeAmount = "0";
现在我们处理小数部分，如果有的话。
string decimalAmount = "00";
if (decimalParsed.Length == 2)
{
decimalAmount = decimalParsed[1];
}
最后，我们可以将整数和小数放在一起并解析 Double。
double amount = $"{wholeAmount}.{decimalAmount}".ToDouble();
这将处理 200,00、1 000,00、1,000、1.000,33、2,000.000,78 等。
System.Globalization.CultureInfo ci = System.Globalization.CultureInfo.CurrentCulture;
string _pos = dblstr.Replace(".",
ci.NumberFormat.NumberDecimalSeparator).Replace(",",
ci.NumberFormat.NumberDecimalSeparator);
double _dbl = double.Parse(_pos);
下面的效率较低，但我使用这个逻辑。仅当小数点后有两位数时才有效。
double val;
if (temp.Text.Split('.').Length > 1)
{
val = double.Parse(temp.Text.Split('.')[0]);
if (temp.Text.Split('.')[1].Length == 1)
val += (0.1 * double.Parse(temp.Text.Split('.')[1]));
else
val += (0.01 * double.Parse(temp.Text.Split('.')[1]));
}
else
val = double.Parse(RR(temp.Text));
将数字相乘，然后除以之前乘以的数字。
例如，
perc = double.Parse("3.555)*1000;
result = perc/1000