[C#]Double转化为String时的保留位数及格式

最新推荐文章于 2024-12-16 16:15:20 发布
最新推荐文章于 2024-12-16 16:15:20 发布
阅读量4.6k 收藏 12
点赞数 2
CC 4.0 BY-SA版权
分类专栏： C#基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/FliesOfTime/article/details/90671925
博客介绍了程序中数据写入文件时，Double转化为String设置保留位数及格式的相关内容，示例源于官方资料，方便日后快速查询。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

       有时需要将程序中的数据写入到文件中进行保存，这时候就涉及到数据的字符串格式问题。下面介绍Double转化为String时如何设置保留位数及格式，示例来自官方资料，博客用于日后快速查询。

Double.ToString Method官方资料

double[] numbers= {1054.32179, -195489100.8377, 1.0437E21, 
                   -1.0573e-05};
string[] specifiers = { "C", "E", "e", "F", "G", "N", "P", 
                        "R", "#,000.000", "0.###E-000",
                        "000,000,000,000.00###" };
foreach (double number in numbers)
{
   Console.WriteLine("Formatting of {0}:", number);
   foreach (string specifier in specifiers) {
      Console.WriteLine("   {0,-22} {1}", 
                        specifier + ":", number.ToString(specifier));
      // Add precision specifiers from 0 to 3.
      if (specifier.Length == 1 & ! specifier.Equals("R")) {
         for (int precision = 0; precision <= 3; precision++) {
            string pSpecifier = String.Format("{0}{1}", specifier, precision);
            Console.WriteLine("   {0,-22} {1}", 
                              pSpecifier + ":", number.ToString(pSpecifier));
         }    
         Console.WriteLine();
      }   
   }
   Console.WriteLine();
}
// The example displays the following output to the console:
//       Formatting of 1054.32179:
//          C:                     $1,054.32
//          C0:                    $1,054
//          C1:                    $1,054.3
//          C2:                    $1,054.32
//          C3:                    $1,054.322
//       
//          E:                     1.054322E+003
//          E0:                    1E+003
//          E1:                    1.1E+003
//          E2:                    1.05E+003
//          E3:                    1.054E+003
//       
//          e:                     1.054322e+003
//          e0:                    1e+003
//          e1:                    1.1e+003
//          e2:                    1.05e+003
//          e3:                    1.054e+003
//       
//          F:                     1054.32
//          F0:                    1054
//          F1:                    1054.3
//          F2:                    1054.32
//          F3:                    1054.322
//       
//          G:                     1054.32179
//          G0:                    1054.32179
//          G1:                    1E+03
//          G2:                    1.1E+03
//          G3:                    1.05E+03
//       
//          N:                     1,054.32
//          N0:                    1,054
//          N1:                    1,054.3
//          N2:                    1,054.32
//          N3:                    1,054.322
//       
//          P:                     105,432.18 %
//          P0:                    105,432 %
//          P1:                    105,432.2 %
//          P2:                    105,432.18 %
//          P3:                    105,432.179 %
//       
//          R:                     1054.32179
//          #,000.000:             1,054.322
//          0.###E-000:            1.054E003
//          000,000,000,000.00###: 000,000,001,054.32179
//       
//       Formatting of -195489100.8377:
//          C:                     ($195,489,100.84)
//          C0:                    ($195,489,101)
//          C1:                    ($195,489,100.8)
//          C2:                    ($195,489,100.84)
//          C3:                    ($195,489,100.838)
//       
//          E:                     -1.954891E+008
//          E0:                    -2E+008
//          E1:                    -2.0E+008
//          E2:                    -1.95E+008
//          E3:                    -1.955E+008
//       
//          e:                     -1.954891e+008
//          e0:                    -2e+008
//          e1:                    -2.0e+008
//          e2:                    -1.95e+008
//          e3:                    -1.955e+008
//       
//          F:                     -195489100.84
//          F0:                    -195489101
//          F1:                    -195489100.8
//          F2:                    -195489100.84
//          F3:                    -195489100.838
//       
//          G:                     -195489100.8377
//          G0:                    -195489100.8377
//          G1:                    -2E+08
//          G2:                    -2E+08
//          G3:                    -1.95E+08
//       
//          N:                     -195,489,100.84
//          N0:                    -195,489,101
//          N1:                    -195,489,100.8
//          N2:                    -195,489,100.84
//          N3:                    -195,489,100.838
//       
//          P:                     -19,548,910,083.77 %
//          P0:                    -19,548,910,084 %
//          P1:                    -19,548,910,083.8 %
//          P2:                    -19,548,910,083.77 %
//          P3:                    -19,548,910,083.770 %
//       
//          R:                     -195489100.8377
//          #,000.000:             -195,489,100.838
//          0.###E-000:            -1.955E008
//          000,000,000,000.00###: -000,195,489,100.8377
//       
//       Formatting of 1.0437E+21:
//          C:                     $1,043,700,000,000,000,000,000.00
//          C0:                    $1,043,700,000,000,000,000,000
//          C1:                    $1,043,700,000,000,000,000,000.0
//          C2:                    $1,043,700,000,000,000,000,000.00
//          C3:                    $1,043,700,000,000,000,000,000.000
//       
//          E:                     1.043700E+021
//          E0:                    1E+021
//          E1:                    1.0E+021
//          E2:                    1.04E+021
//          E3:                    1.044E+021
//       
//          e:                     1.043700e+021
//          e0:                    1e+021
//          e1:                    1.0e+021
//          e2:                    1.04e+021
//          e3:                    1.044e+021
//       
//          F:                     1043700000000000000000.00
//          F0:                    1043700000000000000000
//          F1:                    1043700000000000000000.0
//          F2:                    1043700000000000000000.00
//          F3:                    1043700000000000000000.000
//       
//          G:                     1.0437E+21
//          G0:                    1.0437E+21
//          G1:                    1E+21
//          G2:                    1E+21
//          G3:                    1.04E+21
//       
//          N:                     1,043,700,000,000,000,000,000.00
//          N0:                    1,043,700,000,000,000,000,000
//          N1:                    1,043,700,000,000,000,000,000.0
//          N2:                    1,043,700,000,000,000,000,000.00
//          N3:                    1,043,700,000,000,000,000,000.000
//       
//          P:                     104,370,000,000,000,000,000,000.00 %
//          P0:                    104,370,000,000,000,000,000,000 %
//          P1:                    104,370,000,000,000,000,000,000.0 %
//          P2:                    104,370,000,000,000,000,000,000.00 %
//          P3:                    104,370,000,000,000,000,000,000.000 %
//       
//          R:                     1.0437E+21
//          #,000.000:             1,043,700,000,000,000,000,000.000
//          0.###E-000:            1.044E021
//          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//       
//       Formatting of -1.0573E-05:
//          C:                     $0.00
//          C0:                    $0
//          C1:                    $0.0
//          C2:                    $0.00
//          C3:                    $0.000
//       
//          E:                     -1.057300E-005
//          E0:                    -1E-005
//          E1:                    -1.1E-005
//          E2:                    -1.06E-005
//          E3:                    -1.057E-005
//       
//          e:                     -1.057300e-005
//          e0:                    -1e-005
//          e1:                    -1.1e-005
//          e2:                    -1.06e-005
//          e3:                    -1.057e-005
//       
//          F:                     0.00
//          F0:                    0
//          F1:                    0.0
//          F2:                    0.00
//          F3:                    0.000
//       
//          G:                     -1.0573E-05
//          G0:                    -1.0573E-05
//          G1:                    -1E-05
//          G2:                    -1.1E-05
//          G3:                    -1.06E-05
//       
//          N:                     0.00
//          N0:                    0
//          N1:                    0.0
//          N2:                    0.00
//          N3:                    0.000
//       
//          P:                     0.00 %
//          P0:                    0 %
//          P1:                    0.0 %
//          P2:                    0.00 %
//          P3:                    -0.001 %
//       
//          R:                     -1.0573E-05
//          #,000.000:             000.000
//          0.###E-000:            -1.057E-005
//          000,000,000,000.00###: -000,000,000,000.00001
重新实现.NET Core的 double.ToString()
mjyfadeaway的专栏
09-26 782
目前C#中double.ToString()的问题.NET Core 2.0发布后，整个框架的性能提升了不少。但是仍然有一些基础数据类型的性能不尽入人意，例如double.ToString(). 本文讲解如何一步一步重新实现double.ToString().
【Bug】C# decimal转换成string并保留两位小数失效
在这里你大概率会有所收获，欢迎指错||纠正||建议||水评+点赞&&评论&&关注&&转发
06-18 808
摘要：本文记录了一个decimal转string保留两位小数时出现异常的bug排查过程。通过分析发现，问题源于自定义的ToDecimal扩展方法返回可空类型导致。解决方案是改用Convert.ToDecimal确保获取非可空decimal类型。作者详细描述了从重现问题到修复的完整步骤（1-7），并附上了技术实现的代码对比。文章后半部分转为感性自述，表达了写作过程中的孤独与坚持，以及对读者认可的珍视。"茫茫文海无人意，天下有君识吾心"道出了技术写作者的心声。
double转为string
MDtime的博客
10-22 1136
【代码】double转为string。
14.调用函数、double类型转String C#
S13461120713的博客
12-16 486
将一个double类型的数转化为不保留小数的字符串。在同一个项目的两个不同文件中定义和调用函数，
C#double、string、int之间的相互转换
昱垚的博客
04-28 8520
一、double和string之间 1、double转string double a=1.2522; string s=Convert.ToString(a); 2、string转double String a= "5555"; // 示例 1 Double b = Double.Parse(a); // 示例 2 b = Convert.ToDouble(a); 二、int和string之间 1、int转string int a = 15; //示例1 string s1 .
C#double类型转换string类型
aabbaa2000的博客
04-03 5597
double a=1.2522; string s=Convert.ToString(a); //Convert 转变 转载于:https://www.cnblogs.com/liyu925/p/4389433.html
C# Double保留小数点后面位数
04-04
本文将围绕“C# Double保留小数点后面位数”这一主题展开详细讨论，包括如何利用`Double`类型的数据以及如何通过字符串格式化来实现这一功能。 ### C#中的Double类型 在C#中，`Double`是一种基本数据类型，用于...
C# 小数位数保留的方法集锦
10-30
在C#编程中，处理小数位数的保留是一个常见的任务，特别是在财务计算、数据分析以及显示用户友好的数值时。以下是一些C#中保留小数位数的常用方法： 1. 使用`System.Globalization.NumberFormatInfo`类： 这个类...
C# String 的各种转换
12-15
### C# String 的各种转换 在C#编程语言中，字符串与数字之间的转换是非常常见的操作。本文将详细介绍如何在C#中实现字符串与其他数据类型（如整数、浮点数等）之间的转换，并特别关注字符串与十六进制之间的转换。...
C# Double String互转
weixin_30376323的博客
05-20 368
/// <summary> /// str转金额 元 /// </summary> /// <param name="money"></param> /// <param name="type">分100 毛10</param> /// <return...
C# Double 按有效数字 ToString
JXISH001的博客
02-08 1644
将double转换为n有效数字的字符 我找了各种帖子包括在微软文档搜索 ‘significant digits’；最接近的是ToString(“Gx”) 但是返回是不大于这个x有效位的字符串， 举例 double a=1.2; string s=a.ToString(&quot;G3&quot;); 得到1.2而不是1.20 所以就写了一个函数 string DoubleToStringSignifi...
【C#】double.ToString() 的用法
风语留痕
09-17 4718
C# 中 double 类型的数据，有时需要格式化显示为字符串（保留N位有效数字或者是保留N位小数），可以使用 double.ToString("参数") 方法。
C#中将integer, long, double 数据类型转换为string类型
夜晚回家
03-31 1822
原文地址：http://www.dingos.cn/index.php?topic=1995.0下 面简单的示例演示将数字类型转换为string类型的不同方式。在.NET中有几种将数字类型转换为字符串。如下示例显示。string salary;// 示例 1salary = 10000.ToString();// 示例 2int sal =
C#中将double变量格式化为字符串，且保留小数点后面的全部位数
Java技术博文
02-27 3100
【问题】 C#中已经获得一个double变量值，比如1343392590725.6758，然后想要将其转换为字符串，且保留全部的小数点后的4位，但是结果却是： private void doubleToStringTest() { double curMilliSecDouble = 1343392590725.6758; //double curMilliSecDouble
C#double转化成字符串 保留小数位数
weixin_34009794的博客
08-22 517
在C#中大家都会遇到这种情况 double类型的数据，需要格式化（保留N未有效数字）或者是保留N为小数等情况，我们往往采取double.tostring("参数");的方法。下面就列出几个常用的方法。 double temp=3.1415926; (F)Fixed point:string str1=temp.toString("f1");//保留一位小数 四舍五入 结果：3.1 (F)Fi...
double转为string（整数取整、小数保留四位）
weixin_39083683的博客
06-18 2339
/** * @Description:double转为string（整数取整、小数保留四位） * @Author: TXY * @Date: 2020/6/18 10:17 * @param number: * @return: java.lang.String **/ public static String doubleFormatInteger(double number) { String numberStr; if (((int) number * 1000) == .
double转string保留小数且不保留0
james_14的博客
01-30 436
返回字符串数字类型,有小数返回带小数的,没有小数则返回不带小数的值。// 返回true时说明小数点后都是0。
c# double转string保留两位小数
热门推荐
qq_31617121的博客
12-30 1万+
double tmp = 3.11415; string s = tmp.toString(“f2”); 这样就是保留两位小数
C# Double toString保留小数点方法
weixin_30865427的博客
02-26 697
有时候double型数据需要toString(),但又想保留小数,当值为整数,比如3.00时tostring后会变为”3″,具体说明见下: 1 stringstr0 = i.ToString("f");//25.00 2 stringstr1 = i.ToString("f1");//25.0 ...
C#中double转换成string
最新发布
03-23
<think>嗯，用户想知道在C#中如何将double类型转换为string类型。首先，我得回忆一下C#中的类型转换方法。记得有Convert.ToString()方法，这应该可以直接用。比如Convert.ToString(doubleValue)，对吧？然后还有ToString()方法，因为double是结构体，应该有自己的ToString()方法，可以直接调用，比如num.ToString()。 不过用户可能还需要格式控制，比如保留几位小数或者科学计数法。这时候需要用ToString()的参数，比如格式字符串。例如，"F2"表示保留两位小数，"E"表示科学计数法。可能还需要考虑文化区域的问题，比如不同的地区小数点符号可能不同，用InvariantCulture可以保持一致性。 然后，用户提供的引用中有提到Convert.ToString的例子，比如引用[2]里的double a=1.2522; string s=Convert.ToString(a); 这说明Convert.ToString确实是一个方法。另外在引用[3]里有个Functions.DoubleToString方法，但可能用户自己封装了一个函数，不过标准库的方法应该足够用了。 另外，用户可能在做界面开发，比如引用[4]里提到的小工具，所以转换后的字符串可能用于文本框显示，这时候格式控制就很重要，比如显示红色或蓝色，但转换本身只是字符串处理。 需要注意的还有，如果double的值很大或很小，可能需要用科学记数法，或者处理舍入误差。比如123456.789用"0.00"格式会变成123456.79。此外，使用string.Format或者插值字符串也是可行的，比如$"{num:F2}"。 总结一下，应该分几种方法介绍：Convert.ToString、ToString()无参数、带格式参数，以及文化区域设置。同时给出示例代码，并说明适用场景，比如是否需要格式化，是否需要考虑区域设置等。最后可能还要提醒常见的错误，比如空值或者格式字符串错误，但用户的问题可能基础，暂时不需要深入错误处理。</think>### C# double 转 string 的常用方法 在C#中，将double类型转换为string类型有以下几种常用方式，具体选择取决于是否需要格式化控制或区域性设置： --- #### 1. **`Convert.ToString()` 方法** 直接调用系统提供的类型转换方法，适用于简单转换： ```csharp double num = 3.14159; string str = Convert.ToString(num); // 输出: "3.14159" ``` 此方法默认保留所有小数位，不进行四舍五入[^2]。 --- #### 2. **`ToString()` 方法** 所有数值类型都支持的实例方法，可添加格式化参数： ```csharp double num = 123.456; // 无参数形式（保留所有小数位） string str1 = num.ToString(); // 输出: "123.456" // 格式控制参数 string str2 = num.ToString("F2"); // 输出: "123.46"（保留两位小数） string str3 = num.ToString("E"); // 输出: "1.234560E+002"（科学计数法） ``` 常用格式符： - `"F"`：固定小数位数（如`"F3"`保留3位） - `"N"`：千位分隔符（如`"N0"`表示无小数且带逗号分隔） - `"0.00"`：自定义格式（如`123.456.ToString("0.00")`输出`"123.46"`） --- #### 3. **字符串插值或 `string.Format`** 通过格式化字符串灵活控制输出： ```csharp double num = 99.995; string str1 = $"{num:F2}"; // 输出: "100.00"（自动四舍五入） string str2 = string.Format("{0:0.###}", num); // 输出: "99.995" ``` --- #### 4. **区域性设置（CultureInfo）** 解决不同语言环境下的格式差异： ```csharp double num = 1234.56; string str1 = num.ToString("N2", CultureInfo.InvariantCulture); // 输出: "1,234.56" string str2 = num.ToString("N2", new CultureInfo("de-DE")); // 输出: "1.234,56" ``` 使用`CultureInfo.InvariantCulture`可避免小数点/千位符的本地化差异[^4]。 --- ### 示例代码 ```csharp using System; using System.Globalization; class Program { static void Main() { double num = 3456.123; // 方法1: Convert.ToString Console.WriteLine(Convert.ToString(num)); // "3456.123" // 方法2: ToString格式控制 Console.WriteLine(num.ToString("0.0")); // "3456.1" // 方法3: 字符串插值 Console.WriteLine($"{num:N0}"); // "3,456" // 方法4: 区域性设置 Console.WriteLine(num.ToString("F2", CultureInfo.InvariantCulture)); // "3456.12" } } ``` --- ### 注意事项 1. **四舍五入规则**：格式化时会自动处理，如`99.995.ToString("F2")`结果为`100.00`。 2. **性能优化**：频繁转换时优先使用`ToString()`而非`Convert.ToString()`。 3. **异常处理**：若值为`double.NaN`或`double.Infinity`，转换结果会直接输出字符串形式（如`"NaN"`）。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值