C# 标准数字格式字符串

总目录

前言

当前文章为 C# 中的格式设置(格式化字符串) 大全 中的一个小章节。

一、概述

1. 基本信息

• 标准数字格式字符串用于格式化通用数值类型。
• 标准数字格式字符串采用 [format specifier][precision specifier] 的形式
  • format specifier 格式说明符，负责指定数字格式类型，通常是单个字母字符，如G、C、F等
  • precision specifier 精度说明符，负责控制数字的字符串表示形式中的数字个数。是一个可选整数，它影响生成的字符串中的位数
    • 在 .NET 7 及更高版本中，最大精度值为 999,999,999。
    • 在 .NET 6 中，最大精度值为 Int32.MaxValue。
    • 在旧版 .NET 中，精度范围可以为 0 到 99。
  • 当精度说明符控制结果字符串中的小数位数时，在格式化时会进行四舍五入运算后返回结果
    • 标准数字格式字符串 在做精度控制的时候，基本都会在格式化时进行四舍五入

        static void Main(string[] args)
        {
            double amount = 1234.5678;
            Console.WriteLine(amount.ToString("C"));   // 输出: ￥1,234.57
            Console.WriteLine(amount.ToString("C3"));  // 输出: ￥1,234.568
        }

如上面的案例中的C3：

• C 是 格式说明符，指定的数据格式类型为 货币
• 3 是 精度说明符，负责控制结果字符串的小数位，指定为3位
• 3 控制了结果字符串的小数位，使用 C3 在格式化时会进行四舍五入运算 ，因此1234.5678（C3） =>￥1,234.568

2. 标准格式说明符 图例

下表描述标准的数字格式说明符并显示由每个格式说明符产生的示例输出。

特定区域性的格式化字符串的结果可能与以下示例不同。操作系统设置、用户设置、环境变量和所用的 .NET 版本都会影响格式。 例如，从 .NET 5 开始，.NET 尝试跨平台统一区域性格式。 有关详细信息，请参阅 .NET 全球化和 ICU。

二、标准数字格式说明符详解

1. B/b 二进制格式说明符

• 二进制格式说明符 (B) 将数字转换为二进制数字字符串。 只有整型且仅在 .NET 8+ 上才支持此格式。

• 结果字符串不受当前 NumberFormatInfo 对象的格式信息的影响。

        static void Main(string[] args)
        {
            int value = 42;
            Console.WriteLine(value.ToString("B"));     //输出：101010
            Console.WriteLine(value.ToString("B0"));    //输出：101010
            Console.WriteLine(value.ToString("B1"));    //输出：101010
            Console.WriteLine(value.ToString("B3"));    //输出：101010
            Console.WriteLine(value.ToString("B5"));    //输出：101010
            Console.WriteLine(value.ToString("B8"));    //输出：00101010

            int value2 = 255;
            Console.WriteLine(value2.ToString("B"));    //输出：11111111
            Console.WriteLine(value2.ToString("B0"));   //输出：11111111
            Console.WriteLine(value2.ToString("B1"));   //输出：11111111
            Console.WriteLine(value2.ToString("B10"));  //输出：0011111111
            Console.WriteLine(value2.ToString("B16"));  //输出：0000000011111111
            Console.WriteLine(value2.ToString("B20"));  //输出：00000000000011111111

        }

• 精度说明符指示结果字符串中所需的最少数字个数。 如果需要的话，则用零填充该数字的左侧，以产生精度说明符给定的数字个数。

2. C/c 货币格式说明符

• “C”（或货币）格式说明符将数字转换为表示货币金额的字符串。
• 精度说明符指示结果字符串中的所需小数位数。
• 如果省略精度说明符，则默认精度由 NumberFormatInfo.CurrencyDecimalDigits 属性定义，默认为 2。

        static void Main(string[] args)
        {
            double amount = 1234.5678;
            Console.WriteLine(amount.ToString("C"));   // 输出: ￥1,234.57
            Console.WriteLine(amount.ToString("C0"));  // 输出: ￥1,235
            Console.WriteLine(amount.ToString("C1"));  // 输出: ￥1,234.6
            Console.WriteLine(amount.ToString("C2"));  // 输出: ￥1,234.57
            Console.WriteLine(amount.ToString("C3"));  // 输出: ￥1,234.568
            Console.WriteLine(amount.ToString("C4"));  // 输出: ￥1,234.5678
            Console.WriteLine(amount.ToString("C5"));  // 输出: ￥1,234.56780
        }

