请教C#中String.Format 有什么作用什么情况下用它呢

本文目录

• 请教C#中String.Format 有什么作用什么情况下用它呢
• String.format(“%02d“, year)是什么意思
• string.format();用法
• String.format()静态方法为什么不用import就能使用
• string.Format 三个参数
• C#中string.Format怎么用
• String.format 是什么意思
• c#string.format的用法
• C#中string.Format，什么意思
• string.format用法

请教C#中String.Format 有什么作用什么情况下用它呢

C# String.Format格式，日期，数字，科学技术法，百分数，等等
　　string s1 = 12345.ToString(“n“); //生成 12,345.00
string s2 = 12345.ToString(“C“); //生成 ￥12,345.00
string s3 = 12345.ToString(“e“); //生成 1.234500e+004
string s4 = 12345.ToString(“f4“); //生成 12345.0000
string s5 = 12345.ToString(“x“); //生成 3039 (16进制)
string s6 = 612345.ToString(“p“); //生成 1,234,500.00%
string s7 = String.Format(“{0:(###) ###-####}“, 8005551212);
//生成(1800)555-1212
int a = 12345678;
double b = 1234.12543;
string s8= String.Format(“abcd{0:C}abcd“, b);//abcd￥1,234.13abcd
string s9 = “abcd“ + b.ToString(“C“) + “abcd“;//abcd￥1,234.13abcd
　　string s10 = String.Format(“{0:C3}“, b);//￥1,234.125
string s11 = b.ToString(“C3“);//￥1,234.125
string s12 = String.Format(“{0:d}“, a);//十进制--12345678
string s13 = b.ToString(“d“);//十进制--相同的类型，转换报错
string s14 = String.Format(“{0:e}“, a);//指数--1.234568e+007
string s15 = b.ToString(“e“);//指数--1.234125e+003
string s16 = String.Format(“{0:f}“, a);//定点数--12345678.00
string s17 = b.ToString(“f“);//定点数--1234.13
string s18 = String.Format(“{0:n}“, a);//数值--12,345,678.00
string s19 = b.ToString(“n“);//数值--1,234.13
string s20 = String.Format(“{0:x}“, a);//十六进制--bc614e
string s21 = b.ToString(“x“);//16--带有小数不能转换，出错
string s22 = String.Format(“{0:g}“, a);//通用为最紧凑--12345678
string s23 = b.ToString(“g“);//通用为最紧凑--1234.12543
　　b = 4321.12543;
a = 1234;
string s24 = String.Format(“{0:000000}“, a);// 001234
string s25 = String.Format(“{0:000000}“, b);// 004321
//# 描述：占位符，如果可能，填充位
string s26 = String.Format(“{0:#######}“, a);// 1234
string s27 = String.Format(“{0:#######}“, b);// 4321
string s28 = String.Format(“{0:#0####}“, a);// 01234
string s29 = String.Format(“{0:0#0000}“, b);// 004321
//. 描述：小数点
string s30 = String.Format(“{0:000.000}“, a);//1234.000
string s31 = String.Format(“{0:000.000}“, b);//4321.125
b = 87654321.12543;
a = 12345678;
//, 描述：数字分组，也用于增倍器
string s32 = String.Format(“{0:0,00}“, a);// 12,345,678
string s33 = String.Format(“{0:0,00}“, b);// 87,654,321
string s34 = String.Format(“{0:0,}“, a);// 12346
string s35 = String.Format(“{0:0,}“, b);// 87654
string s36 = String.Format(“{0:0,,}“, a);// 12
string s37 = String.Format(“{0:0,,}“, b);// 88
string s38 = String.Format(“{0:0,,,}“, a);// 0
string s39 = String.Format(“{0:0,,,}“, b);// 0　　
// % 描述：格式为百分数
　string s40 = String.Format(“{0:0%}“, a);// 1234567800%
string s41 = String.Format(“{0:#%}“, b);// 8765432113%
string s42 = String.Format(“{0:0.00%}“, a);// 1234567800.00%
string s43 = String.Format(“{0:#.00%}“, b);// 8765432112.54%
　　格式 原始数据 结 果
　　“{0:P}“ 0.40 40%
　　数字 {0:N2} 12.36
　　数字 {0:N0} 13
　　货币 {0:c2} $12.36
　　货币 {0:c4} $12.3656
　　货币 “￥{0:N2}“ ￥12.36
　　科学计数法 {0:E3} 1.23E+001
　　百分数 {0:P} 12.25% P and p present the same.
　　日期 {0:D} 2006年11月25日
　　日期 {0:d} 2006-11-25
　　日期 {0:f} 2006年11月25日 10:30
　　日期 {0:F} 2006年11月25日 10:30:00
　　日期 {0:s} 2006-11-26 10:30:00
时间 {0:T} 10:30:00
DateTime dt = DateTime.Now;
　　TextBox.Text = dt.ToString();//2005-11-5 13:21:25
　　TextBox.Text = dt.ToFileTime().ToString();//127756416859912816
　　TextBox.Text = dt.ToFileTimeUtc().ToString();//127756704859912816
　　TextBox.Text = dt.ToLocalTime().ToString();//2005-11-5 21:21:25
　　TextBox.Text = dt.ToLongDateString().ToString();//2005年11月5日
　　TextBox.Text = dt.ToLongTimeString().ToString();//13:21:25
　　TextBox.Text = dt.ToOADate().ToString();//38661.5565508218
　　TextBox.Text = dt.ToShortDateString().ToString();//2005-11-5
　　TextBox.Text = dt.ToShortTimeString().ToString();//13:21
　　TextBox.Text = dt.ToUniversalTime().ToString();//2005-11-5 5:21:25
　　TextBox.Text = dt.Year.ToString();//2005
　　TextBox.Text = dt.Date.ToString();//2005-11-5 0:00:00
　　TextBox.Text = dt.DayOfWeek.ToString();//Saturday
　　TextBox.Text = dt.DayOfYear.ToString();//309
　　TextBox.Text = dt.Hour.ToString();//13
　　TextBox.Text = dt.Millisecond.ToString();//441
　　TextBox.Text = dt.Minute.ToString();//30
　　TextBox.Text = dt.Month.ToString();//11
　　TextBox.Text = dt.Second.ToString();//28
　　TextBox.Text = dt.Ticks.ToString();//632667942284412864
　　TextBox.Text = dt.TimeOfDay.ToString();//13:30:28.4412864
　　TextBox.Text = dt.ToString();//2005-11-5 13:47:04
　　TextBox.Text = dt.AddYears(1).ToString();//2006-11-5 13:47:04
　　TextBox.Text = dt.AddDays(1.1).ToString();//2005-11-6 16:11:04
　　TextBox.Text = dt.AddHours(1.1).ToString();//2005-11-5 14:53:04
　　TextBox.Text = dt.AddMilliseconds(1.1).ToString();//2005-11-5 13:47:04
　　TextBox.Text = dt.AddMonths(1).ToString();//2005-12-5 13:47:04
　　TextBox.Text = dt.AddSeconds(1.1).ToString();//2005-11-5 13:47:05
　　TextBox.Text = dt.AddMinutes(1.1).ToString();//2005-11-5 13:48:10
　　TextBox.Text = dt.AddTicks(1000).ToString();//2005-11-5 13:47:04
　　TextBox.Text = dt.CompareTo(dt).ToString();//0
　　TextBox.Text = dt.Add(?).ToString();//问号为一个时间段
　　TextBox.Text = dt.Equals(“2005-11-6 16:11:04“).ToString();//False
　　TextBox.Text = dt.Equals(dt).ToString();//True
　　TextBox.Text = dt.GetHashCode().ToString();//1474088234
　　TextBox.Text = dt.GetType().ToString();//System.DateTime
　　TextBox.Text = dt.GetTypeCode().ToString();//DateTime
　　TextBox.Text = dt.GetDateTimeFormats(’s’).ToString();//2005-11-05T14:06:25
　　TextBox.Text = dt.GetDateTimeFormats(’t’).ToString();//14:06
　　TextBox.Text = dt.GetDateTimeFormats(’y’).ToString();//2005年11月
　　TextBox.Text = dt.GetDateTimeFormats(’D’).ToString();//2005年11月5日
　　TextBox.Text = dt.GetDateTimeFormats(’D’).ToString();//2005 11 05
　　TextBox.Text = dt.GetDateTimeFormats(’D’).ToString();//星期六 2005 11 05
　　TextBox.Text = dt.GetDateTimeFormats(’D’).ToString();//星期六 2005年11月5日
　　TextBox.Text = dt.GetDateTimeFormats(’M’).ToString();//11月5日
　　TextBox.Text = dt.GetDateTimeFormats(’f’).ToString();//2005年11月5日 14:06
　　TextBox.Text = dt.GetDateTimeFormats(’g’).ToString();//2005-11-5 14:06
　　TextBox.Text = dt.GetDateTimeFormats(’r’).ToString();//Sat, 05 Nov 2005 14:06:25 GMT
　　TextBox.Text = String.Format(“{0:d}“,dt);//2005-11-5
　　TextBox.Text = String.Format(“{0:D}“,dt);//2005年11月5日
　　TextBox.Text = String.Format(“{0:f}“,dt);//2005年11月5日 14:23
　　TextBox.Text = String.Format(“{0:F}“,dt);//2005年11月5日 14:23:23
　　TextBox.Text = String.Format(“{0:g}“,dt);//2005-11-5 14:23
　　TextBox.Text = String.Format(“{0:G}“,dt);//2005-11-5 14:23:23
　　TextBox.Text = String.Format(“{0:M}“,dt);//11月5日
　　TextBox.Text = String.Format(“{0:R}“,dt);//Sat, 05 Nov 2005 14:23:23 GMT
　　TextBox.Text = String.Format(“{0:s}“,dt);//2005-11-05T14:23:23
　　TextBox.Text String.Format(“{0:t}“,dt);//14:23
　　TextBox.Text = String.Format(“{0:T}“,dt);//14:23:23
　　TextBox.Text = String.Format(“{0:u}“,dt);//2005-11-05 14:23:23Z
　　TextBox.Text = String.Format(“{0:U}“,dt);//2005年11月5日 6:23:23
　　TextBox.Text = String.Format(“{0:Y}“,dt);//2005年11月
　　TextBox.Text = String.Format(“{0}“,dt);//2005-11-5 14:23:23
　　TextBox.Text = String.Format(“{0:yyyyMMddHHmmssffff}“,dt);
　　TextBox =String.Format(“{0:N1}“,56789); //result: 56,789.0
　　TextBox =String.Format(“{0:N2}“,56789); //result: 56,789.00
　　TextBox =String.Format(“{0:N3}“,56789); //result: 56,789.000
　　TextBox =String.Format(“{0:F1}“,56789); //result: 56789.0
　　TextBox =String.Format(“{0:F2}“,56789); //result: 56789.00
　　TextBox =(56789 / 100.0).ToString(“#.##“); //result: 567.89
　　TextBox =(56789 / 100).ToString(“#.##“); //result: 567
　　C 或 c
　　货币
　　Console.Write(“{0:C}“, 2.5); //$2.50
　　Console.Write(“{0:C}“, -2.5); //($2.50)
　　D 或 d
　　十进制数
　　Console.Write(“{0:D5}“, 25); //00025
　　E 或 e
　　科学型
　　Console.Write(“{0:E}“, 250000); //2.500000E+005
　　F 或 f
　　固定点
　　Console.Write(“{0:F2}“, 25); //25.00
　　Console.Write(“{0:F0}“, 25); //25
　　G 或 g
　　常规
　　Console.Write(“{0:G}“, 2.5); //2.5
　　N 或 n
　　数字
　　Console.Write(“{0:N}“, 2500000); //2,500,000.00
　X 或 x
　　十六进制
　　Console.Write(“{0:X}“, 250); //FA
　　Console.Write(“{0:X}“, 0xffff); //FFFF

String.format(“%02d“, year)是什么意思

1、String.format(“%02d“, year)

2、year格式化为至少2位十进制整数
譬如int year = 5; 结果为05

3、string.format 是格式化字符串  最大的好处 是 有多个参数的时候 只在内存中分布一个字符串如过用++的方式就会分布多个 

例如：C# code
string sql=“select “ + colname + “from “+tablename;  //这个拼装的字符串就会在拼装的时候再内存中多分配了两个字符串空间（引号的内容）

string.format();用法

MessageBox.Show(string.Format(“不存在用户{0}，请重新输入！“, textBox2.Text)); 在format规定的字符串里，有{数字}这样的占位符，数字是几，就代表是后面的第几个参数。所以在这里是{0}，代表把参数textBox2.Text放进字符串中的这个位置。就等同于 MessageBox.Show(“不存在用户“ + textBox2.Text + “，请重新输入！“); 下面的sql也是一样到道理。将state的值替换到{0}的位置。 因为参数可以是个数组，所以才会有{0}{1}{2}……分别替换你的参数数组里第几个值。

String.format()静态方法为什么不用import就能使用

带类名使用静态方法是不需要导入静态方法的，只需要导入那个类就行了。

而java.lang包中的类是默认自动导入的，String类属于这个包，因此被自动导入了。所以就可以使用String类的静态方法了，通过String.staticMethodName的方式。

如果

import static Java.lang.String.format;

就可以省略类名使用format了。

下面是一个例子：

string.Format 三个参数

1.对整数进行格式化：%[index$][标识][最小宽度]转换方式
我们可以看到，格式化字符串由4部分组成，其中%[index$]的含义我们上面已经讲过，[最小宽度]的含义也很好理解，就是最终该整数转化的字符串最少包含多少位数字。我们来看看剩下2个部分的含义吧：
标识：
’-’ 在最小宽度内左对齐，不可以与“用0填充”同时使用
’#’ 只适用于8进制和16进制，8进制时在结果前面增加一个0，16进制时在结果前面增加0x
’+’ 结果总是包括一个符号（一般情况下只适用于10进制，若对象为BigInteger才可以用于8进制和16进制）
’ ’ 正值前加空格，负值前加负号（一般情况下只适用于10进制，若对象为BigInteger才可以用于8进制和16进制）
’0’ 结果将用零来填充
’,’ 只适用于10进制，每3位数字之间用“，”分隔
’(’ 若参数是负数，则结果中不添加负号而是用圆括号把数字括起来（同‘+’具有同样的限制）
转换方式：
d-十进制 o-八进制 x或X-十六进制
上面的说明过于枯燥，我们来看几个具体的例子。需要特别注意的一点是：大部分标识字符可以同时使用。
[java] view plain copy
System.out.println(String.format(“%1$,09d“, -3123));
System.out.println(String.format(“%1$9d“, -31));
System.out.println(String.format(“%1$-9d“, -31));
System.out.println(String.format(“%1$(9d“, -31));
System.out.println(String.format(“%1$#9x“, 5689));

//结果为：
//-0003,123
// -31
//-31
// (31)
// 0x1639
2.对浮点数进行格式化：%[index$][标识][最少宽度][.精度]转换方式
我们可以看到，浮点数的转换多了一个“精度”选项，可以控制小数点后面的位数。
标识：
’-’ 在最小宽度内左对齐，不可以与“用0填充”同时使用
’+’ 结果总是包括一个符号
’ ’ 正值前加空格，负值前加负号
’0’ 结果将用零来填充
’,’ 每3位数字之间用“，”分隔（只适用于fgG的转换）
’(’ 若参数是负数，则结果中不添加负号而是用圆括号把数字括起来（只适用于eEfgG的转换）
转换方式：
’e’, ’E’ -- 结果被格式化为用计算机科学记数法表示的十进制数
’f’ -- 结果被格式化为十进制普通表示方式
’g’, ’G’ -- 根据具体情况，自动选择用普通表示方式还是科学计数法方式
’a’, ’A’ -- 结果被格式化为带有效位数和指数的十六进制浮点数
3.对字符进行格式化：
对字符进行格式化是非常简单的，c表示字符，标识中’-’表示左对齐，其他就没什么了。
4.对百分比符号进行格式化：
看了上面的说明，大家会发现百分比符号“%”是特殊格式的一个前缀。那么我们要输入一个百分比符号该怎么办呢？肯定是需要转义字符的,但是要注意的是，在这里转义字符不是“\”，而是“%”。换句话说，下面这条语句可以输出一个“12%”：
System.out.println(String.format(“%1$d%%“, 12));
5.取得平台独立的行分隔符：
System.getProperty(“line.separator“)可以取得平台独立的行分隔符，但是用在format中间未免显得过于烦琐了。于是format函数自带了一个平台独立的行分隔符那就是String.format(“%n“)。
6.对日期类型进行格式化：
以下日期和时间转换的后缀字符是为 ’t’ 和 ’T’ 转换定义的。这些类型相似于但不完全等同于那些由 GNU date 和 POSIX strftime(3c) 定义的类型。提供其他转换类型是为了访问特定于 Java 的功能（如将 ’L’ 用作秒中的毫秒）。
以下转换字符用来格式化时间：
’H’ 24 小时制的小时，被格式化为必要时带前导零的两位数，即 00 - 23。
’I’ 12 小时制的小时，被格式化为必要时带前导零的两位数，即 01 - 12。
’k’ 24 小时制的小时，即 0 - 23。
’l’ 12 小时制的小时，即 1 - 12。
’M’ 小时中的分钟，被格式化为必要时带前导零的两位数，即 00 - 59。
’S’ 分钟中的秒，被格式化为必要时带前导零的两位数，即 00 - 60 （“60“ 是支持闰秒所需的一个特殊值）。
’L’ 秒中的毫秒，被格式化为必要时带前导零的三位数，即 000 - 999。
’N’ 秒中的毫微秒，被格式化为必要时带前导零的九位数，即 000000000 - 999999999。
’p’ 特定于语言环境的 上午或下午 标记以小写形式表示，例如 “am“ 或 “pm“。使用转换前缀 ’T’ 可以强行将此输出转换为大写形式。
’z’ 相对于 GMT 的 RFC 822 格式的数字时区偏移量，例如 -0800。
’Z’ 表示时区缩写形式的字符串。Formatter 的语言环境将取代参数的语言环境（如果有）。
’s’ 自协调世界时 (UTC) 1970 年 1 月 1 日 00:00:00 至现在所经过的秒数，即 Long.MIN_VALUE/1000 与 Long.MAX_VALUE/1000 之间的差值。
’Q’ 自协调世界时 (UTC) 1970 年 1 月 1 日 00:00:00 至现在所经过的毫秒数，即 Long.MIN_VALUE 与 Long.MAX_VALUE 之间的差值。
以下转换字符用来格式化日期：
’B’ 特定于语言环境的月份全称，例如 “January“ 和 “February“。
’b’ 特定于语言环境的月份简称，例如 “Jan“ 和 “Feb“。
’h’ 与 ’b’ 相同。
’A’ 特定于语言环境的星期几全称，例如 “Sunday“ 和 “Monday“
’a’ 特定于语言环境的星期几简称，例如 “Sun“ 和 “Mon“
’C’ 除以 100 的四位数表示的年份，被格式化为必要时带前导零的两位数，即 00 - 99
’Y’ 年份，被格式化为必要时带前导零的四位数（至少），例如，0092 等于格里高利历的 92 CE。
’y’ 年份的最后两位数，被格式化为必要时带前导零的两位数，即 00 - 99。
’j’ 一年中的天数，被格式化为必要时带前导零的三位数，例如，对于格里高利历是 001 - 366。
’m’ 月份，被格式化为必要时带前导零的两位数，即 01 - 13。
’d’ 一个月中的天数，被格式化为必要时带前导零两位数，即 01 - 31
’e’ 一个月中的天数，被格式化为两位数，即 1 - 31。
以下转换字符用于格式化常见的日期/时间组合。
’R’ 24 小时制的时间，被格式化为 “%tH:%tM“
’T’ 24 小时制的时间，被格式化为 “%tH:%tM:%tS“。
’r’ 12 小时制的时间，被格式化为 “%tI:%tM:%tS %Tp“。上午或下午标记 (’%Tp’) 的位置可能与语言环境有关。
’D’ 日期，被格式化为 “%tm/%td/%ty“。
’F’ ISO 8601 格式的完整日期，被格式化为 “%tY-%tm-%td“。
’c’ 日期和时间，被格式化为 “%ta %tb %td %tT %tZ %tY“，例如 “Sun Jul 20 16:17:00 EDT 1969“。
JDK1.5中，String类新增了一个很有用的静态方法String.format():
format(Locale l, String format, Object... args) 使用指定的语言环境、格式字符串和参数返回一个格式化字符串。
format(String format, Object... args) 使用指定的格式字符串和参数返回一个格式化字符串。
举几个这个方法实用的例子(注释是输出结果)：
CODE:
long now = System.currentTimeMillis();
String s = String.format(“%tR“, now); // “15:12“
CODE:
// Current month/day/year
Date d = new Date(now);
s = String.format(“%tD“, d); // “07/13/04“
CODE:
s = String.format(“%,d“, Integer.MAX_VALUE); // “2,147,483,647“
CODE:
s = String.format(“%05d“, 123); // “00123“是不是很方便，让人动心啊？哈哈，还有更多的效果!
其实format函数有些类似C语言中printf函数，一些格式字符串与 C 类似，但已进行了某些定制，以适应 Java 语言，并且利用了其中一些特性。此方法提供了对布局对齐和排列的支持，以及对数值、字符串和日期/时间数据的常规格式和特定于语言环境的输出的支持。支持诸如 byte、BigDecimal 和 Calendar 等常见 Java 类型。
产生格式化输出的每个方法都需要格式字符串 和参数列表。格式字符串是一个 String，它可以包含固定文本以及一个或多个嵌入的格式说明符。请考虑以下示例：
Calendar c = ...;
String s = String.format(“Duke’s Birthday: %1$tm %1$te,%1$tY“, c);
格式字符串是 format 方法的第一个参数。它包含三个格式说明符 “%1$tm“、“%1$te“ 和 “%1$tY“，它们指出应该如何处理参数以及在文本的什么地方插入它们。格式字符串的其余部分是包括 “Dukes Birthday: “ 和其他任何空格或标点符号的固定文本。 参数列表由传递给位于格式字符串之后的方法的所有参数组成。

在上述示例中，参数列表的大小为 1，由新对象 Calendar 组成。
1.常规类型、字符类型和数值类型的格式说明符的语法如下：
%[argument_index$][flags][width][.precision]conversion
可选的 argument_index 是一个十进制整数，用于表明参数在参数列表中的位置。第一个参数由 “1$“ 引用，第二个参数由 “2$“ 引用，依此类推。
可选的 flags 是修改输出格式的字符集。有效标志的集合取决于转换类型。
可选 width 是一个非负十进制整数，表明要向输出中写入的最少字符数。
可选 precision 是一个非负十进制整数，通常用来限制字符数。特定行为取决于转换类型。
所需的 conversion 是一个表明应该如何格式化参数的字符。给定参数的有效转换集合取决于参数的数据类型。
2.用来表示日期和时间类型的格式说明符的语法如下:
%[argument_index$][flags][width]conversion
可选的 argument_index 、flags 和 width 的定义同上。
所需的 conversion 是一个由两字符组成的序列。第一个字符是 ’t’ 或 ’T’。第二个字符表明所使用的格式。这些字符类似于但不完全等同于那些由 GNU date 和 POSIX strftime(3c) 定义的字符。
3.与参数不对应的格式说明符的语法如下：
%[flags][width]conversion
可选 flags 和 width 的定义同上。
所需的 conversion 是一个表明要在输出中所插内容的字符。
转换
转换可分为以下几类：
1. 常规 - 可应用于任何参数类型
2. 字符 - 可应用于表示 Unicode 字符的基本类型：char、Character、byte、Byte、short 和 Short。当 Character.isValidCodePoint(int) 返回 true 时，可将此转换应用于 int 和 Integer 类型
3. 数值
1. 整数 - 可应用于 Java 的整数类型：byte、Byte、short、Short、int、Integer、long、Long 和 BigInteger
2. 浮点 - 可用于 Java 的浮点类型：float、Float、double、Double 和 BigDecimal
4. 日期/时间 - 可应用于 Java 的、能够对日期或时间进行编码的类型：long、Long、Calendar 和 Date。
5. 百分比 - 产生字面值 ’%’ (’\u0025’)
6. 行分隔符 - 产生特定于平台的行分隔符

C#中string.Format怎么用

如果有占位符{0}这样的可以往这个占位符里面插入指定的内容。
比如：string str=“你好：{0}！您的{1}回答在{2}被采纳了。“;
string ret=string.Format(str,“张三“,“百度知道“,“2017-10-13“);
最终输入的ret内容是：
你好：张三！您的百度知道回答在2017-10-13被采纳了。

String.format 是什么意思

string format
字符串格式
format
英-[’fɔːmæt]
美-[’fɔrmæt]
释义
n. 格式；版式；开本
vt. 使格式化；规定…的格式
vi. 设计版式

c#string.format的用法

c#中string.format主要用来格式化输出的 比较常用的就是占位符 如楼上所解还有用的比较多的就是在格式化时间如： String.Format(“{0:yyyy年MM月dd日 HH:mm}“, “2011-05-11”);

C#中string.Format，什么意思

string.Format是将指定的 String类型的数据中的每个格式项替换为相应对象的值的文本等效项。
不好理解的举个例子你瞬间就明白了。
string str=string.Format(“Hello {0}, I’m {1}.“, “张三“, “李四“)；
执行完这句话后：
str的结果就是：Hello 张三，I’m 李四.
这样你该明白了吧

string.format用法

参数
format
类型：System..::.String
复合格式字符串。
args
类型：array《System..::.Object》()
包含零个或多个要格式化的对象的 Object 数组。
返回值
类型：System..::.String
format 的一个副本，其中格式项已替换为 args 中相应 Object 实例的 String 等效项。
异常
异常 条件
ArgumentNullException format 或 args 为 nullNothingnullptrnull 引用（在 Visual Basic 中为 Nothing）。

FormatException format 无效。
- 或 -
用于指示要格式化的参数的数字小于零，或者大于等于 args 数组的长度。
备注
此方法使用 .NET Framework 的复合格式设置功能将对象的值转换为其文本表示形式，并将该表示形式嵌入字符串中。.NET Framework 提供了广泛的格式设置支持，下面的格式设置主题中对此有更详细的描述。
有关 Format、AppendFormat 等方法以及 WriteLine 的某些重载所支持的复合格式设置功能的更多信息，请参见复合格式设置。
有关数值格式说明符的更多信息，请参见标准数字格式字符串和自定义数字格式字符串。
有关日期和时间格式说明符的更多信息，请参见标准日期和时间格式字符串和自定义日期和时间格式字符串。
有关枚举格式说明符的更多信息，请参见枚举格式字符串。
有关格式设置的更多信息，请参见为类型设置格式和格式设置概述。
format 参数由零个或多个文本序列与零个或多个索引占位符混合组成，其中索引占位符称为格式项，它们与此方法的参数列表中的对象相对应。格式设置过程将每个格式项替换为相应对象值的文本表示形式。
格式项的语法是 {索引[,对齐方式][:格式字符串]}，它指定了一个强制索引、格式化文本的可选长度和对齐方式，以及格式说明符字符的可选字符串，其中格式说明符字符用于控制如何设置相应对象的值的格式。格式项的组成部分包括：
索引
从零开始的整数，指示对象列表中要格式化的元素。如果由索引指定的对象为 nullNothingnullptrnull 引用（在 Visual Basic 中为 Nothing），则格式项将被空字符串 (““) 替换。
对齐方式
可选整数，指示包含格式化值的区域的最小宽度。如果格式化值的长度小于对齐方式，则用空格填充该区域。如果对齐方式为负，则格式化值将在该区域中左对齐；如果对齐方式为正，则格式化值将右对齐。如果没有指定对齐方式，则该区域的长度为格式化值的长度。如果指定对齐方式，则需要使用逗号。
格式字符串
可选的格式说明符字符串。如果没有指定格式字符串，并且对应的参数实现了 IFormattable 接口，则将 nullNothingnullptrnull 引用（在 Visual Basic 中为 Nothing） 用作 IFormattable..::.ToString 格式字符串。因此，IFormattable..::.ToString 的所有实现都必须允许 nullNothingnullptrnull 引用（在 Visual Basic 中为 Nothing） 作为格式字符串，并以 String 对象的形式返回对象表示形式的默认格式设置。如果指定格式字符串，则需要使用冒号。
必须使用前导大括号字符和尾部大括号字符，即“{”和“}”。若要在 format 中指定单个大括号字符，请指定两个前导大括号字符或尾部大括号字符；即“{{”或“}}”。
如果 format 的值为“Thank you for your purchase of {0:####} copies of Microsoft®.NET (Core Reference).”，并且 arg 是值为 123 的 Int16，则返回值为：
“Thank you for your purchase of 123 copies of Microsoft®.NET (Core Reference).”
如果 format 的值为“Brad’s dog has {0,-8:G} fleas.”，arg 是值为 42 的 Int16（在此示例中，下划线表示填充空格），则返回值为：
“Brad’s dog has 42______ fleas.”
示例
下面的代码示例演示数字、日期和枚举的标准格式设置说明符。
Visual Basic 复制代码
’ This code example demonstrates the String.Format() method.
’ This example uses the provider parameter to supply formatting
’ information using the invariant culture.
Imports System.Globalization
Class Sample
Public Enum Color
Yellow = 1
Blue = 2
Green = 3
End Enum ’Color
Private Shared thisDate As DateTime = DateTime.Now
Public Shared Sub Main()
’ Store the output of the String.Format method in a string.
Dim s As String = ““
Console.Clear()
’ Format a negative integer or floating-point number in various ways.
Console.WriteLine(“Standard Numeric Format Specifiers“)
s = String.Format(CultureInfo.InvariantCulture, _
“(C) Currency: . . . . . . . . {0:C}“ & vbCrLf & _
“(D) Decimal:. . . . . . . . . {0:D}“ & vbCrLf & _
“(E) Scientific: . . . . . . . {1:E}“ & vbCrLf & _
“(F) Fixed point:. . . . . . . {1:F}“ & vbCrLf & _
“(G) General:. . . . . . . . . {0:G}“ & vbCrLf & _
“ (default):. . . . . . . . {0} (default = ’G’)“ & vbCrLf & _
“(N) Number: . . . . . . . . . {0:N}“ & vbCrLf & _
“(P) Percent:. . . . . . . . . {1:P}“ & vbCrLf & _
“(R) Round-trip: . . . . . . . {1:R}“ & vbCrLf & _
“(X) Hexadecimal:. . . . . . . {0:X}“ & vbCrLf, _
- 123, - 123.45F)
Console.WriteLine(s)
’ Format the current date in various ways.
Console.WriteLine(“Standard DateTime Format Specifiers“)
s = String.Format(CultureInfo.InvariantCulture.DateTimeFormat, _
“(d) Short date: . . . . . . . {0:d}“ & vbCrLf & _
“(D) Long date:. . . . . . . . {0:D}“ & vbCrLf & _
“(t) Short time: . . . . . . . {0:t}“ & vbCrLf & _
“(T) Long time:. . . . . . . . {0:T}“ & vbCrLf & _
“(f) Full date/short time: . . {0:f}“ & vbCrLf & _
“(F) Full date/long time:. . . {0:F}“ & vbCrLf & _
“(g) General date/short time:. {0:g}“ & vbCrLf & _
“(G) General date/long time: . {0:G}“ & vbCrLf & _
“ (default):. . . . . . . . {0} (default = ’G’)“ & vbCrLf & _
“(M) Month:. . . . . . . . . . {0:M}“ & vbCrLf & _
“(R) RFC1123:. . . . . . . . . {0:R}“ & vbCrLf & _
“(s) Sortable: . . . . . . . . {0:s}“ & vbCrLf & _
“(u) Universal sortable: . . . {0:u} (invariant)“ & vbCrLf & _
“(U) Universal sortable: . . . {0:U}“ & vbCrLf & _
“(Y) Year: . . . . . . . . . . {0:Y}“ & vbCrLf, _
thisDate)
Console.WriteLine(s)
’ Format a Color enumeration value in various ways.
Console.WriteLine(“Standard Enumeration Format Specifiers“)
s = String.Format(CultureInfo.InvariantCulture, _
“(G) General:. . . . . . . . . {0:G}“ & vbCrLf & _
“ (default):. . . . . . . . {0} (default = ’G’)“ & vbCrLf & _
“(F) Flags:. . . . . . . . . . {0:F} (flags or integer)“ & vbCrLf & _
“(D) Decimal number: . . . . . {0:D}“ & vbCrLf & _
“(X) Hexadecimal:. . . . . . . {0:X}“ & vbCrLf, _
Color.Green)
Console.WriteLine(s)
End Sub ’Main
End Class ’Sample
’
’ This example displays the following output to the console:
’
’ Standard Numeric Format Specifiers
’ (C) Currency: . . . . . . . . (123.00)
’ (D) Decimal:. . . . . . . . . -123
’ (E) Scientific: . . . . . . . -1.234500E+002
’ (F) Fixed point:. . . . . . . -123.45
’ (G) General:. . . . . . . . . -123
’ (default):. . . . . . . . -123 (default = ’G’)
’ (N) Number: . . . . . . . . . -123.00
’ (P) Percent:. . . . . . . . . -12,345.00 %
’ (R) Round-trip: . . . . . . . -123.45
’ (X) Hexadecimal:. . . . . . . FFFFFF85
’
’ Standard DateTime Format Specifiers
’ (d) Short date: . . . . . . . 07/09/2007
’ (D) Long date:. . . . . . . . Monday, 09 July 2007
’ (t) Short time: . . . . . . . 13:42
’ (T) Long time:. . . . . . . . 13:42:50
’ (f) Full date/short time: . . Monday, 09 July 2007 13:42
’ (F) Full date/long time:. . . Monday, 09 July 2007 13:42:50
’ (g) General date/short time:. 07/09/2007 13:42
’ (G) General date/long time: . 07/09/2007 13:42:50
’ (default):. . . . . . . . 07/09/2007 13:42:50 (default = ’G’)
’ (M) Month:. . . . . . . . . . July 09
’ (R) RFC1123:. . . . . . . . . Mon, 09 Jul 2007 13:42:50 GMT
’ (s) Sortable: . . . . . . . . 2007-07-09T13:42:50
’ (u) Universal sortable: . . . 2007-07-09 13:42:50Z (invariant)
’ (U) Universal sortable: . . . Monday, 09 July 2007 20:42:50
’ (Y) Year: . . . . . . . . . . 2007 July
’
’ Standard Enumeration Format Specifiers
’ (G) General:. . . . . . . . . Green
’ (default):. . . . . . . . Green (default = ’G’)
’ (F) Flags:. . . . . . . . . . Green (flags or integer)
’ (D) Decimal number: . . . . . 3
’ (X) Hexadecimal:. . . . . . . 00000003
C# 复制代码
// This code example demonstrates the String.Format() method.
// Formatting for this example uses the “en-US“ culture.
using System;
using System.Globalization;
class Sample
{
enum Color {Yellow = 1, Blue, Green};
static DateTime thisDate = DateTime.Now;
public static void Main()
{
// Store the output of the String.Format method in a string.
string s = ““;
Console.Clear();
// Format a negative integer or floating-point number in various ways.
Console.WriteLine(“Standard Numeric Format Specifiers“);
s = String.Format(CultureInfo.InvariantCulture,
“(C) Currency: . . . . . . . . {0:C}\n“ +
“(D) Decimal:. . . . . . . . . {0:D}\n“ +
“(E) Scientific: . . . . . . . {1:E}\n“ +
“(F) Fixed point:. . . . . . . {1:F}\n“ +
“(G) General:. . . . . . . . . {0:G}\n“ +
“ (default):. . . . . . . . {0} (default = ’G’)\n“ +
“(N) Number: . . . . . . . . . {0:N}\n“ +
“(P) Percent:. . . . . . . . . {1:P}\n“ +
“(R) Round-trip: . . . . . . . {1:R}\n“ +
“(X) Hexadecimal:. . . . . . . {0:X}\n“,
-123, -123.45f);
Console.WriteLine(s);
// Format the current date in various ways.
Console.WriteLine(“Standard DateTime Format Specifiers“);
s = String.Format(CultureInfo.InvariantCulture.DateTimeFormat,
“(d) Short date: . . . . . . . {0:d}\n“ +
“(D) Long date:. . . . . . . . {0:D}\n“ +
“(t) Short time: . . . . . . . {0:t}\n“ +
“(T) Long time:. . . . . . . . {0:T}\n“ +
“(f) Full date/short time: . . {0:f}\n“ +
“(F) Full date/long time:. . . {0:F}\n“ +
“(g) General date/short time:. {0:g}\n“ +
“(G) General date/long time: . {0:G}\n“ +
“ (default):. . . . . . . . {0} (default = ’G’)\n“ +
“(M) Month:. . . . . . . . . . {0:M}\n“ +
“(R) RFC1123:. . . . . . . . . {0:R}\n“ +
“(s) Sortable: . . . . . . . . {0:s}\n“ +
“(u) Universal sortable: . . . {0:u} (invariant)\n“ +
“(U) Universal sortable: . . . {0:U}\n“ +
“(Y) Year: . . . . . . . . . . {0:Y}\n“,
thisDate);
Console.WriteLine(s);
// Format a Color enumeration value in various ways.
Console.WriteLine(“Standard Enumeration Format Specifiers“);
s = String.Format(CultureInfo.InvariantCulture,
“(G) General:. . . . . . . . . {0:G}\n“ +
“ (default):. . . . . . . . {0} (default = ’G’)\n“ +
“(F) Flags:. . . . . . . . . . {0:F} (flags or integer)\n“ +
“(D) Decimal number: . . . . . {0:D}\n“ +
“(X) Hexadecimal:. . . . . . . {0:X}\n“,
Color.Green);
Console.WriteLine(s);
}
}
/*
This example displays the following output to the console:
Standard Numeric Format Specifiers
(C) Currency: . . . . . . . . (123.00)
(D) Decimal:. . . . . . . . . -123
(E) Scientific: . . . . . . . -1.234500E+002
(F) Fixed point:. . . . . . . -123.45
(G) General:. . . . . . . . . -123
(default):. . . . . . . . -123 (default = ’G’)
(N) Number: . . . . . . . . . -123.00
(P) Percent:. . . . . . . . . -12,345.00 %
(R) Round-trip: . . . . . . . -123.45
(X) Hexadecimal:. . . . . . . FFFFFF85
Standard DateTime Format Specifiers
(d) Short date: . . . . . . . 07/09/2007
(D) Long date:. . . . . . . . Monday, 09 July 2007
(t) Short time: . . . . . . . 13:48
(T) Long time:. . . . . . . . 13:48:05
(f) Full date/short time: . . Monday, 09 July 2007 13:48
(F) Full date/long time:. . . Monday, 09 July 2007 13:48:05
(g) General date/short time:. 07/09/2007 13:48
(G) General date/long time: . 07/09/2007 13:48:05
(default):. . . . . . . . 07/09/2007 13:48:05 (default = ’G’)
(M) Month:. . . . . . . . . . July 09
(R) RFC1123:. . . . . . . . . Mon, 09 Jul 2007 13:48:05 GMT
(s) Sortable: . . . . . . . . 2007-07-09T13:48:05
(u) Universal sortable: . . . 2007-07-09 13:48:05Z (invariant)
(U) Universal sortable: . . . Monday, 09 July 2007 20:48:05
(Y) Year: . . . . . . . . . . 2007 July
Standard Enumeration Format Specifiers
(G) General:. . . . . . . . . Green
(default):. . . . . . . . Green (default = ’G’)
(F) Flags:. . . . . . . . . . Green (flags or integer)
(D) Decimal number: . . . . . 3
(X) Hexadecimal:. . . . . . . 00000003
*/