String.Format 方法
定义
将对象的值转换为基于指定格式的字符串,并将其插入到另一个字符串。Converts the value of objects to strings based on the formats specified and inserts them into another string.
如果不熟悉 String.Format
方法,请参阅 String.Format 方法入门一节来进行快速了解。If you are new to the String.Format
method, see the Get started with the String.Format method section for a quick overview.
有关 String.Format
方法的常规文档,请参阅备注部分。See the Remarks section for general documentation for the String.Format
method.
重载
Format(String, Object) |
将字符串中的一个或多个格式项替换为指定对象的字符串表示形式。Replaces one or more format items in a string with the string representation of a specified object. |
Format(String, Object[]) |
将指定字符串中的格式项替换为指定数组中相应对象的字符串表示形式。Replaces the format item in a specified string with the string representation of a corresponding object in a specified array. |
Format(IFormatProvider, String, Object) |
将指定字符串中的一个或多个格式项替换为对应对象的字符串表示形式。Replaces the format item or items in a specified string with the string representation of the corresponding object. 参数提供区域性特定的格式设置信息。A parameter supplies culture-specific formatting information. |
Format(IFormatProvider, String, Object[]) |
将字符串中的格式项替换为指定数组中相应对象的字符串表示形式。Replaces the format items in a string with the string representations of corresponding objects in a specified array. 参数提供区域性特定的格式设置信息。A parameter supplies culture-specific formatting information. |
Format(String, Object, Object) |
将字符串中的格式项替换为两个指定对象的字符串表示形式。Replaces the format items in a string with the string representation of two specified objects. |
Format(IFormatProvider, String, Object, Object) |
将字符串中的格式项替换为两个指定对象的字符串表示形式。Replaces the format items in a string with the string representation of two specified objects. 参数提供区域性特定的格式设置信息。A parameter supplies culture-specific formatting information. |
Format(String, Object, Object, Object) |
将字符串中的格式项替换为三个指定对象的字符串表示形式。Replaces the format items in a string with the string representation of three specified objects. |
Format(IFormatProvider, String, Object, Object, Object) |
将字符串中的格式项替换为三个指定对象的字符串表示形式。Replaces the format items in a string with the string representation of three specified objects. 参数提供区域性特定的格式设置信息。An parameter supplies culture-specific formatting information. |
示例
调用方法的多 Format 个示例贯穿本文的 " 备注 " 部分。Numerous examples that call the Format method are interspersed through the Remarks section of this article.
你还可以下载一组完整的 String.Format
示例,其中包括 适用于 c # 的 .net Core 项目。You can also download a complete set of String.Format
examples, which are included a .NET Core project for C#.
下面是本文中包含的一些示例:The following are some of the examples included in the article:
创建格式字符串Create a format string
插入字符串Inserting a string
格式项The format item
设置具有相同索引的项的格式Format items that have the same index
控制格式化输出Control formatted output
控制格式设置Controlling formatting
控制间距Controlling spacing
控制对齐方式Controlling alignment
控制整数位数Controlling the number of integral digits
控制小数点分隔符后的位数Controlling the number of digits after the decimal separator
在结果字符串中包含字面大括号Including literal braces in a result string
使格式字符串区分区域性Make format strings culture-sensitive
区分区域性的格式设置Culture-sensitive formatting
自定义格式设置操作Customize the formatting operation
自定义格式设置操作A custom formatting operation
截距提供程序和罗马数字格式化程序An intercept provider and Roman numeral formatter
注解
重要
可以不调用 String.Format 方法或使用复合格式字符串,而改为使用内插字符串(如果受语言支持的话)******。Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 内插字符串是包含内插表达式的字符串。An interpolated string is a string that contains interpolated expressions. 每个内插表达式都使用表达式的值进行解析,并在分配字符串时包含在结果字符串中。Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 有关详细信息,请参阅字符串内插(C# 参考)和内插字符串(Visual Basic 参考)。For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).
本节内容:In this section:
开始处理字符串. 格式方法Get started with the String.Format method
我要调用哪种方法?Which method do I call?
Format 方法 briefThe Format method in brief
格式项The Format item
如何设置参数的格式How arguments are formatted
设置具有相同索引的项的格式Format items that have the same index
格式设置和区域性Formatting and culture
自定义格式设置操作Custom formatting operations
字符串格式 Q &String.Format Q & A
开始处理字符串. 格式方法Get started with the String.Format method
String.Format如果需要将对象、变量或表达式的值插入到另一个字符串,请使用。Use String.Format if you need to insert the value of an object, variable, or expression into another string. 例如,可以将值的值插入 Decimal 字符串中,以单个字符串的形式向用户显示该值:For example, you can insert the value of a Decimal value into a string to display it to the user as a single string:
Decimal pricePerOunce = (Decimal)17.36;
String^ s = String::Format("The current price is {0} per ounce.",
pricePerOunce);
// Result: The current price is 17.36 per ounce.
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0} per ounce.",
pricePerOunce);
Console.WriteLine(s);
// Result: The current price is 17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36d
Dim s As String = String.Format("The current price is {0} per ounce.",
pricePerOunce)
' Result: The current price is 17.36 per ounce.
您可以控制该值的格式:And you can control that value's formatting:
Decimal pricePerOunce = (Decimal)17.36;
String^ s = String::Format("The current price is {0:C2} per ounce.",
pricePerOunce);
// Result if current culture is en-US:
// The current price is $17.36 per ounce.
Decimal pricePerOunce = 17.36m;
String s = String.Format("The current price is {0:C2} per ounce.",
pricePerOunce);
Console.WriteLine(s);
// Result if current culture is en-US:
// The current price is $17.36 per ounce.
Dim pricePerOunce As Decimal = 17.36d
Dim s As String = String.Format("The current price is {0:C2} per ounce.",
pricePerOunce)
' Result if current culture is en-US:
' The current price is $17.36 per ounce.
除了格式设置,还可以控制对齐方式和间距。Besides formatting, you can also control alignment and spacing.
插入字符串Insert a string
String.Format 以格式字符串开头,后跟一个或多个将转换为字符串并在格式字符串中的指定位置插入的对象或表达式。String.Format starts with a format string, followed by one or more objects or expressions that will be converted to strings and inserted at a specified place in the format string. 例如:For example:
Decimal temp = (Decimal)20.4;
String^ s = String::Format("The temperature is {0}°C.", temp);
Console::WriteLine(s);
// Displays 'The temperature is 20.4°C.'
decimal temp = 20.4m;
string s = String.Format("The temperature is {0}°C.", temp);
Console.WriteLine(s);
// Displays 'The temperature is 20.4°C.'
Dim temp As Decimal = 20.4d
Dim s As String = String.Format("The temperature is {0}°C.", temp)
Console.WriteLine(s)
' Displays 'The temperature is 20.4°C.'
{0}
格式字符串中的是格式项。The {0}
in the format string is a format item. 0
对象的索引,该对象的字符串值将在该位置插入。0
is the index of the object whose string value will be inserted at that position. (索引从0开始 ) 。如果要插入的对象不是字符串,则调用它的方法将其 ToString
转换为一个字符串,然后再将其插入到结果字符串中。(Indexes start at 0.) If the object to be inserted is not a string, its ToString
method is called to convert it to one before inserting it in the result string.
下面是使用两个格式项和对象列表中的两个对象的另一个示例:Here's another example that uses two format items and two objects in the object list:
String^ s = String::Format("At {0}, the temperature is {1}°C.",
DateTime::Now, 20.4);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
string s = String.Format("At {0}, the temperature is {1}°C.",
DateTime.Now, 20.4);
Console.WriteLine(s);
// Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
Dim s As String = String.Format("At {0}, the temperature is {1}°C.",
Date.Now, 20.4)
' Output similar to: 'At 4/10/2015 9:29:41 AM, the temperature is 20.4°C.'
只要每个格式项的索引在对象列表中都有匹配的对象,就可以拥有任意数量的格式项以及对象列表中的任意多个对象。You can have as many format items and as many objects in the object list as you want, as long as the index of every format item has a matching object in the object list. 您也不必担心您调用的是哪个重载;编译器将为您选择合适的一个。You also don't have to worry about which overload you call; the compiler will select the appropriate one for you.
控件格式设置Control formatting
可以在格式项中的索引后跟格式字符串,以控制如何设置对象的格式。You can follow the index in a format item with a format string to control how an object is formatted. 例如, {0:d}
将 "d" 格式字符串应用于对象列表中的第一个对象。For example, {0:d}
applies the "d" format string to the first object in the object list. 下面是一个包含单个对象和两个格式项的示例:Here is an example with a single object and two format items:
String^ s = String::Format("It is now {0:d} at {0:t}",
DateTime::Now);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
string s = String.Format("It is now {0:d} at {0:t}", DateTime.Now);
Console.WriteLine(s);
// Output similar to: 'It is now 4/10/2015 at 10:04 AM'
Dim s As String = String.Format("It is now {0:d} at {0:t}",
Date.Now)
' Output similar to: 'It is now 4/10/2015 at 10:04 AM'
许多类型都支持格式字符串,其中包括标准和自定义格式字符串 (的所有数字类型) 、标准和自定义格式字符串) (的所有日期和时间均为标准和自定义格式字符串 (、所有枚举类型枚举类型以及guid。A number of types support format strings, including all numeric types (both standard and custom format strings), all dates and times (both standard and custom format strings) and time intervals (both standard and custom format strings), all enumeration types enumeration types, and GUIDs. 您还可以将对格式字符串的支持添加到您自己的类型中。You can also add support for format strings to your own types.
控件间距Control spacing
您可以通过使用诸如的语法( {0,12}
插入12个字符的字符串)来定义插入到结果字符串中的字符串的宽度。You can define the width of the string that is inserted into the result string by using syntax such as {0,12}
, which inserts a 12-character string. 在这种情况下,第一个对象的字符串表示形式在12个字符的字段中右对齐。In this case, the string representation of the first object is right-aligned in the 12-character field. (如果第一个对象的字符串表示形式的长度超过12个字符,则将忽略首选字段宽度,并将整个字符串插入到结果字符串中。 ) (If the string representation of the first object is more than 12 characters in length, though, the preferred field width is ignored, and the entire string is inserted into the result string.)
下面的示例定义了一个包含字符串 "Year" 和一些年份字符串的6字符字段,以及一个包含字符串 "人口" 和一些人口数据的15个字符的字段。The following example defines a 6-character field to hold the string "Year" and some year strings, as well as an 15-character field to hold the string "Population" and some population data. 请注意,字符在字段中右对齐。Note that the characters are right-aligned in the field.
array<int>^ years = { 2013, 2014, 2015 };
array<int>^ population = { 1025632, 1105967, 1148203 };
StringBuiler^ sb = gcnew StringBuilder();
sb->Append(String::Format("{0,6} {1,15}\n\n", "Year", "Population"));
for(int index = 0; index < years->Length; index++)
sb->AppendFormat("{0,6} {1,15:N0}\n",
years[index], population[index]);
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
var sb = new System.Text.StringBuilder();
sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population"));
for (int index = 0; index < years.Length; index++)
sb.Append(String.Format("{0,6} {1,15:N0}\n", years[index], population[index]));
Console.WriteLine(sb);
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
Dim years() As Integer = { 2013, 2014, 2015 }
Dim population() As Integer = { 1025632, 1105967, 1148203 }
Dim sb As New StringBuilder()
sb.Append(String.Format("{0,6} {1,15}{2}{2}",
"Year", "Population", vbCrLf))
For index As Integer = 0 To years.Length - 1
sb.AppendFormat("{0,6} {1,15:N0}{2}",
years(index), population(index), vbCrLf)
Next
' Result:
' Year Population
'
' 2013 1,025,632
' 2014 1,105,967
' 2015 1,148,203
控件对齐Control alignment
默认情况下,如果指定字段宽度,则字符串在其字段内右对齐。By default, strings are right-aligned within their field if you specify a field width. 若要在字段中左对齐字符串,请在字段宽度前面加上负号,如 {0,-12}
定义12个字符左对齐字段。To left-align strings in a field, you preface the field width with a negative sign, such as {0,-12}
to define a 12-character left-aligned field.
下面的示例与上一个示例类似,不同之处在于它会将标签和数据保持一致。The following example is similar to the previous one, except that it left-aligns both labels and data.
array<int>^ years = { 2013, 2014, 2015 };
array<int>^ population = { 1025632, 1105967, 1148203 };
String^ s = String::Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for(int index = 0; index < years->Length; index++)
s += String::Format("{0,-10} {1,-10:N0}\n",
years[index], population[index]);
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
int[] years = { 2013, 2014, 2015 };
int[] population = { 1025632, 1105967, 1148203 };
String s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population");
for(int index = 0; index < years.Length; index++)
s += String.Format("{0,-10} {1,-10:N0}\n",
years[index], population[index]);
Console.WriteLine($"\n{s}");
// Result:
// Year Population
//
// 2013 1,025,632
// 2014 1,105,967
// 2015 1,148,203
Dim years() As Integer = { 2013, 2014, 2015 }
Dim population() As Integer = { 1025632, 1105967, 1148203 }
Dim s As String = String.Format("{0,-10} {1,-10}{2}{2}",
"Year", "Population", vbCrLf)
For index As Integer = 0 To years.Length - 1
s += String.Format("{0,-10} {1,-10:N0}{2}",
years(index), population(index), vbCrLf)
Next
' Result:
' Year Population
'
' 2013 1,025,632
' 2014 1,105,967
' 2015 1,148,203
String.Format 使用复合格式设置功能。String.Format makes use of the composite formatting feature. 有关更多信息,请参见复合格式设置。For more information, see Composite Formatting.
我要调用哪种方法?Which method do I call?
功能To | 调用Call |
---|---|
使用当前区域性的约定设置一个或多个对象的格式。Format one or more objects by using the conventions of the current culture. | 除了包含参数的重载以外 provider ,其余 Format 重载包含一个参数, String 后跟一个或多个对象参数。Except for the overloads that include a provider parameter, the remaining Format overloads include a String parameter followed by one or more object parameters. 因此,不必确定要 Format 调用的重载。Because of this, you don't have to determine which Format overload you intend to call. 根据参数列表,语言编译器会从没有参数的重载中选择相应的重载 provider 。Your language compiler selects the appropriate overload from among the overloads that don't have a provider parameter, based on your argument list. 例如,如果参数列表具有五个参数,则编译器将调用 Format(String, Object[]) 方法。For example, if your argument list has five arguments, the compiler calls the Format(String, Object[]) method. |
通过使用特定区域性的约定来设置一个或多个对象的格式。Format one or more objects by using the conventions of a specific culture. | 以 Format 参数开头的每个重载 provider 后跟一个 String 参数和一个或多个对象参数。Each Format overload that begins with a provider parameter is followed by a String parameter and one or more object parameters. 因此,不必确定要调用的特定 Format 重载。Because of this, you don't have to determine which specific Format overload you intend to call. 语言编译器根据参数列表,从具有参数的重载中选择适当的重载 provider 。Your language compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list. 例如,如果参数列表具有五个参数,则编译器将调用 Format(IFormatProvider, String, Object[]) 方法。For example, if your argument list has five arguments, the compiler calls the Format(IFormatProvider, String, Object[]) method. |
使用实现或实现执行自定义格式设置操作 ICustomFormatter IFormattable 。Perform a custom formatting operation either with an ICustomFormatter implementation or an IFormattable implementation. | 四个具有参数的重载中的任何一个 provider 。Any of the four overloads with a provider parameter. 编译器根据参数列表,从具有参数的重载中选择适当的重载 provider 。The compiler selects the appropriate overload from among the overloads that have a provider parameter, based on your argument list. |
Format 方法 briefThe Format method in brief
该方法的每个重载都 Format 使用 复合格式设置功能 ,以复合格式字符串形式包含从零开始的索引占位符(称为 格式项)。Each overload of the Format method uses the composite formatting feature to include zero-based indexed placeholders, called format items, in a composite format string. 在运行时,每个格式项都替换为参数列表中相应参数的字符串表示形式。At run time, each format item is replaced with the string representation of the corresponding argument in a parameter list. 如果参数的值为,则 null
将格式项替换为 String.Empty 。If the value of the argument is null
, the format item is replaced with String.Empty. 例如,以下对方法的调用 Format(String, Object, Object, Object) 包含一个格式字符串,其中包含三个格式项、、 {0} {1} 和 {2} ,以及包含三个项的参数列表。For example, the following call to the Format(String, Object, Object, Object) method includes a format string with three format items, {0}, {1}, and {2}, and an argument list with three items.
using namespace System;
void main()
{
DateTime^ dat = gcnew DateTime(2012, 1, 17, 9, 30, 0);
String^ city = "Chicago";
int temp = -16;
String^ output = String::Format("At {0} in {1}, the temperature was {2} degrees.",
dat, city, temp);
Console::WriteLine(output);
}
// The example displays the following output:
// At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
DateTime dat = new DateTime(2012, 1, 17, 9, 30, 0);
string city = "Chicago";
int temp = -16;
string output = String.Format("At {0} in {1}, the temperature was {2} degrees.",
dat, city, temp);
Console.WriteLine(output);
// The example displays output like the following:
// At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
Dim dat As Date = #1/17/2012 9:30AM#
Dim city As String = "Chicago"
Dim temp As Integer = -16
Dim output As String = String.Format("At {0} in {1}, the temperature was {2} degrees.",
dat, city, temp)
Console.WriteLine(output)
' The example displays the following output:
' At 1/17/2012 9:30:00 AM in Chicago, the temperature was -16 degrees.
格式项The format item
格式项具有以下语法:A format item has this syntax:
{index[,alignment][:formatString]}
方括号表示可选元素。Brackets denote optional elements. 需要左大括号和右大括号。The opening and closing braces are required. (在格式字符串中包含文本左大括号或右大括号,请参阅复合格式设置一文中的转义大括号部分。 ) (To include a literal opening or closing brace in the format string, see the Escaping Braces section in the Composite Formatting article.)
例如,设置货币值格式的格式项可能如下所示:For example, a format item to format a currency value might appear like this:
String::Format("{0,-10:C}", (Decimal) 126347.89);
var value = String.Format("{0,-10:C}", 126347.89m);
Console.WriteLine(value);
String.Format("{0,-10:C}", 126347.89d)
格式项包含以下元素:A format item has the following elements:
indexindex
自变量的从零开始的索引,其字符串表示形式将包含在字符串中的此位置。The zero-based index of the argument whose string representation is to be included at this position in the string. 如果此参数为 null
,则字符串中此位置将包含空字符串。If this argument is null
, an empty string will be included at this position in the string.
关联alignment
可选。Optional. 一个有符号整数,它指示要插入自变量的字段的总长度,并指定该参数是右对齐的, (是正整数) 还是) 负整数 (左对齐。A signed integer that indicates the total length of the field into which the argument is inserted and whether it is right-aligned (a positive integer) or left-aligned (a negative integer). 如果省略 对齐方式,则会在不带前导空格或尾随空格的字段中插入相应参数的字符串表示形式。If you omit alignment, the string representation of the corresponding argument is inserted in a field with no leading or trailing spaces.
如果 对齐 值小于要插入的参数的长度,则将忽略 对齐 ,并使用参数的字符串表示形式的长度作为字段宽度。If the value of alignment is less than the length of the argument to be inserted, alignment is ignored and the length of the string representation of the argument is used as the field width.
说明符formatString
可选。Optional. 一个字符串,指定相应参数的结果字符串的格式。A string that specifies the format of the corresponding argument's result string. 如果省略 格式说明符,则将调用相应的参数的无参数 ToString
方法,以生成其字符串表示形式。If you omit formatString, the corresponding argument's parameterless ToString
method is called to produce its string representation. 如果指定格式 字符串,则该格式项引用的参数必须实现 IFormattable 接口。If you specify formatString, the argument referenced by the format item must implement the IFormattable interface. 支持格式字符串的类型包括:Types that support format strings include:
所有整型和浮点类型。All integral and floating-point types. (参见 标准数字格式字符串 和 自定义数字格式字符串。 ) (See Standard Numeric Format Strings and Custom Numeric Format Strings.)
DateTime 和 DateTimeOffset。DateTime and DateTimeOffset. (参见 标准日期和时间格式字符串 和 自定义日期和时间格式字符串。 ) (See Standard Date and Time Format Strings and Custom Date and Time Format Strings.)
所有枚举类型。All enumeration types. (参见 枚举格式字符串。 ) (See Enumeration Format Strings.)
TimeSpan 值。TimeSpan values. (参见 标准 Timespan 格式字符串 和 自定义时间跨度格式字符串。 ) (See Standard TimeSpan Format Strings and Custom TimeSpan Format Strings.)
GUID。GUIDs. (参见 Guid.ToString(String) 方法。 ) (See the Guid.ToString(String) method.)
但请注意,任何自定义类型都可以实现 IFormattable 或扩展现有类型的 IFormattable 实现。However, note that any custom type can implement IFormattable or extend an existing type's IFormattable implementation.
下面的示例使用 alignment
和 formatString
参数来生成格式化的输出。The following example uses the alignment
and formatString
arguments to produce formatted output.
using namespace System;
void main()
{
// Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
array<Tuple<String^, DateTime, int, DateTime, int>^>^ cities = gcnew array<Tuple<String^, DateTime, int, DateTime, int>^>
{ gcnew Tuple<String^, DateTime, int, DateTime, int>("Los Angeles", DateTime(1940, 1, 1), 1504277,
DateTime(1950, 1, 1), 1970358),
gcnew Tuple<String^, DateTime, int, DateTime, int>("New York", DateTime(1940, 1, 1), 7454995,
DateTime(1950, 1, 1), 7891957),
gcnew Tuple<String^, DateTime, int, DateTime, int>("Chicago", DateTime(1940, 1, 1), 3396808,
DateTime(1950, 1, 1), 3620962),
gcnew Tuple<String^, DateTime, int, DateTime, int>("Detroit", DateTime(1940, 1, 1), 1623452,
DateTime(1950, 1, 1), 1849568) };
// Display header
String^ header = String::Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
"City", "Year", "Population", "Change (%)");
Console::WriteLine(header);
String^ output;
for each (Tuple<String^, DateTime, int, DateTime, int>^ city in cities) {
output = String::Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
city->Item1, city->Item2, city->Item3, city->Item4, city->Item5,
(city->Item5 - city->Item3)/ (double)city->Item3);
Console::WriteLine(output);
}
}
// The example displays the following output:
// City Year Population Year Population Change (%)
//
// Los Angeles 1940 1,504,277 1950 1,970,358 31.0 %
// New York 1940 7,454,995 1950 7,891,957 5.9 %
// Chicago 1940 3,396,808 1950 3,620,962 6.6 %
// Detroit 1940 1,623,452 1950 1,849,568 13.9 %
// Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
Tuple<string, DateTime, int, DateTime, int>[] cities =
{ Tuple.Create("Los Angeles", new DateTime(1940, 1, 1), 1504277,
new DateTime(1950, 1, 1), 1970358),
Tuple.Create("New York", new DateTime(1940, 1, 1), 7454995,
new DateTime(1950, 1, 1), 7891957),
Tuple.Create("Chicago", new DateTime(1940, 1, 1), 3396808,
new DateTime(1950, 1, 1), 3620962),
Tuple.Create("Detroit", new DateTime(1940, 1, 1), 1623452,
new DateTime(1950, 1, 1), 1849568) };
// Display header
var header = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n",
"City", "Year", "Population", "Change (%)");
Console.WriteLine(header);
foreach (var city in cities) {
var output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
(city.Item5 - city.Item3)/ (double)city.Item3);
Console.WriteLine(output);
}
// The example displays the following output:
// City Year Population Year Population Change (%)
//
// Los Angeles 1940 1,504,277 1950 1,970,358 31.0 %
// New York 1940 7,454,995 1950 7,891,957 5.9 %
// Chicago 1940 3,396,808 1950 3,620,962 6.6 %
// Detroit 1940 1,623,452 1950 1,849,568 13.9 %
Module Example
Public Sub Main()
' Create array of 5-tuples with population data for three U.S. cities, 1940-1950.
Dim cities() = _
{ Tuple.Create("Los Angeles", #1/1/1940#, 1504277, #1/1/1950#, 1970358),
Tuple.Create("New York", #1/1/1940#, 7454995, #1/1/1950#, 7891957),
Tuple.Create("Chicago", #1/1/1940#, 3396808, #1/1/1950#, 3620962),
Tuple.Create("Detroit", #1/1/1940#, 1623452, #1/1/1950#, 1849568) }
' Display header
Dim header As String = String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}",
"City", "Year", "Population", "Change (%)")
Console.WriteLine(header)
Console.WriteLine()
For Each city In cities
Dim output = String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
city.Item1, city.Item2, city.Item3, city.Item4, city.Item5,
(city.Item5 - city.Item3)/city.Item3)
Console.WriteLine(output)
Next
End Sub
End Module
' The example displays the following output:
' City Year Population Year Population Change (%)
'
' Los Angeles 1940 1,504,277 1950 1,970,358 31.0 %
' New York 1940 7,454,995 1950 7,891,957 5.9 %
' Chicago 1940 3,396,808 1950 3,620,962 6.6 %
' Detroit 1940 1,623,452 1950 1,849,568 13.9 %
如何设置参数的格式How arguments are formatted
格式项从字符串的开头按顺序处理。Format items are processed sequentially from the beginning of the string. 每个格式项都具有与方法的参数列表中的对象相对应的索引。Each format item has an index that corresponds to an object in the method's argument list. Format方法检索参数并按如下方式派生其字符串表示形式:The Format method retrieves the argument and derives its string representation as follows:
如果参数为
null
,则该方法将插入 String.Empty 到结果字符串中。If the argument isnull
, the method inserts String.Empty into the result string. 不必担心如何处理 NullReferenceException null 参数。You don't have to be concerned with handling a NullReferenceException for null arguments.如果调用 Format(IFormatProvider, String, Object[]) 重载并且
provider
对象的 IFormatProvider.GetFormat 实现返回非 null ICustomFormatter 实现,则会将参数传递给其 ICustomFormatter.Format(String, Object, IFormatProvider) 方法。If you call the Format(IFormatProvider, String, Object[]) overload and theprovider
object's IFormatProvider.GetFormat implementation returns a non-null ICustomFormatter implementation, the argument is passed to its ICustomFormatter.Format(String, Object, IFormatProvider) method. 如果格式项包含格式 字符串 参数,则它将作为第一个参数传递给方法。If the format item includes a formatString argument, it is passed as the first argument to the method. 如果 ICustomFormatter 实现可用并且产生一个非空字符串,则返回该字符串作为参数的字符串表示形式; 否则,将执行下一步。If the ICustomFormatter implementation is available and produces a non-null string, that string is returned as the string representation of the argument; otherwise, the next step executes.如果参数实现 IFormattable 接口, IFormattable.ToString 则调用其实现。If the argument implements the IFormattable interface, its IFormattable.ToString implementation is called.
调用了自变量的无参数
ToString
方法,该方法可重写或继承基类实现。The argument's parameterlessToString
method, which either overrides or inherits from a base class implementation, is called.
有关截获对方法的调用, ICustomFormatter.Format 并允许你查看 Format 方法为复合格式字符串中的每个格式项传递到格式设置方法的信息,请参阅 示例:截获提供程序和罗马数字格式化程序。For an example that intercepts calls to the ICustomFormatter.Format method and allows you to see what information the Format method passes to a formatting method for each format item in a composite format string, see Example: An intercept provider and Roman numeral formatter.
有关详细信息,请参阅复合格式设置一文中的 "处理顺序" 部分。For more information, see the Processing Order section in the Composite Formatting article.
设置具有相同索引的项的格式Format items that have the same index
Format FormatException 如果索引项的索引大于或等于参数列表中的参数数目,则该方法将引发异常。The Format method throws a FormatException exception if the index of an index item is greater than or equal to the number of arguments in the argument list. 但是, format
只要多个格式项具有相同的索引,就可以包含比参数更多的格式项。However, format
can include more format items than there are arguments, as long as multiple format items have the same index. 在以下示例中,对方法的调用中 Format(String, Object) ,参数列表具有单个参数,但格式字符串包含两个格式项:一个显示数字的十进制值,另一个显示其十六进制值。In the call to the Format(String, Object) method in following example, the argument list has a single argument, but the format string includes two format items: one displays the decimal value of a number, and the other displays its hexadecimal value.
short[] values= { Int16.MinValue, -27, 0, 1042, Int16.MaxValue };
Console.WriteLine("{0,10} {1,10}\n", "Decimal", "Hex");
foreach (short value in values)
{
string formatString = String.Format("{0,10:G}: {0,10:X}", value);
Console.WriteLine(formatString);
}
// The example displays the following output:
// Decimal Hex
//
// -32768: 8000
// -27: FFE5
// 0: 0
// 1042: 412
// 32767: 7FFF
Module Example
Public Sub Main()
Dim values() As Short = { Int16.MinValue, -27, 0, 1042, Int16.MaxValue }
Console.WriteLine("{0,10} {1,10}", "Decimal", "Hex")
Console.WriteLine()
For Each value As Short In values
Dim formatString As String = String.Format("{0,10:G}: {0,10:X}", value)
Console.WriteLine(formatString)
Next
End Sub
End Module
' The example displays the following output:
' Decimal Hex
'
' -32768: 8000
' -27: FFE5
' 0: 0
' 1042: 412
' 32767: 7FFF
格式和区域性Format and culture
通常,使用当前区域性的约定(由属性返回),将参数列表中的对象转换为其字符串表示形式 CultureInfo.CurrentCulture 。Generally, objects in the argument list are converted to their string representations by using the conventions of the current culture, which is returned by the CultureInfo.CurrentCulture property. 可以通过调用包含参数的的重载之一来控制此行为 Format provider
。You can control this behavior by calling one of the overloads of Format that includes a provider
parameter. provider
参数是一个 IFormatProvider 实现,提供用于使格式设置过程适中的自定义和区域性特定的格式设置信息。The provider
parameter is an IFormatProvider implementation that supplies custom and culture-specific formatting information that is used to moderate the formatting process.
此 IFormatProvider 接口具有一个成员, GetFormat 该成员负责返回提供格式设置信息的对象。The IFormatProvider interface has a single member, GetFormat, which is responsible for returning the object that provides formatting information. .NET 具有三种 IFormatProvider 实现,它们提供区域性特定的格式设置:.NET has three IFormatProvider implementations that provide culture-specific formatting:
CultureInfo.CultureInfo. 其 GetFormat 方法返回一个特定于区域性的 NumberFormatInfo 对象,用于设置数值的格式,以及 DateTimeFormatInfo 用于设置日期和时间值格式的区域性特定的对象。Its GetFormat method returns a culture-specific NumberFormatInfo object for formatting numeric values and a culture-specific DateTimeFormatInfo object for formatting date and time values.
DateTimeFormatInfo,它用于日期和时间值的区域性特定格式设置。DateTimeFormatInfo, which is used for culture-specific formatting of date and time values. 其 GetFormat 方法返回自身。Its GetFormat method returns itself.
NumberFormatInfo,它用于指定数值的区域性特定格式。NumberFormatInfo, which is used for culture-specific formatting of numeric values. 其 GetFormat 属性返回自身。Its GetFormat property returns itself.
自定义格式设置操作Custom formatting operations
您还可以调用 Format 具有类型的参数的方法的任何重载 provider
IFormatProvider 来执行自定义格式设置操作。You can also call the any of the overloads of the Format method that have a provider
parameter of type IFormatProvider to perform custom formatting operations. 例如,可以将整数的格式设置为标识号或电话号码。For example, you could format an integer as an identification number or as a telephone number. 若要执行自定义格式设置,你 provider
的参数必须实现 IFormatProvider 和 ICustomFormatter 接口。To perform custom formatting, your provider
argument must implement both the IFormatProvider and ICustomFormatter interfaces. 当向 Format 方法传递 ICustomFormatter 实现作为 provider
参数时, Format 方法将调用其 IFormatProvider.GetFormat 实现并请求类型的对象 ICustomFormatter 。When the Format method is passed an ICustomFormatter implementation as the provider
argument, the Format method calls its IFormatProvider.GetFormat implementation and requests an object of type ICustomFormatter. 然后,它调用返回的 ICustomFormatter 对象的 Format 方法,以设置传递给它的复合字符串中的每个格式项的格式。It then calls the returned ICustomFormatter object's Format method to format each format item in the composite string passed to it.
有关提供自定义格式设置解决方案的详细信息,请参阅 如何:定义和使用自定义数值格式提供程序 和 ICustomFormatter 。For more information about providing custom formatting solutions, see How to: Define and Use Custom Numeric Format Providers and ICustomFormatter. 有关将整数转换为格式化自定义数字的示例,请参阅 示例:自定义格式设置操作。For an example that converts integers to formatted custom numbers, see Example: A custom formatting operation. 有关将无符号字节转换为罗马数字的示例,请参阅 示例:截获提供程序和罗马数字格式化程序。For an example that converts unsigned bytes to Roman numerals, see Example: An intercept provider and Roman numeral formatter.
示例:自定义格式设置操作Example: A custom formatting operation
此示例定义格式提供程序,该提供程序将整数值的格式设置为 x-xxxxx-xx 形式的客户帐户号。This example defines a format provider that formats an integer value as a customer account number in the form x-xxxxx-xx.
using namespace System;
ref class CustomerFormatter : IFormatProvider, ICustomFormatter
{
public:
virtual Object^ GetFormat(Type^ formatType)
{
if (formatType == ICustomFormatter::typeid)
return this;
else
return nullptr;
}
virtual String^ Format(String^ format,
Object^ arg,
IFormatProvider^ formatProvider)
{
if (! this->Equals(formatProvider))
{
return nullptr;
}
else
{
if (String::IsNullOrEmpty(format))
format = "G";
String^ customerString = arg->ToString();
if (customerString->Length < 8)
customerString = customerString->PadLeft(8, '0');
format = format->ToUpper();
if (format == L"G")
return customerString->Substring(0, 1) + "-" +
customerString->Substring(1, 5) + "-" +
customerString->Substring(6);
else if (format == L"S")
return customerString->Substring(0, 1) + "/" +
customerString->Substring(1, 5) + "/" +
customerString->Substring(6);
else if (format == L"P")
return customerString->Substring(0, 1) + "." +
customerString->Substring(1, 5) + "." +
customerString->Substring(6);
else
throw gcnew FormatException(
String::Format("The '{0}' format specifier is not supported.", format));
}
}
};
void main()
{
int acctNumber = 79203159;
Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0}", acctNumber));
Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:G}", acctNumber));
Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:S}", acctNumber));
Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:P}", acctNumber));
try {
Console::WriteLine(String::Format(gcnew CustomerFormatter, "{0:X}", acctNumber));
}
catch (FormatException^ e) {
Console::WriteLine(e->Message);
}
}
// The example displays the following output:
// 7-92031-59
// 7-92031-59
// 7/92031/59
// 7.92031.59
// The 'X' format specifier is not supported.
using System;
public class TestFormatter
{
public static void Main()
{
int acctNumber = 79203159;
Console.WriteLine(String.Format(new CustomerFormatter(), "{0}", acctNumber));
Console.WriteLine(String.Format(new CustomerFormatter(), "{0:G}", acctNumber));
Console.WriteLine(String.Format(new CustomerFormatter(), "{0:S}", acctNumber));
Console.WriteLine(String.Format(new CustomerFormatter(), "{0:P}", acctNumber));
try {
Console.WriteLine(String.Format(new CustomerFormatter(), "{0:X}", acctNumber));
}
catch (FormatException e) {
Console.WriteLine(e.Message);
}
}
}
public class CustomerFormatter : IFormatProvider, ICustomFormatter
{
public object GetFormat(Type formatType)
{
if (formatType == typeof(ICustomFormatter))
return this;
else
return null;
}
public string Format(string format,
object arg,
IFormatProvider formatProvider)
{
if (! this.Equals(formatProvider))
{
return null;
}
else
{
if (String.IsNullOrEmpty(format))
format = "G";
string customerString = arg.ToString();
if (customerString.Length < 8)
customerString = customerString.PadLeft(8, '0');
format = format.ToUpper();
switch (format)
{
case "G":
return customerString.Substring(0, 1) + "-" +
customerString.Substring(1, 5) + "-" +
customerString.Substring(6);
case "S":
return customerString.Substring(0, 1) + "/" +
customerString.Substring(1, 5) + "/" +
customerString.Substring(6);
case "P":
return customerString.Substring(0, 1) + "." +
customerString.Substring(1, 5) + "." +
customerString.Substring(6);
default:
throw new FormatException(
String.Format("The '{0}' format specifier is not supported.", format));
}
}
}
}
// The example displays the following output:
// 7-92031-59
// 7-92031-59
// 7/92031/59
// 7.92031.59
// The 'X' format specifier is not supported.
Module TestFormatter
Public Sub Main()
Dim acctNumber As Integer = 79203159
Console.WriteLine(String.Format(New CustomerFormatter, "{0}", acctNumber))
Console.WriteLine(String.Format(New CustomerFormatter, "{0:G}", acctNumber))
Console.WriteLine(String.Format(New CustomerFormatter, "{0:S}", acctNumber))
Console.WriteLine(String.Format(New CustomerFormatter, "{0:P}", acctNumber))
Try
Console.WriteLine(String.Format(New CustomerFormatter, "{0:X}", acctNumber))
Catch e As FormatException
Console.WriteLine(e.Message)
End Try
End Sub
End Module
Public Class CustomerFormatter : Implements IFormatProvider, ICustomFormatter
Public Function GetFormat(type As Type) As Object _
Implements IFormatProvider.GetFormat
If type Is GetType(ICustomFormatter) Then
Return Me
Else
Return Nothing
End If
End Function
Public Function Format(fmt As String, _
arg As Object, _
formatProvider As IFormatProvider) As String _
Implements ICustomFormatter.Format
If Not Me.Equals(formatProvider) Then
Return Nothing
Else
If String.IsNullOrEmpty(fmt) Then fmt = "G"
Dim customerString As String = arg.ToString()
if customerString.Length < 8 Then _
customerString = customerString.PadLeft(8, "0"c)
Select Case fmt
Case "G"
Return customerString.Substring(0, 1) & "-" & _
customerString.Substring(1, 5) & "-" & _
customerString.Substring(6)
Case "S"
Return customerString.Substring(0, 1) & "/" & _
customerString.Substring(1, 5) & "/" & _
customerString.Substring(6)
Case "P"
Return customerString.Substring(0, 1) & "." & _
customerString.Substring(1, 5) & "." & _
customerString.Substring(6)
Case Else
Throw New FormatException( _
String.Format("The '{0}' format specifier is not supported.", fmt))
End Select
End If
End Function
End Class
' The example displays the following output:
' 7-92031-59
' 7-92031-59
' 7/92031/59
' 7.92031.59
' The 'X' format specifier is not supported.
示例:截距提供程序和罗马数字格式化程序Example: An intercept provider and Roman numeral formatter
此示例定义了一个自定义格式提供程序,该提供程序实现 ICustomFormatter 和 IFormatProvider 接口以执行两项操作:This example defines a custom format provider that implements the ICustomFormatter and IFormatProvider interfaces to do two things:
它将显示传递到其实现的参数 ICustomFormatter.Format 。It displays the parameters passed to its ICustomFormatter.Format implementation. 这使我们能够查看方法将哪些参数 Format(IFormatProvider, String, Object[]) 传递到其尝试设置格式的每个对象的自定义格式设置实现。This enables us to see what parameters the Format(IFormatProvider, String, Object[]) method is passing to the custom formatting implementation for each object that it tries to format. 调试应用程序时,这会很有用。This can be useful when you're debugging your application.
如果要设置格式的对象是要使用 "R" 标准格式字符串设置格式的无符号字节值,则自定义格式化程序将数值的格式设置为罗马数字。If the object to be formatted is an unsigned byte value that is to be formatted by using the "R" standard format string, the custom formatter formats the numeric value as a Roman numeral.
using namespace System;
using namespace System::Globalization;
ref class InterceptProvider : IFormatProvider, ICustomFormatter
{
public:
virtual Object^ GetFormat(Type^ formatType)
{
if (formatType == ICustomFormatter::typeid)
return this;
else
return nullptr;
}
virtual String^ Format(String^ format, Object^ obj, IFormatProvider^ provider)
{
// Display information about method call.
String^ formatString = format != nullptr ? format : "<null>";
Console::WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
provider, obj != nullptr ? obj : "<null>", formatString);
if (obj == nullptr) return String::Empty;
// If this is a byte and the "R" format string, format it with Roman numerals.
if (obj->GetType() == Byte::typeid && formatString->ToUpper()->Equals("R")) {
Byte value = (Byte) obj;
int remainder;
int result;
String^ returnString = String::Empty;
// Get the hundreds digit(s)
result = Math::DivRem(value, 100, remainder);
if (result > 0)
returnString = gcnew String('C', result);
value = (Byte) remainder;
// Get the 50s digit
result = Math::DivRem(value, 50, remainder);
if (result == 1)
returnString += "L";
value = (Byte) remainder;
// Get the tens digit.
result = Math::DivRem(value, 10, remainder);
if (result > 0)
returnString += gcnew String('X', result);
value = (Byte) remainder;
// Get the fives digit.
result = Math::DivRem(value, 5, remainder);
if (result > 0)
returnString += "V";
value = (Byte) remainder;
// Add the ones digit.
if (remainder > 0)
returnString += gcnew String('I', remainder);
// Check whether we have too many X characters.
int pos = returnString->IndexOf("XXXX");
if (pos >= 0) {
int xPos = returnString->IndexOf("L");
if ((xPos >= 0) & (xPos == pos - 1))
returnString = returnString->Replace("LXXXX", "XC");
else
returnString = returnString->Replace("XXXX", "XL");
}
// Check whether we have too many I characters
pos = returnString->IndexOf("IIII");
if (pos >= 0)
if (returnString->IndexOf("V") >= 0)
returnString = returnString->Replace("VIIII", "IX");
else
returnString = returnString->Replace("IIII", "IV");
return returnString;
}
// Use default for all other formatting.
if (obj->GetType() == IFormattable::typeid)
return ((IFormattable^) obj)->ToString(format, CultureInfo::CurrentCulture);
else
return obj->ToString();
}
};
void main()
{
int n = 10;
double value = 16.935;
DateTime day = DateTime::Now;
InterceptProvider^ provider = gcnew InterceptProvider();
Console::WriteLine(String::Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
Console::WriteLine(String::Format(provider, "{0}: {1:F}\n", "Today: ",
(DayOfWeek) DateTime::Now.DayOfWeek));
Console::WriteLine(String::Format(provider, "{0:X}, {1}, {2}\n",
(Byte) 2, (Byte) 12, (Byte) 199));
Console::WriteLine(String::Format(provider, "{0:R}, {1:R}, {2:R}\n",
(Byte) 2, (Byte) 12, (Byte) 199));
}
// The example displays the following output:
// Provider: InterceptProvider, Object: 10, Format String: N0
// Provider: InterceptProvider, Object: 16.935, Format String: C2
// Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
// 10: $16.94 on 1/31/2013
//
// Provider: InterceptProvider, Object: Today: , Format String: <null>
// Provider: InterceptProvider, Object: Thursday, Format String: F
// Today: : Thursday
//
// Provider: InterceptProvider, Object: 2, Format String: X
// Provider: InterceptProvider, Object: 12, Format String: <null>
// Provider: InterceptProvider, Object: 199, Format String: <null>
// 2, 12, 199
//
// Provider: InterceptProvider, Object: 2, Format String: R
// Provider: InterceptProvider, Object: 12, Format String: R
// Provider: InterceptProvider, Object: 199, Format String: R
// II, XII, CXCIX
using System;
using System.Globalization;
public class InterceptProvider : IFormatProvider, ICustomFormatter
{
public object GetFormat(Type formatType)
{
if (formatType == typeof(ICustomFormatter))
return this;
else
return null;
}
public string Format(String format, Object obj, IFormatProvider provider)
{
// Display information about method call.
string formatString = format ?? "<null>";
Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
provider.GetType().Name, obj ?? "<null>", formatString);
if (obj == null) return String.Empty;
// If this is a byte and the "R" format string, format it with Roman numerals.
if (obj is Byte && formatString.ToUpper().Equals("R")) {
Byte value = (Byte) obj;
int remainder;
int result;
String returnString = String.Empty;
// Get the hundreds digit(s)
result = Math.DivRem(value, 100, out remainder);
if (result > 0)
returnString = new String('C', result);
value = (Byte) remainder;
// Get the 50s digit
result = Math.DivRem(value, 50, out remainder);
if (result == 1)
returnString += "L";
value = (Byte) remainder;
// Get the tens digit.
result = Math.DivRem(value, 10, out remainder);
if (result > 0)
returnString += new String('X', result);
value = (Byte) remainder;
// Get the fives digit.
result = Math.DivRem(value, 5, out remainder);
if (result > 0)
returnString += "V";
value = (Byte) remainder;
// Add the ones digit.
if (remainder > 0)
returnString += new String('I', remainder);
// Check whether we have too many X characters.
int pos = returnString.IndexOf("XXXX");
if (pos >= 0) {
int xPos = returnString.IndexOf("L");
if (xPos >= 0 & xPos == pos - 1)
returnString = returnString.Replace("LXXXX", "XC");
else
returnString = returnString.Replace("XXXX", "XL");
}
// Check whether we have too many I characters
pos = returnString.IndexOf("IIII");
if (pos >= 0)
if (returnString.IndexOf("V") >= 0)
returnString = returnString.Replace("VIIII", "IX");
else
returnString = returnString.Replace("IIII", "IV");
return returnString;
}
// Use default for all other formatting.
if (obj is IFormattable)
return ((IFormattable) obj).ToString(format, CultureInfo.CurrentCulture);
else
return obj.ToString();
}
}
public class Example
{
public static void Main()
{
int n = 10;
double value = 16.935;
DateTime day = DateTime.Now;
InterceptProvider provider = new InterceptProvider();
Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day));
Console.WriteLine(String.Format(provider, "{0}: {1:F}\n", "Today: ",
(DayOfWeek) DateTime.Now.DayOfWeek));
Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n",
(Byte) 2, (Byte) 12, (Byte) 199));
Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}\n",
(Byte) 2, (Byte) 12, (Byte) 199));
}
}
// The example displays the following output:
// Provider: InterceptProvider, Object: 10, Format String: N0
// Provider: InterceptProvider, Object: 16.935, Format String: C2
// Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
// 10: $16.94 on 1/31/2013
//
// Provider: InterceptProvider, Object: Today: , Format String: <null>
// Provider: InterceptProvider, Object: Thursday, Format String: F
// Today: : Thursday
//
// Provider: InterceptProvider, Object: 2, Format String: X
// Provider: InterceptProvider, Object: 12, Format String: <null>
// Provider: InterceptProvider, Object: 199, Format String: <null>
// 2, 12, 199
//
// Provider: InterceptProvider, Object: 2, Format String: R
// Provider: InterceptProvider, Object: 12, Format String: R
// Provider: InterceptProvider, Object: 199, Format String: R
// II, XII, CXCIX
Imports System.Globalization
Public Class InterceptProvider : Implements IFormatProvider, ICustomFormatter
Public Function GetFormat(formatType As Type) As Object _
Implements IFormatProvider.GetFormat
If formatType Is GetType(ICustomFormatter) Then
Return Me
Else
Return Nothing
End If
End Function
Public Function Format(fmt As String, obj As Object, provider As IFormatProvider) As String _
Implements ICustomFormatter.Format
Dim formatString As String = If(fmt IsNot Nothing, fmt, "<null>")
Console.WriteLine("Provider: {0}, Object: {1}, Format String: {2}",
provider, If(obj IsNot Nothing, obj, "<null>"), formatString)
If obj Is Nothing Then Return String.Empty
' If this is a byte and the "R" format string, format it with Roman numerals.
If TypeOf(obj) Is Byte AndAlso formatString.ToUpper.Equals("R") Then
Dim value As Byte = CByte(obj)
Dim remainder As Integer
Dim result As Integer
Dim returnString As String = String.Empty
' Get the hundreds digit(s)
result = Math.DivRem(value, 100, remainder)
If result > 0 Then returnString = New String("C"c, result)
value = CByte(remainder)
' Get the 50s digit
result = Math.DivRem(value, 50, remainder)
If result = 1 Then returnString += "L"
value = CByte(remainder)
' Get the tens digit.
result = Math.DivRem(value, 10, remainder)
If result > 0 Then returnString += New String("X"c, result)
value = CByte(remainder)
' Get the fives digit.
result = Math.DivRem(value, 5, remainder)
If result > 0 Then returnString += "V"
value = CByte(remainder)
' Add the ones digit.
If remainder > 0 Then returnString += New String("I"c, remainder)
' Check whether we have too many X characters.
Dim pos As Integer = returnString.IndexOf("XXXX")
If pos >= 0 Then
Dim xPos As Integer = returnString.IndexOf("L")
If xPos >= 0 And xPos = pos - 1 Then
returnString = returnString.Replace("LXXXX", "XC")
Else
returnString = returnString.Replace("XXXX", "XL")
End If
End If
' Check whether we have too many I characters
pos = returnString.IndexOf("IIII")
If pos >= 0 Then
If returnString.IndexOf("V") >= 0 Then
returnString = returnString.Replace("VIIII", "IX")
Else
returnString = returnString.Replace("IIII", "IV")
End If
End If
Return returnString
End If
' Use default for all other formatting.
If obj Is GetType(IFormattable)
Return CType(obj, IFormattable).ToString(fmt, CultureInfo.CurrentCulture)
Else
Return obj.ToString()
End If
End Function
End Class
Module Example
Public Sub Main()
Dim n As Integer = 10
Dim value As Double = 16.935
Dim day As DateTime = Date.Now
Dim provider As New InterceptProvider()
Console.WriteLine(String.Format(provider, "{0:N0}: {1:C2} on {2:d}", n, value, day))
Console.WriteLine()
Console.WriteLine(String.Format(provider, "{0}: {1:F}", "Today",
CType(Date.Now.DayOfWeek, DayOfWeek)))
Console.WriteLine()
Console.WriteLine(String.Format(provider, "{0:X}, {1}, {2}\n",
CByte(2), CByte(12), CByte(199)))
Console.WriteLine()
Console.WriteLine(String.Format(provider, "{0:R}, {1:R}, {2:R}",
CByte(2), CByte(12), CByte(199)))
End Sub
End Module
' The example displays the following output:
' Provider: InterceptProvider, Object: 10, Format String: N0
' Provider: InterceptProvider, Object: 16.935, Format String: C2
' Provider: InterceptProvider, Object: 1/31/2013 6:10:28 PM, Format String: d
' 10: $16.94 on 1/31/2013
'
' Provider: InterceptProvider, Object: Today: , Format String: <null>
' Provider: InterceptProvider, Object: Thursday, Format String: F
' Today: : Thursday
'
' Provider: InterceptProvider, Object: 2, Format String: X
' Provider: InterceptProvider, Object: 12, Format String: <null>
' Provider: InterceptProvider, Object: 199, Format String: <null>
' 2, 12, 199
'
' Provider: InterceptProvider, Object: 2, Format String: R
' Provider: InterceptProvider, Object: 12, Format String: R
' Provider: InterceptProvider, Object: 199, Format String: R
' II, XII, CXCIX
字符串格式 Q &String.Format Q & A
为什么建议通过调用方法来插入字符串 String.Format
?Why do you recommend string interpolation over calls to the String.Format
method?
字符串内插为:String interpolation is:
更灵活。More flexible. 它可用于任何字符串,无需调用支持复合格式设置的方法。It can be used in any string without requiring a call to a method that supports composite formatting. 否则,必须调用 Format 方法或支持复合格式设置的其他方法,如 Console.WriteLine 或 StringBuilder.AppendFormat 。Otherwise, you have to call the Format method or another method that supports composite formatting, such as Console.WriteLine or StringBuilder.AppendFormat.
可读性更强。More readable. 由于插入到字符串中的表达式出现在内插表达式中(而不是自变量列表中),因此,内插字符串的代码和读取更为容易。Because the expression to insert into a string appears in the interpolated expression rather than in a argument list, interpolated strings are far easier to code and to read. 由于其可读性更高,内插字符串不仅可以替换对复合格式方法的调用,还可以在字符串串联操作中使用,以生成更简洁简洁的代码。Because of their greater readability, interpolated strings can replace not only calls to composite format methods, but they can also be used in string concatenation operations to produce more concise, clearer code.
下面两个代码示例的比较说明了经营字符串连接和对复合格式设置方法的调用的内插字符串。A comparison of the following two code examples illustrates the superiority of interpolated strings over string concatenation and calls to composite formatting methods. 在下面的示例中,使用多个字符串串联操作会生成详细的代码和难于阅读的代码。The use of multiple string concatenation operations in the following example produces verbose and hard-to-read code.
string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
string output = names[0] + ", " + names[1] + ", " + names[2] + ", " +
names[3] + ", " + names[4] + ", " + names[5] + ", " +
names[6];
output += "\n";
var date = DateTime.Now;
output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.",
date, date.DayOfWeek);
Console.WriteLine(output);
// The example displays the following output:
// Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
// It is 10:29 AM on 1/8/2018. The day of the week is Monday.
Module Example
Public Sub Main()
Dim names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" }
Dim output = names(0) + ", " + names(1) + ", " + names(2) + ", " +
names(3) + ", " + names(4) + ", " + names(5) + ", " +
names(6)
output += vbCrLf
Dim dat = DateTime.Now
output += String.Format("It is {0:t} on {0:d}. The day of the week is {1}.",
dat, dat.DayOfWeek)
Console.WriteLine(output)
End Sub
End Module
' The example displays the following output:
' Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
' It is 10:29 AM on 1/8/2018. The day of the week is Monday.
与此相反,在下面的示例中使用内插字符串会生成比字符串串联语句更清晰、更简洁的代码,并对 Format 上一示例中的方法进行调用。In contrast, the use of interpolated strings in the following example produce much clearer, more concise code than the string concatenation statement and the call to the Format method in the previous example.
string[] names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" };
string output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, " +
$"{names[5]}, {names[6]}";
var date = DateTime.Now;
output += $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}.";
Console.WriteLine(output);
// The example displays the following output:
// Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
// It is 10:29 AM on 1/8/2018. The day of the week is Monday.
Module Example
Public Sub Main()
Dim names = { "Balto", "Vanya", "Dakota", "Samuel", "Koani", "Yiska", "Yuma" }
Dim output = $"{names(0)}, {names(1)}, {names(2)}, {names(3)}, {names(4)}, " +
$"{names(5)}, {names(6)}"
Dim dat = DateTime.Now
output += $"{vbCrLf}It is {dat:t} on {dat:d}. The day of the week is {dat.DayOfWeek}."
Console.WriteLine(output)
End Sub
End Module
' The example displays the following output:
' Balto, Vanya, Dakota, Samuel, Koani, Yiska, Yuma
' It is 10:29 AM on 1/8/2018. The day of the week is Monday.
在哪里可以找到可用于格式项的预定义格式字符串列表?Where can I find a list of the predefined format strings that can be used with format items?
对于所有整型和浮点类型,请参阅 标准数字格式字符串 和 自定义数字格式字符串。For all integral and floating-point types, see Standard Numeric Format Strings and Custom Numeric Format Strings.
对于日期和时间值,请参阅 标准日期和时间格式字符串 和 自定义日期和时间格式字符串。For date and time values, see Standard Date and Time Format Strings and Custom Date and Time Format Strings.
对于枚举值,请参阅 枚举格式字符串。For enumeration values, see Enumeration Format Strings.
有关 TimeSpan 值,请参阅 标准 Timespan 格式字符串 和 自定义 timespan 格式字符串。For TimeSpan values, see Standard TimeSpan Format Strings and Custom TimeSpan Format Strings.
有关 Guid 值,请参阅引用页的 "备注" 部分 Guid.ToString(String) 。For Guid values, see the Remarks section of the Guid.ToString(String) reference page.
如何实现控制替换格式项的结果字符串的对齐方式吗?How do I control the alignment of the result strings that replace format items?
格式项的一般语法为:The general syntax of a format item is:
{index[,alignment][: formatString]}
其中, 对齐方式 是一个定义字段宽度的带符号整数。where alignment is a signed integer that defines the field width. 如果此值为负数,则字段中的文本为左对齐。If this value is negative, text in the field is left-aligned. 如果为正数,则文本右对齐。If it is positive, text is right-aligned.
如何实现控制小数点分隔符后的位数?How do I control the number of digits after the decimal separator?
除 "D" (之外的所有 标准数字格式字符串 (仅适用于整数) "G"、"R" 和 "X")都允许使用精度说明符定义结果字符串中的小数位数。All standard numeric format strings except "D" (which is used with integers only), "G", "R", and "X" allow a precision specifier that defines the number of decimal digits in the result string. 下面的示例使用标准数字格式字符串来控制结果字符串中的小数位数。The following example uses standard numeric format strings to control the number of decimal digits in the result string.
object[] values = { 1603, 1794.68235, 15436.14 };
string result;
foreach (var value in values) {
result = String.Format("{0,12:C2} {0,12:E3} {0,12:F4} {0,12:N3} {1,12:P2}\n",
Convert.ToDouble(value), Convert.ToDouble(value) / 10000);
Console.WriteLine(result);
}
// The example displays output like the following:
// $1,603.00 1.603E+003 1603.0000 1,603.000 16.03 %
//
// $1,794.68 1.795E+003 1794.6824 1,794.682 17.95 %
//
// $15,436.14 1.544E+004 15436.1400 15,436.140 154.36 %
Module Example
Public Sub Main()
Dim values() As Object = { 1603, 1794.68235, 15436.14 }
Dim result As String
For Each value In values
result = String.Format("{0,12:C2} {0,12:E3} {0,12:F4} {0,12:N3} {1,12:P2}",
value, CDbl(value) / 10000)
Console.WriteLine(result)
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' $1,603.00 1.603E+003 1603.0000 1,603.000 16.03 %
'
' $1,794.68 1.795E+003 1794.6824 1,794.682 17.95 %
'
' $15,436.14 1.544E+004 15436.1400 15,436.140 154.36 %
如果使用的是 自定义数字格式字符串,请使用 "0" 格式说明符控制结果字符串中的小数位数,如下面的示例所示。If you're using a custom numeric format string, use the "0" format specifier to control the number of decimal digits in the result string, as the following example shows.
decimal value = 16309.5436m;
string result = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}",
value);
Console.WriteLine(result);
// The example displays the following output:
// 16309.54360 16,309.54 16309.544
Module Example
Public Sub Main()
Dim value As Decimal = 16309.5436d
Dim result As String = String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}",
value)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 16309.54360 16,309.54 16309.544
如何实现控制整数位数?How do I control the number of integral digits?
默认情况下,格式设置操作仅显示非零整数位数。By default, formatting operations only display non-zero integral digits. 如果要设置整数格式,则可以使用带有 "D" 和 "X" 标准格式字符串的精度说明符来控制数字的位数。If you are formatting integers, you can use a precision specifier with the "D" and "X" standard format strings to control the number of digits.
int value = 1326;
string result = String.Format("{0,10:D6} {0,10:X8}", value);
Console.WriteLine(result);
// The example displays the following output:
// 001326 0000052E
Module Example
Public Sub Main()
Dim value As Integer = 1326
Dim result As String = String.Format("{0,10:D6} {0,10:X8}", value)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 001326 0000052E
可以通过使用 "0" 自定义数值格式说明符,使用前导零填充整数或浮点数,以生成具有指定数量整数位数的结果字符串,如下面的示例所示。You can pad an integer or floating-point number with leading zeros to produce a result string with a specified number of integral digits by using the "0" custom numeric format specifier, as the following example shows.
int value = 16342;
string result = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}",
value);
Console.WriteLine(result);
// The example displays the following output:
// 00016342 00016342.000 0,000,016,342.0
Module Example
Public Sub Main()
Dim value As Integer = 16342
Dim result As String = String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}",
value)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 00016342 00016342.000 0,000,016,342.0
可以在 "格式" 列表中包含多少项?How many items can I include in the format list?
没有实际限制。There is no practical limit. 方法的第二个参数 Format(IFormatProvider, String, Object[]) 使用特性进行标记 ParamArrayAttribute ,这允许您将分隔的列表或对象数组作为格式列表包括在内。The second parameter of the Format(IFormatProvider, String, Object[]) method is tagged with the ParamArrayAttribute attribute, which allows you to include either a delimited list or an object array as your format list.
如何实现在结果字符串中包含 "{" 和 "}" ( 文本大括号 ) How do I include literal braces ("{" and "}") in the result string?
例如,如何防止下面的方法调用引发 FormatException 异常?For example, how do you prevent the following method call from throwing a FormatException exception?
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
nOpen, nClose);
result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
nOpen, nClose)
单个左大括号或右大括号始终解释为格式项的开头或结尾。A single opening or closing brace is always interpreted as the beginning or end of a format item. 若要按原义解释,则必须对其进行转义。To be interpreted literally, it must be escaped. 通过添加另一个大括号 ( "{{" 和 "}}" 而不是 "{" 和 "}" ) 来转义大括号,如以下方法调用所示:You escape a brace by adding another brace ("{{" and "}}" instead of "{" and "}"), as in the following method call:
string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
nOpen, nClose);
Console.WriteLine(result);
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
nOpen, nClose)
不过,甚至可以轻松地误解转义大括号。However, even escaped braces are easily misinterpreted. 建议在格式列表中包含大括号,并使用格式项将它们插入到结果字符串中,如下面的示例所示。We recommend that you include braces in the format list and use format items to insert them in the result string, as the following example shows.
string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
nOpen, "{", nClose, "}");
Console.WriteLine(result);
result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
nOpen, "{", nClose, "}")
为什么调用字符串。 Format 方法会引发 FormatException?Why does my call to the String.Format method throw a FormatException?
最常见的原因是,格式项的索引不与 "格式" 列表中的对象相对应。The most common cause of the exception is that the index of a format item doesn't correspond to an object in the format list. 通常,这表示您已 misnumbered 格式项的索引,或者您忘记在 "格式" 列表中包含一个对象。Usually this indicates that you've misnumbered the indexes of format items or you've forgotten to include an object in the format list. 尝试包含非转义的左大括号或右大括号会引发 FormatException 。Attempting to include an unescaped left or right brace character also throws a FormatException. 偶尔,异常是由键入错误引起的;例如,典型的错误是错误地键入了 "[" (左括号) 而不是 "{" (左大括号) 。Occasionally, the exception is the result of a typo; for example, a typical mistake is to mistype "[" (the left bracket) instead of "{" (the left brace).
如果 (IFormatProvider,System.string,system.object [] ) 方法的格式支持参数数组,则我的代码在使用数组时为什么会引发异常?If the Format(System.IFormatProvider,System.String,System.Object[]) method supports parameter arrays, why does my code throw an exception when I use an array?
例如,以下代码将引发 FormatException 异常:For example, the following code throws a FormatException exception:
Random rnd = new Random();
int[] numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++) {
int number = rnd.Next(1001);
numbers[ctr] = number;
total += number;
}
numbers[3] = total;
Console.WriteLine("{0} + {1} + {2} = {3}", numbers);
Imports System.Collections.Generic
Module Example
Public Sub Main()
Dim rnd As New Random()
Dim numbers(3) As Integer
Dim total As Integer = 0
For ctr = 0 To 2
Dim number As Integer = rnd.Next(1001)
numbers(ctr) = number
total += number
Next
numbers(3) = total
Console.WriteLine("{0} + {1} + {2} = {3}", numbers)
End Sub
End Module
这是编译器重载决策的问题。This is a problem of compiler overload resolution. 由于编译器无法将整数数组转换为对象数组,因此它将整数数组视为单个参数,因此它将调用 Format(String, Object) 方法。Because the compiler cannot convert an array of integers to an object array, it treats the integer array as a single argument, so it calls the Format(String, Object) method. 引发此异常的原因是存在四个格式项,但在 "格式" 列表中只有一个项。The exception is thrown because there are four format items but only a single item in the format list.
因为 Visual Basic 和 c # 都不能将整数数组转换为对象数组,所以必须在调用方法之前自行执行转换 Format(String, Object[]) 。Because neither Visual Basic nor C# can convert an integer array to an object array, you have to perform the conversion yourself before calling the Format(String, Object[]) method. 以下示例提供了一个实现。The following example provides one implementation.
Random rnd = new Random();
int[] numbers = new int[4];
int total = 0;
for (int ctr = 0; ctr <= 2; ctr++) {
int number = rnd.Next(1001);
numbers[ctr] = number;
total += number;
}
numbers[3] = total;
object[] values = new object[numbers.Length];
numbers.CopyTo(values, 0);
Console.WriteLine("{0} + {1} + {2} = {3}", values);
Imports System.Collections.Generic
Module Example
Public Sub Main()
Dim rnd As New Random()
Dim numbers(3) As Integer
Dim total As Integer = 0
For ctr = 0 To 2
Dim number As Integer = rnd.Next(1001)
numbers(ctr) = number
total += number
Next
numbers(3) = total
Dim values(numbers.Length - 1) As Object
numbers.CopyTo(values, 0)
Console.WriteLine("{0} + {1} + {2} = {3}", values)
End Sub
End Module
Format(String, Object)
将字符串中的一个或多个格式项替换为指定对象的字符串表示形式。Replaces one or more format items in a string with the string representation of a specified object.
public:
static System::String ^ Format(System::String ^ format, System::Object ^ arg0);
public static string Format (string format, object arg0);
public static string Format (string format, object? arg0);
static member Format : string * obj -> string
Public Shared Function Format (format As String, arg0 As Object) As String
参数
- format
- String
- arg0
- Object
要设置格式的对象。The object to format.
返回
format
的副本,其中的任何格式项均替换为 arg0
的字符串表示形式。A copy of format
in which any format items are replaced by the string representation of arg0
.
例外
format
为 null
。format
is null
.
format
中的格式项无效。The format item in format
is invalid.
- 或 --or-
格式项的索引不为零。The index of a format item is not zero.
注解
重要
可以不调用 String.Format 方法或使用复合格式字符串,而改为使用内插字符串(如果受语言支持的话)******。Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 内插字符串是包含内插表达式的字符串。An interpolated string is a string that contains interpolated expressions. 每个内插表达式都使用表达式的值进行解析,并在分配字符串时包含在结果字符串中。Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 有关详细信息,请参阅字符串内插(C# 参考)和内插字符串(Visual Basic 参考)。For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).
此方法使用 复合格式设置功能 将表达式的值转换为其字符串表示形式,并将该表示形式嵌入到字符串中。This method uses the composite formatting feature to convert the value of an expression to its string representation and to embed that representation in a string.
但是,在调用 String.Format 方法时,不需要关注需要调用的特定重载****。However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 相反,可以借助包括一个或多个格式项的复合格式字符串调用方法。Instead, you can call the method with a composite format string that includes one or more format items. 为每个格式项分配一个数字索引;第一个索引从 0 开始。You assign each format item a numeric index; the first index starts at 0. 除了初始字符串,方法调用拥有的额外参数数应该与其拥有的索引值数相同。In addition to the initial string, your method call should have as many additional arguments as it has index values. 例如,格式项有 0 和 1 两个索引的字符串应该有 2 个参数;索引为 0 到 5 的字符串应该有 6 个参数。For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 然后,你的语言编译器将会将方法调用解析为 String.Format 方法的特定重载****。Your language compiler will then resolve your method call to a particular overload of the String.Format method.
有关使用 String.Format 方法的详细文档,请参阅 String.Format 方法入门和我调用哪个方法?****。For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.
示例:设置单个参数的格式Example: Formatting a single argument
下面的示例使用 Format(String, Object) 方法在字符串中间嵌入单个年龄。The following example uses the Format(String, Object) method to embed an individual's age in the middle of a string.
using namespace System;
void main()
{
DateTime birthdate = DateTime(1993, 7, 28);
array<DateTime>^ dates = gcnew array<DateTime> { DateTime(1993, 8, 16),
DateTime(1994, 7, 28),
DateTime(2000, 10, 16),
DateTime(2003, 7, 27),
DateTime(2007, 5, 27) };
for each (DateTime dateValue in dates)
{
TimeSpan interval = dateValue - birthdate;
// Get the approximate number of years, without accounting for leap years.
int years = ((int)interval.TotalDays) / 365;
// See if adding the number of years exceeds dateValue.
String^ output;
if (birthdate.AddYears(years) <= dateValue) {
output = String::Format("You are now {0} years old.", years);
Console::WriteLine(output);
}
else {
output = String::Format("You are now {0} years old.", years - 1);
Console::WriteLine(output);
}
}
}
// The example displays the following output:
// You are now 0 years old.
// You are now 1 years old.
// You are now 7 years old.
// You are now 9 years old.
// You are now 13 years old.
DateTime birthdate = new DateTime(1993, 7, 28);
DateTime[] dates = { new DateTime(1993, 8, 16),
new DateTime(1994, 7, 28),
new DateTime(2000, 10, 16),
new DateTime(2003, 7, 27),
new DateTime(2007, 5, 27) };
foreach (DateTime dateValue in dates)
{
TimeSpan interval = dateValue - birthdate;
// Get the approximate number of years, without accounting for leap years.
int years = ((int) interval.TotalDays) / 365;
// See if adding the number of years exceeds dateValue.
string output;
if (birthdate.AddYears(years) <= dateValue) {
output = String.Format("You are now {0} years old.", years);
Console.WriteLine(output);
}
else {
output = String.Format("You are now {0} years old.", years - 1);
Console.WriteLine(output);
}
}
// The example displays the following output:
// You are now 0 years old.
// You are now 1 years old.
// You are now 7 years old.
// You are now 9 years old.
// You are now 13 years old.
Module Example
Public Sub Main()
Dim birthdate As Date = #7/28/1993#
Dim dates() As Date = { #9/16/1993#, #7/28/1994#, #10/16/2000#, _
#7/27/2003#, #5/27/2007# }
For Each dateValue As Date In dates
Dim interval As TimeSpan = dateValue - birthdate
' Get the approximate number of years, without accounting for leap years.
Dim years As Integer = CInt(interval.TotalDays) \ 365
' See if adding the number of years exceeds dateValue.
Dim output As String
If birthdate.AddYears(years) <= dateValue Then
output = String.Format("You are now {0} years old.", years)
Console.WriteLine(output)
Else
output = String.Format("You are now {0} years old.", years - 1)
Console.WriteLine(output)
End If
Next
End Sub
End Module
' The example displays the following output:
' You are now 0 years old.
' You are now 1 years old.
' You are now 7 years old.
' You are now 9 years old.
' You are now 13 years old.
另请参阅
- 设置 .NET 中类型的格式Formatting Types in .NET
- 复合格式设置Composite Formatting
- 标准日期和时间格式字符串Standard Date and Time Format Strings
- 自定义日期和时间格式字符串Custom Date and Time Format Strings
- 标准数字格式字符串Standard Numeric Format Strings
- 自定义数字格式字符串Custom Numeric Format Strings
- 标准 TimeSpan 格式字符串Standard TimeSpan Format Strings
- 自定义的 TimeSpan 格式字符串Custom TimeSpan Format Strings
- 枚举格式字符串Enumeration Format Strings
适用于
Format(String, Object[])
将指定字符串中的格式项替换为指定数组中相应对象的字符串表示形式。Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.
public:
static System::String ^ Format(System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (string format, params object[] args);
public static string Format (string format, params object?[] args);
static member Format : string * obj[] -> string
Public Shared Function Format (format As String, ParamArray args As Object()) As String
参数
- format
- String
- args
- Object[]
一个对象数组,其中包含零个或多个要设置格式的对象。An object array that contains zero or more objects to format.
返回
format
的副本,其中格式项已替换为 args
中相应对象的字符串表示形式。A copy of format
in which the format items have been replaced by the string representation of the corresponding objects in args
.
例外
format
或 args
为 null
。format
or args
is null
.
format
无效。format
is invalid.
- 或 --or-
格式项的索引小于零,或者大于或等于 args
数组的长度。The index of a format item is less than zero, or greater than or equal to the length of the args
array.
注解
重要
可以不调用 String.Format 方法或使用复合格式字符串,而改为使用内插字符串(如果受语言支持的话)******。Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 内插字符串是包含内插表达式的字符串。An interpolated string is a string that contains interpolated expressions. 每个内插表达式都使用表达式的值进行解析,并在分配字符串时包含在结果字符串中。Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 有关详细信息,请参阅字符串内插(C# 参考)和内插字符串(Visual Basic 参考)。For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).
此方法使用 复合格式设置功能 将4个或更多表达式的值转换为它们的字符串表示形式,并将这些表示形式嵌入到字符串中。This method uses the composite formatting feature to convert the value of four or more expressions to their string representations and to embed those representations in a string. 由于 args
参数是用特性标记的 System.ParamArrayAttribute ,因此可以将对象作为单个参数或数组传递给方法 Object 。Since the args
parameter is marked with the System.ParamArrayAttribute attribute, you can pass the objects to the method as individual arguments or as an Object array.
但是,在调用 String.Format 方法时,不需要关注需要调用的特定重载****。However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 相反,可以借助包括一个或多个格式项的复合格式字符串调用方法。Instead, you can call the method with a composite format string that includes one or more format items. 为每个格式项分配一个数字索引;第一个索引从 0 开始。You assign each format item a numeric index; the first index starts at 0. 除了初始字符串,方法调用拥有的额外参数数应该与其拥有的索引值数相同。In addition to the initial string, your method call should have as many additional arguments as it has index values. 例如,格式项有 0 和 1 两个索引的字符串应该有 2 个参数;索引为 0 到 5 的字符串应该有 6 个参数。For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 然后,你的语言编译器将会将方法调用解析为 String.Format 方法的特定重载****。Your language compiler will then resolve your method call to a particular overload of the String.Format method.
有关使用 String.Format 方法的详细文档,请参阅 String.Format 方法入门和我调用哪个方法?****。For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.
示例:格式化三个以上的参数Example: Format more than three arguments
此示例将创建一个字符串,其中包含特定日期的高温和低温度数据。This example creates a string that contains data on the high and low temperature on a particular date. 复合格式字符串在 c # 示例中有五个格式项,在 Visual Basic 示例中有六个格式项。The composite format string has five format items in the C# example and six in the Visual Basic example. 两个格式项定义其对应值的字符串表示形式的宽度,第一个格式项还包括标准日期和时间格式字符串。Two of the format items define the width of their corresponding value's string representation, and the first format item also includes a standard date and time format string.
using namespace System;
void main()
{
DateTime date1 = DateTime(2009, 7, 1);
TimeSpan hiTime = TimeSpan(14, 17, 32);
Decimal hiTemp = (Decimal) 62.1;
TimeSpan loTime = TimeSpan(3, 16, 10);
Decimal loTemp = (Decimal)54.8;
String^ result1 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)",
date1, hiTime, hiTemp, loTime, loTemp);
Console::WriteLine(result1);
Console::WriteLine();
String^ result2 = String::Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)",
gcnew array<Object^> { date1, hiTime, hiTemp, loTime, loTemp });
Console::WriteLine(result2);
}
// The example displays the following output:
// Temperature on 7/1/2009:
// 14:17:32: 62.1 degrees (hi)
// 03:16:10: 54.8 degrees (lo)
// Temperature on 7/1/2009:
// 14:17:32: 62.1 degrees (hi)
// 03:16:10: 54.8 degrees (lo)
DateTime date1 = new DateTime(2009, 7, 1);
TimeSpan hiTime = new TimeSpan(14, 17, 32);
decimal hiTemp = 62.1m;
TimeSpan loTime = new TimeSpan(3, 16, 10);
decimal loTemp = 54.8m;
string result1 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)",
date1, hiTime, hiTemp, loTime, loTemp);
Console.WriteLine(result1);
Console.WriteLine();
string result2 = String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)",
new object[] { date1, hiTime, hiTemp, loTime, loTemp });
Console.WriteLine(result2);
// The example displays output like the following:
// Temperature on 7/1/2009:
// 14:17:32: 62.1 degrees (hi)
// 03:16:10: 54.8 degrees (lo)
// Temperature on 7/1/2009:
// 14:17:32: 62.1 degrees (hi)
// 03:16:10: 54.8 degrees (lo)
Module Example
Public Sub Main()
Dim date1 As Date = #7/1/2009#
Dim hiTime As New TimeSpan(14, 17, 32)
Dim hiTemp As Decimal = 62.1d
Dim loTime As New TimeSpan(3, 16, 10)
Dim loTemp As Decimal = 54.8d
Dim result1 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
date1, hiTime, hiTemp, loTime, loTemp, vbCrLf)
Console.WriteLine(result1)
Console.WriteLine()
Dim result2 As String = String.Format("Temperature on {0:d}:{5}{1,11}: {2} degrees (hi){5}{3,11}: {4} degrees (lo)", _
New Object() { date1, hiTime, hiTemp, loTime, loTemp, vbCrLf })
Console.WriteLine(result2)
End Sub
End Module
' The example displays the following output:
' Temperature on 7/1/2009:
' 14:17:32: 62.1 degrees (hi)
' 03:16:10: 54.8 degrees (lo)
'
' Temperature on 7/1/2009:
' 14:17:32: 62.1 degrees (hi)
' 03:16:10: 54.8 degrees (lo)
还可以传递要格式化为数组而不是参数列表的对象。You can also pass the objects to be formatted as an array rather than as an argument list.
using namespace System;
ref class CityInfo
{
public:
CityInfo(String^ name, int population, Decimal area, int year)
{
this->Name = name;
this->Population = population;
this->Area = area;
this->Year = year;
}
String^ Name;
int Population;
Decimal Area;
int Year;
};
ref class Example
{
public:
static void ShowPopulationData(CityInfo^ city)
{
array<Object^>^ args = gcnew array<Object^> { city->Name, city->Year, city->Population, city->Area };
String^ result = String::Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet",
args);
Console::WriteLine(result);
}
};
void main()
{
CityInfo^ nyc2010 = gcnew CityInfo("New York", 8175133, (Decimal) 302.64, 2010);
Example::ShowPopulationData(nyc2010);
CityInfo^ sea2010 = gcnew CityInfo("Seattle", 608660, (Decimal) 83.94, 2010);
Example::ShowPopulationData(sea2010);
}
// The example displays the following output:
// New York in 2010: Population 8,175,133, Area 302.6 sq. feet
// Seattle in 2010: Population 608,660, Area 83.9 sq. feet
using System;
public class CityInfo
{
public CityInfo(String name, int population, Decimal area, int year)
{
this.Name = name;
this.Population = population;
this.Area = area;
this.Year = year;
}
public readonly String Name;
public readonly int Population;
public readonly Decimal Area;
public readonly int Year;
}
public class Example
{
public static void Main()
{
CityInfo nyc2010 = new CityInfo("New York", 8175133, 302.64m, 2010);
ShowPopulationData(nyc2010);
CityInfo sea2010 = new CityInfo("Seattle", 608660, 83.94m, 2010);
ShowPopulationData(sea2010);
}
private static void ShowPopulationData(CityInfo city)
{
object[] args = { city.Name, city.Year, city.Population, city.Area };
String result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet",
args);
Console.WriteLine(result);
}
}
// The example displays the following output:
// New York in 2010: Population 8,175,133, Area 302.6 sq. feet
// Seattle in 2010: Population 608,660, Area 83.9 sq. feet
Public Class CityInfo
Public Sub New(name As String, population As Integer, area As Decimal, year As Integer)
Me.Name = name
Me.Population = population
Me.Area = area
Me.Year = year
End Sub
Public ReadOnly Name As String
Public ReadOnly Population As Integer
Public ReadOnly Area As Decimal
Public ReadOnly Year As Integer
End Class
Module Example
Public Sub Main()
Dim nyc2010 As New CityInfo("New York", 8175133, 302.64d, 2010)
ShowPopulationData(nyc2010)
Dim sea2010 As New CityInfo("Seattle", 608660, 83.94d, 2010)
ShowPopulationData(sea2010)
End Sub
Private Sub ShowPopulationData(city As CityInfo)
Dim args() As Object = { city.Name, city.Year, city.Population, city.Area }
Dim result = String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", args)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' New York in 2010: Population 8,175,133, Area 302.6 sq. feet
' Seattle in 2010: Population 608,660, Area 83.9 sq. feet
另请参阅
- 设置 .NET 中类型的格式Formatting Types in .NET
- 复合格式设置Composite Formatting
- 标准日期和时间格式字符串Standard Date and Time Format Strings
- 自定义日期和时间格式字符串Custom Date and Time Format Strings
- 标准数字格式字符串Standard Numeric Format Strings
- 自定义数字格式字符串Custom Numeric Format Strings
- 标准 TimeSpan 格式字符串Standard TimeSpan Format Strings
- 自定义的 TimeSpan 格式字符串Custom TimeSpan Format Strings
- 枚举格式字符串Enumeration Format Strings
适用于
Format(IFormatProvider, String, Object)
将指定字符串中的一个或多个格式项替换为对应对象的字符串表示形式。Replaces the format item or items in a specified string with the string representation of the corresponding object. 参数提供区域性特定的格式设置信息。A parameter supplies culture-specific formatting information.
public:
static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0);
public static string Format (IFormatProvider provider, string format, object arg0);
public static string Format (IFormatProvider? provider, string format, object? arg0);
static member Format : IFormatProvider * string * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object) As String
参数
- provider
- IFormatProvider
一个提供区域性特定的格式设置信息的对象。An object that supplies culture-specific formatting information.
- format
- String
- arg0
- Object
要设置格式的对象。The object to format.
返回
format
的副本,其中的一个或多个格式项已替换为 arg0
的字符串表示形式。A copy of format
in which the format item or items have been replaced by the string representation of arg0
.
例外
format
为 null
。format
is null
.
format
无效。format
is invalid.
- 或 --or-
格式项的索引不为零。The index of a format item is not zero.
注解
重要
可以不调用 String.Format 方法或使用复合格式字符串,而改为使用内插字符串(如果受语言支持的话)******。Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 内插字符串是包含内插表达式的字符串。An interpolated string is a string that contains interpolated expressions. 每个内插表达式都使用表达式的值进行解析,并在分配字符串时包含在结果字符串中。Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 有关详细信息,请参阅字符串内插(C# 参考)和内插字符串(Visual Basic 参考)。For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).
此方法使用 复合格式设置功能 将表达式的值转换为其字符串表示形式,并将该表示形式嵌入到字符串中。This method uses the composite formatting feature to convert the value of an expression to its string representation and to embed that representation in a string. 在执行转换时,方法使用区分区域性的格式设置或自定义格式化程序。In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. 方法 arg0
通过调用其 tostring (IFormatProvider) 方法转换为其字符串表示形式; 如果对象的相应格式项包含格式字符串,则通过调用其 Tostring (string,IFormatProvider) 方法来转换为字符串表示形式。The method converts arg0
to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. 如果这些方法不存在,它将调用对象的无参数 ToString 方法。If these methods don't exist, it calls the object's parameterless ToString method.
但是,在调用 String.Format 方法时,不需要关注需要调用的特定重载****。However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 相反,可以使用提供区分区域性或自定义格式设置的对象和包含一个或多个格式项的复合格式字符串来调用此方法。Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. 为每个格式项分配一个数字索引;第一个索引从 0 开始。You assign each format item a numeric index; the first index starts at 0. 除了初始字符串,方法调用拥有的额外参数数应该与其拥有的索引值数相同。In addition to the initial string, your method call should have as many additional arguments as it has index values. 例如,格式项有 0 和 1 两个索引的字符串应该有 2 个参数;索引为 0 到 5 的字符串应该有 6 个参数。For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 然后,你的语言编译器将会将方法调用解析为 String.Format 方法的特定重载****。Your language compiler will then resolve your method call to a particular overload of the String.Format method.
有关使用 String.Format 方法的详细文档,请参阅 String.Format 方法入门和我调用哪个方法?****。For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.
适用于
Format(IFormatProvider, String, Object[])
将字符串中的格式项替换为指定数组中相应对象的字符串表示形式。Replaces the format items in a string with the string representations of corresponding objects in a specified array. 参数提供区域性特定的格式设置信息。A parameter supplies culture-specific formatting information.
public:
static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, ... cli::array <System::Object ^> ^ args);
public static string Format (IFormatProvider provider, string format, params object[] args);
public static string Format (IFormatProvider? provider, string format, params object?[] args);
static member Format : IFormatProvider * string * obj[] -> string
Public Shared Function Format (provider As IFormatProvider, format As String, ParamArray args As Object()) As String
参数
- provider
- IFormatProvider
一个提供区域性特定的格式设置信息的对象。An object that supplies culture-specific formatting information.
- format
- String
- args
- Object[]
一个对象数组,其中包含零个或多个要设置格式的对象。An object array that contains zero or more objects to format.
返回
format
的副本,其中格式项已替换为 args
中相应对象的字符串表示形式。A copy of format
in which the format items have been replaced by the string representation of the corresponding objects in args
.
例外
format
或 args
为 null
。format
or args
is null
.
format
无效。format
is invalid.
- 或 --or-
格式项的索引小于零,或者大于或等于 args
数组的长度。The index of a format item is less than zero, or greater than or equal to the length of the args
array.
注解
重要
可以不调用 String.Format 方法或使用复合格式字符串,而改为使用内插字符串(如果受语言支持的话)******。Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 内插字符串是包含内插表达式的字符串。An interpolated string is a string that contains interpolated expressions. 每个内插表达式都使用表达式的值进行解析,并在分配字符串时包含在结果字符串中。Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 有关详细信息,请参阅字符串内插(C# 参考)和内插字符串(Visual Basic 参考)。For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).
此方法使用 复合格式设置功能 将4个或更多表达式转换为其字符串表示形式,并将这些表示形式嵌入到字符串中。This method uses the composite formatting feature to convert four or more expressions to their string representations and to embed those representations in a string. 在执行转换时,方法使用区分区域性的格式设置或自定义格式化程序。In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. 方法通过调用其 tostring Object (IFormatProvider) 方法来将每个参数转换为其字符串表示形式; 如果对象的相应格式项包含格式字符串,则通过调用其 Tostring (string,IFormatProvider) 方法来将其转换为字符串表示形式。The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. 如果这些方法不存在,它将调用对象的无参数 ToString 方法。If these methods don't exist, it calls the object's parameterless ToString method.
但是,在调用 String.Format 方法时,不需要关注需要调用的特定重载****。However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 相反,可以使用提供区分区域性或自定义格式设置的对象和包含一个或多个格式项的复合格式字符串来调用此方法。Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. 为每个格式项分配一个数字索引;第一个索引从 0 开始。You assign each format item a numeric index; the first index starts at 0. 除了初始字符串,方法调用拥有的额外参数数应该与其拥有的索引值数相同。In addition to the initial string, your method call should have as many additional arguments as it has index values. 例如,格式项有 0 和 1 两个索引的字符串应该有 2 个参数;索引为 0 到 5 的字符串应该有 6 个参数。For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 然后,你的语言编译器将会将方法调用解析为 String.Format 方法的特定重载****。Your language compiler will then resolve your method call to a particular overload of the String.Format method.
有关使用 String.Format 方法的详细文档,请参阅 String.Format 方法入门和我调用哪个方法?****。For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.
示例:区分区域性的格式设置Example: Culture-sensitive formatting
此示例使用 Format(IFormatProvider, String, Object[]) 方法通过使用几个不同的区域性显示某些日期和时间值的字符串表示形式和数值。This example uses the Format(IFormatProvider, String, Object[]) method to display the string representation of some date and time values and numeric values by using several different cultures.
string[] cultureNames = { "en-US", "fr-FR", "de-DE", "es-ES" };
DateTime dateToDisplay = new DateTime(2009, 9, 1, 18, 32, 0);
double value = 9164.32;
Console.WriteLine("Culture Date Value\n");
foreach (string cultureName in cultureNames)
{
System.Globalization.CultureInfo culture = new System.Globalization.CultureInfo(cultureName);
string output = String.Format(culture, "{0,-11} {1,-35:D} {2:N}",
culture.Name, dateToDisplay, value);
Console.WriteLine(output);
}
// The example displays the following output:
// Culture Date Value
//
// en-US Tuesday, September 01, 2009 9,164.32
// fr-FR mardi 1 septembre 2009 9 164,32
// de-DE Dienstag, 1. September 2009 9.164,32
// es-ES martes, 01 de septiembre de 2009 9.164,32
Imports System.Globalization
Module Example
Public Sub Main()
Dim cultureNames() As String = { "en-US", "fr-FR", "de-DE", "es-ES" }
Dim dateToDisplay As Date = #9/1/2009 6:32PM#
Dim value As Double = 9164.32
Console.WriteLine("Culture Date Value")
Console.WriteLine()
For Each cultureName As String In cultureNames
Dim culture As New CultureInfo(cultureName)
Dim output As String = String.Format(culture, "{0,-11} {1,-35:D} {2:N}", _
culture.Name, dateToDisplay, value)
Console.WriteLine(output)
Next
End Sub
End Module
' The example displays the following output:
' Culture Date Value
'
' en-US Tuesday, September 01, 2009 9,164.32
' fr-FR mardi 1 septembre 2009 9 164,32
' de-DE Dienstag, 1. September 2009 9.164,32
' es-ES martes, 01 de septiembre de 2009 9.164,32
另请参阅
- DateTimeFormatInfo
- ICustomFormatter
- IFormatProvider
- NumberFormatInfo
- 设置 .NET 中类型的格式Formatting Types in .NET
- 复合格式设置Composite Formatting
- 标准日期和时间格式字符串Standard Date and Time Format Strings
- 自定义日期和时间格式字符串Custom Date and Time Format Strings
- 标准数字格式字符串Standard Numeric Format Strings
- 自定义数字格式字符串Custom Numeric Format Strings
- 标准 TimeSpan 格式字符串Standard TimeSpan Format Strings
- 自定义的 TimeSpan 格式字符串Custom TimeSpan Format Strings
- 枚举格式字符串Enumeration Format Strings
适用于
Format(String, Object, Object)
将字符串中的格式项替换为两个指定对象的字符串表示形式。Replaces the format items in a string with the string representation of two specified objects.
public:
static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);
public static string Format (string format, object arg0, object arg1);
public static string Format (string format, object? arg0, object? arg1);
static member Format : string * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object) As String
参数
- format
- String
- arg0
- Object
要设置格式的第一个对象。The first object to format.
- arg1
- Object
要设置格式的第二个对象。The second object to format.
返回
format
的副本,其中的格式项替换为 arg0
和 arg1
的字符串表示形式。A copy of format
in which format items are replaced by the string representations of arg0
and arg1
.
例外
format
为 null
。format
is null
.
format
无效。format
is invalid.
- 或 --or-
格式项的索引不为零或一。The index of a format item is not zero or one.
注解
重要
可以不调用 String.Format 方法或使用复合格式字符串,而改为使用内插字符串(如果受语言支持的话)******。Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 内插字符串是包含内插表达式的字符串。An interpolated string is a string that contains interpolated expressions. 每个内插表达式都使用表达式的值进行解析,并在分配字符串时包含在结果字符串中。Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 有关详细信息,请参阅字符串内插(C# 参考)和内插字符串(Visual Basic 参考)。For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).
此方法使用 复合格式设置功能 将两个表达式的值转换为它们的字符串表示形式,并将这些表示形式嵌入到字符串中。This method uses the composite formatting feature to convert the value of two expressions to their string representations and to embed those representations in a string.
但是,在调用 String.Format 方法时,不需要关注需要调用的特定重载****。However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 相反,可以借助包括一个或多个格式项的复合格式字符串调用方法。Instead, you can call the method with a composite format string that includes one or more format items. 为每个格式项分配一个数字索引;第一个索引从 0 开始。You assign each format item a numeric index; the first index starts at 0. 除了初始字符串,方法调用拥有的额外参数数应该与其拥有的索引值数相同。In addition to the initial string, your method call should have as many additional arguments as it has index values. 例如,格式项有 0 和 1 两个索引的字符串应该有 2 个参数;索引为 0 到 5 的字符串应该有 6 个参数。For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 然后,你的语言编译器将会将方法调用解析为 String.Format 方法的特定重载****。Your language compiler will then resolve your method call to a particular overload of the String.Format method.
有关使用 String.Format 方法的详细文档,请参阅 String.Format 方法入门和我调用哪个方法?****。For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.
示例:设置两个参数的格式Example: Format two arguments
此示例使用 Format(String, Object, Object) 方法来显示通用对象中存储的时间和温度数据 Dictionary<TKey,TValue> 。This example uses the Format(String, Object, Object) method to display time and temperature data stored in a generic Dictionary<TKey,TValue> object. 请注意,尽管只有两个要设置格式的对象,但格式字符串具有三个格式项。Note that the format string has three format items, although there are only two objects to format. 这是因为列表中的第一个对象 (日期和时间值) 由两个格式项使用:第一个格式项显示时间,第二个对象显示日期。This is because the first object in the list (a date and time value) is used by two format items: The first format item displays the time, and the second displays the date.
using namespace System;
using namespace System::Collections::Generic;
void main()
{
Dictionary<DateTime, Double>^ temperatureInfo = gcnew Dictionary<DateTime, Double>();
temperatureInfo->Add(DateTime(2010, 6, 1, 14, 0, 0), 87.46);
temperatureInfo->Add(DateTime(2010, 12, 1, 10, 0, 0), 36.81);
Console::WriteLine("Temperature Information:\n");
String^ output;
for each (KeyValuePair<DateTime, Double>^ item in temperatureInfo)
{
output = String::Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}�F",
item->Key, item->Value);
Console::WriteLine(output);
}
}
// The example displays the following output:
// Temperature Information:
//
// Temperature at 2:00 PM on 6/1/2010: 87.5�F
// Temperature at 10:00 AM on 12/1/2010: 36.8�F
Dictionary<DateTime, Double> temperatureInfo = new Dictionary<DateTime, Double>();
temperatureInfo.Add(new DateTime(2010, 6, 1, 14, 0, 0), 87.46);
temperatureInfo.Add(new DateTime(2010, 12, 1, 10, 0, 0), 36.81);
Console.WriteLine("Temperature Information:\n");
string output;
foreach (var item in temperatureInfo)
{
output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F",
item.Key, item.Value);
Console.WriteLine(output);
}
// The example displays output like the following:
// Temperature Information:
//
// Temperature at 2:00 PM on 6/1/2010: 87.5°F
// Temperature at 10:00 AM on 12/1/2010: 36.8°F
Imports System.Collections.Generic
Module Example
Public Sub Main()
Dim temperatureInfo As New Dictionary(Of Date, Double)
temperatureInfo.Add(#6/1/2010 2:00PM#, 87.46)
temperatureInfo.Add(#12/1/2010 10:00AM#, 36.81)
Console.WriteLine("Temperature Information:")
Console.WriteLine()
Dim output As String
For Each item In temperatureInfo
output = String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", _
item.Key, item.Value)
Console.WriteLine(output)
Next
End Sub
End Module
' The example displays the following output:
' Temperature Information:
'
' Temperature at 2:00 PM on 6/1/2010: 87.5°F
' Temperature at 10:00 AM on 12/1/2010: 36.8°F
另请参阅
- 设置 .NET 中类型的格式Formatting Types in .NET
- 复合格式设置Composite Formatting
- 标准日期和时间格式字符串Standard Date and Time Format Strings
- 自定义日期和时间格式字符串Custom Date and Time Format Strings
- 标准数字格式字符串Standard Numeric Format Strings
- 自定义数字格式字符串Custom Numeric Format Strings
- 标准 TimeSpan 格式字符串Standard TimeSpan Format Strings
- 自定义的 TimeSpan 格式字符串Custom TimeSpan Format Strings
- 枚举格式字符串Enumeration Format Strings
适用于
Format(IFormatProvider, String, Object, Object)
将字符串中的格式项替换为两个指定对象的字符串表示形式。Replaces the format items in a string with the string representation of two specified objects. 参数提供区域性特定的格式设置信息。A parameter supplies culture-specific formatting information.
public:
static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1);
public static string Format (IFormatProvider provider, string format, object arg0, object arg1);
public static string Format (IFormatProvider? provider, string format, object? arg0, object? arg1);
static member Format : IFormatProvider * string * obj * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object) As String
参数
- provider
- IFormatProvider
一个提供区域性特定的格式设置信息的对象。An object that supplies culture-specific formatting information.
- format
- String
- arg0
- Object
要设置格式的第一个对象。The first object to format.
- arg1
- Object
要设置格式的第二个对象。The second object to format.
返回
format
的副本,其中的格式项替换为 arg0
和 arg1
的字符串表示形式。A copy of format
in which format items are replaced by the string representations of arg0
and arg1
.
例外
format
为 null
。format
is null
.
format
无效。format
is invalid.
- 或 --or-
格式项的索引不为零或一。The index of a format item is not zero or one.
注解
重要
可以不调用 String.Format 方法或使用复合格式字符串,而改为使用内插字符串(如果受语言支持的话)******。Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 内插字符串是包含内插表达式的字符串。An interpolated string is a string that contains interpolated expressions. 每个内插表达式都使用表达式的值进行解析,并在分配字符串时包含在结果字符串中。Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 有关详细信息,请参阅字符串内插(C# 参考)和内插字符串(Visual Basic 参考)。For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).
此方法使用 复合格式设置功能 将两个表达式转换为其字符串表示形式,并将这些表示形式嵌入字符串。This method uses the composite formatting feature to convert two expressions to their string representations and to embed those representations in a string. 在执行转换时,方法使用区分区域性的格式设置或自定义格式化程序。In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. 方法通过调用其 tostring Object (IFormatProvider) 方法来将每个参数转换为其字符串表示形式; 如果对象的相应格式项包含格式字符串,则通过调用其 Tostring (string,IFormatProvider) 方法来将其转换为字符串表示形式。The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. 如果这些方法不存在,它将调用对象的无参数 ToString 方法。If these methods don't exist, it calls the object's parameterless ToString method.
但是,在调用 String.Format 方法时,不需要关注需要调用的特定重载****。However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 相反,可以使用提供区分区域性或自定义格式设置的对象和包含一个或多个格式项的复合格式字符串来调用此方法。Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. 为每个格式项分配一个数字索引;第一个索引从 0 开始。You assign each format item a numeric index; the first index starts at 0. 除了初始字符串,方法调用拥有的额外参数数应该与其拥有的索引值数相同。In addition to the initial string, your method call should have as many additional arguments as it has index values. 例如,格式项有 0 和 1 两个索引的字符串应该有 2 个参数;索引为 0 到 5 的字符串应该有 6 个参数。For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 然后,你的语言编译器将会将方法调用解析为 String.Format 方法的特定重载****。Your language compiler will then resolve your method call to a particular overload of the String.Format method.
有关使用 String.Format 方法的详细文档,请参阅 String.Format 方法入门和我调用哪个方法?****。For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.
适用于
Format(String, Object, Object, Object)
将字符串中的格式项替换为三个指定对象的字符串表示形式。Replaces the format items in a string with the string representation of three specified objects.
public:
static System::String ^ Format(System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Format (string format, object arg0, object arg1, object arg2);
public static string Format (string format, object? arg0, object? arg1, object? arg2);
static member Format : string * obj * obj * obj -> string
Public Shared Function Format (format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String
参数
- format
- String
- arg0
- Object
要设置格式的第一个对象。The first object to format.
- arg1
- Object
要设置格式的第二个对象。The second object to format.
- arg2
- Object
要设置格式的第三个对象。The third object to format.
返回
format
的副本,其中的格式项已替换为 arg0
、arg1
和 arg2
的字符串表示形式。A copy of format
in which the format items have been replaced by the string representations of arg0
, arg1
, and arg2
.
例外
format
为 null
。format
is null
.
format
无效。format
is invalid.
- 或 --or-
格式项的索引小于零,或者大于二。The index of a format item is less than zero, or greater than two.
注解
重要
可以不调用 String.Format 方法或使用复合格式字符串,而改为使用内插字符串(如果受语言支持的话)******。Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 内插字符串是包含内插表达式的字符串。An interpolated string is a string that contains interpolated expressions. 每个内插表达式都使用表达式的值进行解析,并在分配字符串时包含在结果字符串中。Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 有关详细信息,请参阅字符串内插(C# 参考)和内插字符串(Visual Basic 参考)。For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).
此方法使用 复合格式设置功能 将三个表达式的值转换为其字符串表示形式,并将这些表示形式嵌入到字符串中。This method uses the composite formatting feature to convert the value of three expressions to their string representations and to embed those representations in a string.
但是,在调用 String.Format 方法时,不需要关注需要调用的特定重载****。However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 相反,可以借助包括一个或多个格式项的复合格式字符串调用方法。Instead, you can call the method with a composite format string that includes one or more format items. 为每个格式项分配一个数字索引;第一个索引从 0 开始。You assign each format item a numeric index; the first index starts at 0. 除了初始字符串,方法调用拥有的额外参数数应该与其拥有的索引值数相同。In addition to the initial string, your method call should have as many additional arguments as it has index values. 例如,格式项有 0 和 1 两个索引的字符串应该有 2 个参数;索引为 0 到 5 的字符串应该有 6 个参数。For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 然后,你的语言编译器将会将方法调用解析为 String.Format 方法的特定重载****。Your language compiler will then resolve your method call to a particular overload of the String.Format method.
有关使用 String.Format 方法的详细文档,请参阅 String.Format 方法入门和我调用哪个方法?****。For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.
示例:设置三个参数的格式Example: Format three arguments
此示例使用 Format(String, Object, Object, Object) 方法创建一个字符串,该字符串演示 And
具有两个整数值的布尔运算的结果。This example uses the Format(String, Object, Object, Object) method to create a string that illustrates the result of a Boolean And
operation with two integer values. 请注意,格式字符串包含六个格式项,但该方法在其参数列表中只有三个项,因为每个项都以两种不同的方式进行格式设置。Note that the format string includes six format items, but the method has only three items in its parameter list, because each item is formatted in two different ways.
using namespace System;
void main()
{
String^ formatString = " {0,10} ({0,8:X8})\n" +
"And {1,10} ({1,8:X8})\n" +
" = {2,10} ({2,8:X8})";
int value1 = 16932;
int value2 = 15421;
String^ result = String::Format(formatString,
value1, value2, value1 & value2);
Console::WriteLine(result);
}
// The example displays the following output:
// 16932 (00004224)
// And 15421 (00003C3D)
// = 36 (00000024)
string formatString = " {0,10} ({0,8:X8})\n" +
"And {1,10} ({1,8:X8})\n" +
" = {2,10} ({2,8:X8})";
int value1 = 16932;
int value2 = 15421;
string result = String.Format(formatString,
value1, value2, value1 & value2);
Console.WriteLine(result);
// The example displays the following output:
// 16932 (00004224)
// And 15421 (00003C3D)
// = 36 (00000024)
Public Module Example
Public Sub Main()
Dim formatString As String = " {0,10} ({0,8:X8})" + vbCrLf + _
"And {1,10} ({1,8:X8})" + vbCrLf + _
" = {2,10} ({2,8:X8})"
Dim value1 As Integer = 16932
Dim value2 As Integer = 15421
Dim result As String = String.Format(formatString, _
value1, value2, value1 And value2)
Console.WriteLine(result)
End Sub
End Module
' The example displays the following output:
' 16932 (00004224)
' And 15421 (00003C3D)
' = 36 (00000024)
另请参阅
适用于
Format(IFormatProvider, String, Object, Object, Object)
将字符串中的格式项替换为三个指定对象的字符串表示形式。Replaces the format items in a string with the string representation of three specified objects. 参数提供区域性特定的格式设置信息。An parameter supplies culture-specific formatting information.
public:
static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, System::Object ^ arg0, System::Object ^ arg1, System::Object ^ arg2);
public static string Format (IFormatProvider provider, string format, object arg0, object arg1, object arg2);
public static string Format (IFormatProvider? provider, string format, object? arg0, object? arg1, object? arg2);
static member Format : IFormatProvider * string * obj * obj * obj -> string
Public Shared Function Format (provider As IFormatProvider, format As String, arg0 As Object, arg1 As Object, arg2 As Object) As String
参数
- provider
- IFormatProvider
一个提供区域性特定的格式设置信息的对象。An object that supplies culture-specific formatting information.
- format
- String
- arg0
- Object
要设置格式的第一个对象。The first object to format.
- arg1
- Object
要设置格式的第二个对象。The second object to format.
- arg2
- Object
要设置格式的第三个对象。The third object to format.
返回
format
的副本,其中的格式项已替换为 arg0
、arg1
和 arg2
的字符串表示形式。A copy of format
in which the format items have been replaced by the string representations of arg0
, arg1
, and arg2
.
例外
format
为 null
。format
is null
.
format
无效。format
is invalid.
- 或 --or-
格式项的索引小于零,或者大于二。The index of a format item is less than zero, or greater than two.
注解
重要
可以不调用 String.Format 方法或使用复合格式字符串,而改为使用内插字符串(如果受语言支持的话)******。Instead of calling the String.Format method or using composite format strings, you can use interpolated strings if your language supports them. 内插字符串是包含内插表达式的字符串。An interpolated string is a string that contains interpolated expressions. 每个内插表达式都使用表达式的值进行解析,并在分配字符串时包含在结果字符串中。Each interpolated expression is resolved with the expression's value and included in the result string when the string is assigned. 有关详细信息,请参阅字符串内插(C# 参考)和内插字符串(Visual Basic 参考)。For more information, see String interpolation (C# Reference) and Interpolated Strings (Visual Basic Reference).
此方法使用 复合格式设置功能 将三个表达式转换为其字符串表示形式,并将这些表示形式嵌入字符串。This method uses the composite formatting feature to convert three expressions to their string representations and to embed those representations in a string. 在执行转换时,方法使用区分区域性的格式设置或自定义格式化程序。In performing the conversion, the method uses culture-sensitive formatting or a custom formatter. 方法通过调用其 tostring Object (IFormatProvider) 方法来将每个参数转换为其字符串表示形式; 如果对象的相应格式项包含格式字符串,则通过调用其 Tostring (string,IFormatProvider) 方法来将其转换为字符串表示形式。The method converts each Object argument to its string representation by calling its ToString(IFormatProvider) method or, if the object's corresponding format item includes a format string, by calling its ToString(String,IFormatProvider) method. 如果这些方法不存在,它将调用对象的无参数 ToString 方法。If these methods don't exist, it calls the object's parameterless ToString method.
但是,在调用 String.Format 方法时,不需要关注需要调用的特定重载****。However, when calling the String.Format method, it is not necessary to focus on the particular overload that you want to call. 相反,可以使用提供区分区域性或自定义格式设置的对象和包含一个或多个格式项的复合格式字符串来调用此方法。Instead, you can call the method with an object that provides culture-sensitive or custom formatting and a composite format string that includes one or more format items. 为每个格式项分配一个数字索引;第一个索引从 0 开始。You assign each format item a numeric index; the first index starts at 0. 除了初始字符串,方法调用拥有的额外参数数应该与其拥有的索引值数相同。In addition to the initial string, your method call should have as many additional arguments as it has index values. 例如,格式项有 0 和 1 两个索引的字符串应该有 2 个参数;索引为 0 到 5 的字符串应该有 6 个参数。For example, a string whose format items have indexes of 0 and 1 should have 2 arguments; one with indexes 0 through 5 should have 6 arguments. 然后,你的语言编译器将会将方法调用解析为 String.Format 方法的特定重载****。Your language compiler will then resolve your method call to a particular overload of the String.Format method.
有关使用 String.Format 方法的详细文档,请参阅 String.Format 方法入门和我调用哪个方法?****。For more detailed documentation on using the String.Format method, see Getting started with the String.Format method and Which method do I call?.