• 如果要设置格式的值的小数位数多于指定或默认数量，将在结果字符串中补0。
  • 如 C5 指定小数位数为5 ，多于1234.5678 中的四位，那么格式化的时候会在结果中补0，结果为￥1,234.56780
• 如果要设置格式的值的小数位数少于指定或默认数量，将在进行四舍五入后返回结果字符串。
  • 如 C2 指定小数位数为2 ，少于1234.5678 中的四位，那么格式化的时候会自动进行四舍五入，返回结果字符串￥1234.57。

        static void Main(string[] args)
        {
            double value = 12345.6789;
            Console.WriteLine(value.ToString("C3"));                                            //输出：￥12,345.679
            Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));                //输出：￥12,345.679

            Console.WriteLine(value.ToString("C3", new CultureInfo("en-US")));                  //输出：$12,345.679
            Console.WriteLine(value.ToString("C3", CultureInfo.CreateSpecificCulture("da-DK")));//输出：12.345,679 kr.
        }

• 使用格式提供程序来实现特定区域性的格式设置约定。
• 当不设置区域信息的时候，默认使用当前计算机的区域信息
• 当需要指定特定的区域性的格式设置的时候，可以通过 CultureInfo 去指定
  • 如上面的案例中，使用了三种不同的方式去指定 区域
• 结果字符串受当前 NumberFormatInfo 对象的格式信息的影响。 下表列出了 NumberFormatInfo 属性，这些属性控制返回字符串的格式。
  

3. D/d 十进制格式说明符

• “D”（或十进制）格式说明符将数字转换为十进制数字 (0-9) 的字符串，如果数字为负，则前面加负号。
• 只有整型才支持此格式。
• 精度说明符指示结果字符串中所需的最少数字个数。

        static void Main(string[] args)
        {
            int number = 1234;
            Console.WriteLine(number.ToString("D"));   // 输出: 1234
            Console.WriteLine(number.ToString("D1"));  // 输出: 1234
            Console.WriteLine(number.ToString("D3"));  // 输出: 1234
            Console.WriteLine(number.ToString("D4"));  // 输出: 1234
            Console.WriteLine(number.ToString("D5"));  // 输出: 01234
            Console.WriteLine(number.ToString("D7"));  // 输出: 0001234
            Console.WriteLine(number.ToString("D8"));  // 输出: 00001234
        }

• 如果未指定精度说明符，则默认值为表示不带前导零的整数所需的最小值。

  • 如 1234(D) -> 1234

• 如果精度说明符给定的数字个数 大于 数字本身的数字位数，则用零填充该数字的左侧满足精度说明符给定的数字个数。

  • 如 1234(D8) -> 00001234

• 如果精度说明符给定的数字个数 小于 数字本身的数字位数，则保留数字本身的数值。

  • 如 1234(D2) -> 1234 、1234(D3) -> 1234

• 结果字符串受当前 NumberFormatInfo 对象的格式信息的影响。 如下表所示，一个属性会影响结果字符串的格式。
  

4. E/e 指数格式说明符

• 指数（“E”）格式说明符将数字转换为“-d.ddd…E+ddd”或“-d.ddd…e+ddd”形式的字符串，其中每个“d”表示一个数字 (0-9)。 如果该数字为负，则该字符串以减号开头。 小数点前总是恰好有一个数字。
• 精度说明符指示小数点后所需的位数。

        static void Main(string[] args)
        {
            double amount = 1234.5678;
            Console.WriteLine(amount.ToString("E"));   // 输出: 1.234568E+003
            Console.WriteLine(amount.ToString("E0"));  // 输出: 1E+003
            Console.WriteLine(amount.ToString("E1"));  // 输出: 1.2E+003
            Console.WriteLine(amount.ToString("E2"));  // 输出: 1.23E+003
            Console.WriteLine(amount.ToString("E3"));  // 输出: 1.235E+003
            Console.WriteLine(amount.ToString("E4"));  // 输出: 1.2346E+003
            Console.WriteLine(amount.ToString("E5"));  // 输出: 1.23457E+003
        }

• 如果省略精度说明符，则使用默认值，即小数点后六位数字。
  • 如 1234.5678(E) -> 1.234568E+003

        static void Main(string[] args)
        {
            double value = 12345.6789;
            Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));               // 输出: 1.234568E+004
            Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));             // 输出: 1.2345678900E+004
            Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));              // 输出: 1.2346e+004
            Console.WriteLine(value.ToString("E",CultureInfo.CreateSpecificCulture("fr-FR")));  // 输出: 1,234568E+004 
        }

• 格式说明符的大小写指示为指数加前缀“E”还是“e”。
  • 如12345.6789(E) -> 1.234568E+004 、 12345.6789(e4) -> 1.2346e+004
• 指数总是由正号或负号以及最少三位数字组成。 如果需要，用零填充指数以满足最少三位数字的要求。
• 结果字符串受当前 NumberFormatInfo 对象的格式信息的影响。 下表列出了 NumberFormatInfo 属性，这些属性控制返回字符串的格式。
  

5. F/f 定点格式说明符

• 定点（“F”）格式说明符将数字转换为“-ddd.ddd…”形式的字符串，其中每个“d”表示一个数字 (0-9)。 如果该数字为负，则该字符串以减号开头。
• 精度说明符指示所需的小数位数。

        static void Main(string[] args)
        {
            double amount = 1234.5678;
            Console.WriteLine(amount.ToString("数值F"));    // 输出: 数值F
            Console.WriteLine(amount.ToString("F。"));      // 输出: F。
            Console.WriteLine(amount.ToString("F"));        // 输出: 1234.57
            Console.WriteLine(amount.ToString("F0"));       // 输出: 1235
            Console.WriteLine(amount.ToString("F1"));       // 输出: 1234.6
            Console.WriteLine(amount.ToString("F2"));       // 输出: 1234.57
            Console.WriteLine(amount.ToString("F3"));       // 输出: 1234.568
            Console.WriteLine(amount.ToString("F4"));       // 输出: 1234.5678
            Console.WriteLine(amount.ToString("F5"));       // 输出: 1234.56780

            double amount2 = 12.30;
            Console.WriteLine(amount2.ToString("F"));        // 输出: 12.30
            Console.WriteLine(amount2.ToString("F3"));       // 输出: 12.300
            Console.WriteLine(amount2.ToString("F4"));       // 输出: 12.3000         
        }

• 如果省略精度说明符，则当前NumberFormatInfo.NumberDecimalDigits 属性提供数值精度，默认值 2。

  • 如1234.5678(F) -> 1234.57

• 如果要设置格式的值的小数位数多于指定或默认数量，将在结果字符串中补0。

  • 如 F5 指定小数位数为5 ，多于1234.5678 中的四位，那么格式化的时候会在结果中补0，结果为1234.56780

• 如果要设置格式的值的小数位数少于指定或默认数量，将在进行四舍五入后返回结果字符串。

  • 如 F3 指定小数位数为3 ，少于1234.5678 中的四位，那么格式化的时候会自动进行四舍五入，返回结果字符串1234.568。

• 结果字符串受当前 NumberFormatInfo 对象的格式信息的影响。 下表列出了 NumberFormatInfo 对象的属性，这些属性控制结果字符串的格式。
  

6. G/g 常规格式说明符

• 根据数字类型以及是否存在精度说明符，常规（“G”）格式说明符将数字转换为更紧凑的定点表示法或科学记数法。
• 精度说明符定义可以出现在结果字符串中的最大有效位数。

        static void Main(string[] args)
        {
            double amount = 1234.5678;
            Console.WriteLine(amount.ToString("数值G"));    // 输出: 数值G
            Console.WriteLine(amount.ToString("G。"));      // 输出: G。
            Console.WriteLine(amount.ToString("G"));        // 输出: 1234.5678
            Console.WriteLine(amount.ToString("G0"));       // 输出: 1234.5678
            Console.WriteLine(amount.ToString("G1"));       // 输出: 1E+03
            Console.WriteLine(amount.ToString("G2"));       // 输出: 1.2E+03
            Console.WriteLine(amount.ToString("G3"));       // 输出: 1.23E+03
            Console.WriteLine(amount.ToString("G4"));       // 输出: 1235
            Console.WriteLine(amount.ToString("G5"));       // 输出: 1234.6

            double amount2 = 12.30;
            Console.WriteLine(amount2.ToString("G"));        // 输出: 12.3
            Console.WriteLine(amount2.ToString("G1"));       // 输出: 1E+01
            Console.WriteLine(amount2.ToString("G2"));       // 输出: 12
            Console.WriteLine(amount2.ToString("G3"));       // 输出: 12.3
            Console.WriteLine(amount2.ToString("G4"));       // 输出: 12.3    
        }

• 如果精度说明符被省略或为零，则数字的类型决定默认精度，如下表所示。
  
• 如果用科学记数法表示数字时指数大于 -5 而且小于精度说明符，则使用定点表示法；否则使用科学记数法。 结果包含小数点（如果需要），并且忽略小数点后面的尾部零。 如果精度说明符存在，并且结果的有效位数超过指定精度，则通过舍入移除多余的尾部数字。
  
• 结果字符串受当前 NumberFormatInfo 对象的格式信息的影响。 下表列出了 NumberFormatInfo 属性，这些属性控制结果字符串的格式。
  

7. N/n 数字格式说明符

• 数字（“N”）格式说明符将数字转换为"-d,ddd,ddd.ddd…“形式的字符串，其中”-"表示负数符号（如果需要），“d"表示数字 (0-9)，”,“表示组分隔符，”."表示小数点符号。
• 精度说明符指示小数点后所需的位数。

        static void Main(string[] args)
        {
            double amount = 1234.5678;
            Console.WriteLine(amount.ToString("数值N"));    // 输出: 数值N
            Console.WriteLine(amount.ToString("N。"));      // 输出: N。
            Console.WriteLine(amount.ToString("N"));        // 输出: 1,234.57
            Console.WriteLine(amount.ToString("N0"));       // 输出: 1,235
            Console.WriteLine(amount.ToString("N1"));       // 输出: 1,234.6
            Console.WriteLine(amount.ToString("N2"));       // 输出: 1,234.57
            Console.WriteLine(amount.ToString("N3"));       // 输出: 1,234.568
            Console.WriteLine(amount.ToString("N4"));       // 输出: 1,234.5678
            Console.WriteLine(amount.ToString("N5"));       // 输出: 1,234.56780

            double amount2 = 12.30;
            Console.WriteLine(amount2.ToString("N"));        // 输出: 12.30
            Console.WriteLine(amount2.ToString("N1"));       // 输出: 12.3
            Console.WriteLine(amount2.ToString("N2"));       // 输出: 12.30
            Console.WriteLine(amount2.ToString("N3"));       // 输出: 12.300
            Console.WriteLine(amount2.ToString("N4"));       // 输出: 12.3000
        }

• 如果省略精度限定符，则小数位数由当前的 NumberFormatInfo.NumberDecimalDigits 属性来定义，默认值2。
  • 如1234.5678(N) -> 1234.57
• N 符号 是进阶版 F 符号，N 符号基于F符号的基础上多了一个组分隔符","
  • 如 1234.5678(N5) ->1,234.56780
  • 如 1234.5678(F5) ->1234.56780
• 结果字符串受当前 NumberFormatInfo 对象的格式信息的影响。 下表列出了 NumberFormatInfo 属性，这些属性控制结果字符串的格式。
  

8. P/p 百分比格式说明符

• 百分比（“P”）格式说明符将数字乘以 100 并将其转换为表示百分比的字符串。
• 精度说明符指示所需的小数位数。

        static void Main(string[] args)
        {
            double amount = 1234.5678;
            Console.WriteLine(amount.ToString("数值P"));    // 输出: 数值P
            Console.WriteLine(amount.ToString("P。"));      // 输出: P。
            Console.WriteLine(amount.ToString("P"));        // 输出: 123,456.78%
            Console.WriteLine(amount.ToString("P0"));       // 输出: 123,457%
            Console.WriteLine(amount.ToString("P1"));       // 输出: 123,456.8%
            Console.WriteLine(amount.ToString("P2"));       // 输出: 123,456.78%
            Console.WriteLine(amount.ToString("P3"));       // 输出: 123,456.780%
            Console.WriteLine(amount.ToString("P4"));       // 输出: 123,456.7800%
            Console.WriteLine(amount.ToString("P5"));       // 输出: 123,456.78000%

            double amount2 = 12.30;
            Console.WriteLine(amount2.ToString("P"));        // 输出: 1,230.00%
            Console.WriteLine(amount2.ToString("P1"));       // 输出: 1,230.0%
            Console.WriteLine(amount2.ToString("P2"));       // 输出: 1,230.00%
            Console.WriteLine(amount2.ToString("P3"));       // 输出: 1,230.000%
            Console.WriteLine(amount2.ToString("P4"));       // 输出: 1,230.0000%
        }

• 如果省略精度说明符，则使用当前 PercentDecimalDigits 属性提供的默认数值精度，默认值 2。
  • 如1234.5678(P) -> 123,456.78%

        static void Main(string[] args)
        {
            double number = .2468013; // 相当于0.2468013
            Console.WriteLine(number.ToString("P4", CultureInfo.InvariantCulture));               // Displays 24.6801 %
            Console.WriteLine(number.ToString("P4", CultureInfo.CreateSpecificCulture("zh-CN"))); // Displays 24.6801%
            Console.WriteLine(number.ToString("P4", CultureInfo.CreateSpecificCulture("en-US"))); // Displays 24.6801%
        }

• 使用CultureInfo.InvariantCulture 和 中英区域的区别
  • 0.2468013（P4）-> 24.6801 % (InvariantCulture) 多个空格
  • 0.2468013（P4）-> 24.6801% (zh-CN)
  • 0.2468013（P4）-> 24.6801% (en-US)

9. R/r 往返格式说明符

• 往返 (“R”) 格式说明符试图确保将转换为字符串的数值分析回相同的数值。
• 只有 Half、Single、Double 和 BigInteger 类型支持此格式。
• 在低于 3.0 的 .NET Framework 和 .NET Core 版本中，
  • 在某些情况下，“R”格式说明符无法成功往返传送 Double 值。
    • 对于 Double 值和 Single 值，“R”格式说明符提供相对较差的性能。
    • 建议改用 “G17” 格式说明符以成功往返 Double 值，
    • 并改用 “G9” 格式说明符以成功往返 Single 值。
• 如果使用此说明符设置 BigInteger 值的格式，其字符串表示形式将包含 BigInteger 值中的所有有效位。

该符号使用较少，有兴趣的可查阅：往返格式说明符 ®

10. X/x 的使用

• 十六进制（“X”）格式说明符将数字转换为十六进制数的字符串。
• 格式说明符的大小写指示对大于 9 的十六进制数使用大写字符还是小写字符。
  • 例如，使用“X”产生“ABCDEF”，使用“x”产生“abcdef”。
• 只有整型才支持此格式。
• 精度说明符指示结果字符串中所需的最少数字个数。

        static void Main(string[] arXs)
        {
            int amount = 15;
            int amount2 = 1115;
            Console.WriteLine(amount.ToString("数值X"));        // 输出: 数值X
            Console.WriteLine(amount.ToString("X。"));          // 输出: X。
            Console.WriteLine(amount.ToString("X"));            // 输出: F
            Console.WriteLine(amount.ToString("X1"));           // 输出: F
            Console.WriteLine(amount.ToString("X2"));           // 输出: 0F
            Console.WriteLine(amount.ToString("X3"));           // 输出: 00F
            Console.WriteLine(amount.ToString("X4"));           // 输出: 000F
                                                                
            Console.WriteLine(amount2.ToString("X"));           // 输出: 45B
            Console.WriteLine(amount2.ToString("X2"));          // 输出: 45B
            Console.WriteLine(amount2.ToString("X3"));          // 输出: 45B
            Console.WriteLine(amount2.ToString("X4"));          // 输出: 045B
        }

• 如果精度说明符给定的数字个数 大于 数字本身的数值，则用零填充该数字的左侧满足精度说明符给定的数字个数。
  • 如 15(X4) -> 000F
• 如果精度说明符给定的数字个数 小于 数字本身的数值，则保留数字本身的16进制数值。
  • 如 1115(X2) -> 45B 、1115(X3) -> 45B
• 结果字符串不受当前 NumberFormatInfo 对象的格式信息的影响。

三、相关信息

本章节主要介绍 使用 标准数字格式字符串 时会涉及到的相关知识

1. 区域设置

1）控制面板设置

控制面板中 “区域和语言选项” 项中的设置会影响由格式化操作产生的结果字符串。

2）使用 CultureInfo

通过 CultureInfo 去指定特定的区域性的格式设置，如下所示：

        static void Main(string[] args)
        {
            double value = 12345.6789;
            Console.WriteLine(value.ToString("C3"));                                            //输出：￥12,345.679
            Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));                //输出：￥12,345.679

            Console.WriteLine(value.ToString("C3", new CultureInfo("en-US")));                  //输出：$12,345.679
            Console.WriteLine(value.ToString("C3", CultureInfo.CreateSpecificCulture("da-DK")));//输出：12.345,679 kr.
        }

注：Windows 系统上可用的区域性的预定义区域性标识符在 Windows 支持的语言/区域名称列表中的“语言标记”列中列出。 列名遵循 BCP 47 定义的标准。

2. 整型和浮点型数值类型

对标准数字格式说明符的一些说明涉及到整型或浮点型数值类型。

• 整型数值类型包括 Byte、SByte、Int16、Int32、Int64、UInt16、UInt32、UInt64 和 BigInteger。
• 浮点型数值类型有 Decimal、Half、Single 和 Double。

3. 浮点型无穷大和 NaN

无论格式字符串原来是什么值，只要 Half、Single 或 Double 浮点类型的值为正无穷大、负无穷大或非数值 (NaN)，格式字符串就分别是当前适用的 NumberFormatInfo 对象指定的 PositiveInfinitySymbol、NegativeInfinitySymbol 或 NaNSymbol 属性的值。

2. NumberFormatInfo

格式设置受当前 NumberFormatInfo 对象的属性影响，它由当前区域性隐式提供或由调用格式设置的方法的 IFormatProvider 参数显式提供。 为该参数指定 NumberFormatInfo 或 CultureInfo 对象。

1）NumberFormatInfo 介绍

提供用于对数字值进行格式设置和分析的区域性特定信息。

public sealed class NumberFormatInfo : ICloneable, IFormatProvider

详见：NumberFormatInfo 类，NumberFormatInfo 中属性基本覆盖了我们想要对数字格式进行设置的绝大部分操作，可以辅助我们得到满意的格式设置的数字格式的字符串。

2) 常见属性的使用

• CurrencyDecimalDigits
  • 获取或设置在货币值中使用的小数位数。

        static void Main(string[] args)
        {
            // 获取与en-US区域性关联的NumberFormatInfo。
            NumberFormatInfo nfi = new CultureInfo("en-US", false).NumberFormat;

            // 显示默认小数位数（2）的负值。
            Int64 myInt = -1234;
            Console.WriteLine(myInt.ToString("C", nfi)); //-$1,234.00
           
			// 设置在货币值中使用的小数位数。
            // 用四位小数显示相同的值。
            nfi.CurrencyDecimalDigits = 4;
            Console.WriteLine(myInt.ToString("C", nfi)); // -$1,234.0000
        }

• CurrencyDecimalSeparator
  • 获取或设置要在货币值中用作小数分隔符的字符串。

        static void Main(string[] args)
        {
            // 获取与en-US区域性关联的NumberFormatInfo。
            NumberFormatInfo nfi = new CultureInfo("en-US", false).NumberFormat;

            // 显示带有默认分隔符（“.”）的值。
            Int64 myInt = 123456789;
            Console.WriteLine(myInt.ToString("C", nfi));    //$123,456,789.00


            // 以空格显示与分隔符相同的值。
            nfi.CurrencyDecimalSeparator = " ";
            Console.WriteLine(myInt.ToString("C", nfi));    //$123,456,789 00
        }

• CurrencyGroupSeparator
  • 获取或设置在货币值中隔开小数点左边的位数组的字符串。
  • 在货币值中隔开小数点左边的位数组的字符串。 InvariantInfo 默认为“,”。

        static void Main(string[] args)
        {
            // 获取与en-US区域性关联的NumberFormatInfo。
            NumberFormatInfo nfi = new CultureInfo("en-US", false).NumberFormat;

            // 显示带有默认分隔符（“，”）的值
            Int64 myInt = 123456789;
            Console.WriteLine(myInt.ToString("C", nfi));    //$123,456,789.00

            // 以空格显示与分隔符相同的值。
            nfi.CurrencyGroupSeparator = " ";
            Console.WriteLine(myInt.ToString("C", nfi));    //$123 456 789.00
        }

• CurrencyPositivePattern
  获取或设置正货币值的格式模式。

        static void Main(string[] args)
        {
            // 获取与en-US区域性关联的NumberFormatInfo。
            NumberFormatInfo nfi = new CultureInfo("en-US", false).NumberFormat;

            Int64 myInt = 123456789;
            Console.WriteLine(myInt.ToString("C", nfi));    //$123,456,789.00

            nfi.CurrencyPositivePattern = 1;
            Console.WriteLine(myInt.ToString("C", nfi));    //123,456,789.00$
        }

属性 CurrencyPositivePattern 与“C”标准格式字符串一起使用，以定义正货币值的模式。

• CurrencySymbol
  获取或设置用作货币符号的字符串。

        static void Main(string[] args)
        {
            // 获取与en-US区域性关联的NumberFormatInfo。
            NumberFormatInfo nfi = new CultureInfo("en-US", false).NumberFormat;

            Int64 myInt = 123456789;
            Console.WriteLine(myInt.ToString("C", nfi));    // $123,456,789.00
            Console.WriteLine(nfi.CurrencySymbol);          // $

            nfi.CurrencySymbol = "&";
            Console.WriteLine(myInt.ToString("C", nfi));    // &123,456,789.00
        }

扩展：如果在开发WPF项目的时候，使用字体图标，通过CurrencySymbol 可以设置货币符号，那么这个货币符号将有很大的扩展性

• InvariantInfo
  获取不依赖于区域性的（固定）只读的 NumberFormatInfo 对象。

using System;
using System.Globalization;
using System.Text;

class SamplesNumberFormatInfo  {

   public static void Main()  {

      // Gets the InvariantInfo.
      NumberFormatInfo myInv = NumberFormatInfo.InvariantInfo;

      // Gets a UnicodeEncoding to display the Unicode value of symbols.
      UnicodeEncoding myUE = new UnicodeEncoding( true, false );
      byte[] myCodes;

      // Displays the default values for each of the properties.
      Console.WriteLine( "InvariantInfo:\nNote: Symbols might not display correctly on the console,\ntherefore, Unicode values are included." );
      Console.WriteLine( "\tCurrencyDecimalDigits\t\t{0}", myInv.CurrencyDecimalDigits );
      Console.WriteLine( "\tCurrencyDecimalSeparator\t{0}", myInv.CurrencyDecimalSeparator );
      Console.WriteLine( "\tCurrencyGroupSeparator\t\t{0}", myInv.CurrencyGroupSeparator );
      Console.WriteLine( "\tCurrencyGroupSizes\t\t{0}", myInv.CurrencyGroupSizes[0] );
      Console.WriteLine( "\tCurrencyNegativePattern\t\t{0}", myInv.CurrencyNegativePattern );
      Console.WriteLine( "\tCurrencyPositivePattern\t\t{0}", myInv.CurrencyPositivePattern );
      myCodes = myUE.GetBytes( myInv.CurrencySymbol );
      Console.WriteLine( "\tCurrencySymbol\t\t\t{0}\t(U+{1:x2}{2:x2})", myInv.CurrencySymbol, myCodes[0], myCodes[1] );
      Console.WriteLine( "\tNaNSymbol\t\t\t{0}", myInv.NaNSymbol );
      Console.WriteLine( "\tNegativeInfinitySymbol\t\t{0}", myInv.NegativeInfinitySymbol );
      Console.WriteLine( "\tNegativeSign\t\t\t{0}", myInv.NegativeSign );
      Console.WriteLine( "\tNumberDecimalDigits\t\t{0}", myInv.NumberDecimalDigits );
      Console.WriteLine( "\tNumberDecimalSeparator\t\t{0}", myInv.NumberDecimalSeparator );
      Console.WriteLine( "\tNumberGroupSeparator\t\t{0}", myInv.NumberGroupSeparator );
      Console.WriteLine( "\tNumberGroupSizes\t\t{0}", myInv.NumberGroupSizes[0] );
      Console.WriteLine( "\tNumberNegativePattern\t\t{0}", myInv.NumberNegativePattern );
      Console.WriteLine( "\tPercentDecimalDigits\t\t{0}", myInv.PercentDecimalDigits );
      Console.WriteLine( "\tPercentDecimalSeparator\t\t{0}", myInv.PercentDecimalSeparator );
      Console.WriteLine( "\tPercentGroupSeparator\t\t{0}", myInv.PercentGroupSeparator );
      Console.WriteLine( "\tPercentGroupSizes\t\t{0}", myInv.PercentGroupSizes[0] );
      Console.WriteLine( "\tPercentNegativePattern\t\t{0}", myInv.PercentNegativePattern );
      Console.WriteLine( "\tPercentPositivePattern\t\t{0}", myInv.PercentPositivePattern );
      myCodes = myUE.GetBytes( myInv.PercentSymbol );
      Console.WriteLine( "\tPercentSymbol\t\t\t{0}\t(U+{1:x2}{2:x2})", myInv.PercentSymbol, myCodes[0], myCodes[1] );
      myCodes = myUE.GetBytes( myInv.PerMilleSymbol );
      Console.WriteLine( "\tPerMilleSymbol\t\t\t{0}\t(U+{1:x2}{2:x2})", myInv.PerMilleSymbol, myCodes[0], myCodes[1] );
      Console.WriteLine( "\tPositiveInfinitySymbol\t\t{0}", myInv.PositiveInfinitySymbol );
      Console.WriteLine( "\tPositiveSign\t\t\t{0}", myInv.PositiveSign );
   }
}


/*

This code produces the following output.

InvariantInfo:
Note: Symbols might not display correctly on the console,
therefore, Unicode values are included.
        CurrencyDecimalDigits           2
        CurrencyDecimalSeparator        .
        CurrencyGroupSeparator          ,
        CurrencyGroupSizes              3
        CurrencyNegativePattern         0
        CurrencyPositivePattern         0
        CurrencySymbol                         (U+00a4)
        NaNSymbol                       NaN
        NegativeInfinitySymbol          -Infinity
        NegativeSign                    -
        NumberDecimalDigits             2
        NumberDecimalSeparator          .
        NumberGroupSeparator            ,
        NumberGroupSizes                3
        NumberNegativePattern           1
        PercentDecimalDigits            2
        PercentDecimalSeparator         .
        PercentGroupSeparator           ,
        PercentGroupSizes               3
        PercentNegativePattern          0
        PercentPositivePattern          0
        PercentSymbol                   %       (U+0025)
        PerMilleSymbol                  %       (U+2030)
        PositiveInfinitySymbol          Infinity
        PositiveSign                    +

*/

结语

回到目录页：C# 知识汇总
希望以上内容可以帮助到大家，如文中有不对之处，还请批评指正。

参考资料
标准数字格式字符串
概述：如何在 .NET 中设置数字、日期、枚举和其他类型的格式