String.Format Metod

Definition

Namnområde:: System

Sammansättningar:: mscorlib.dll, System.Runtime.dll

Sammansättningar:: netstandard.dll, System.Runtime.dll

Sammansättning:: System.Runtime.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Konverterar värdet för objekt till strängar baserat på de format som angetts och infogar dem i en annan sträng.

Om du är nybörjare på String.Format metoden kan du läsa Komma igång med metoden String.Format för en snabb översikt.

Överlagringar

Name	Description
Format(IFormatProvider, String, Object, Object, Object)	Ersätter formatobjekten i en sträng med strängrepresentationen av tre angivna objekt. En parameter tillhandahåller kulturspecifik formateringsinformation.
Format(IFormatProvider, String, Object, Object)	Ersätter formatobjekten i en sträng med strängrepresentationen av två angivna objekt. En parameter tillhandahåller kulturspecifik formateringsinformation.
Format(String, Object, Object)	Ersätter formatobjekten i en sträng med strängrepresentationen av två angivna objekt.
Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)	Ersätter formatobjektet eller objekten i en CompositeFormat med strängrepresentationen av motsvarande objekt i det angivna formatet.
Format(IFormatProvider, CompositeFormat, Object[])	Ersätter formatobjektet eller objekten i en CompositeFormat med strängrepresentationen av motsvarande objekt i det angivna formatet.
Format(String, Object, Object, Object)	Ersätter formatobjekten i en sträng med strängrepresentationen av tre angivna objekt.
Format(IFormatProvider, String, Object[])	Ersätter formatobjekten i en sträng med strängrepresentationer av motsvarande objekt i en angiven matris. En parameter tillhandahåller kulturspecifik formateringsinformation.
Format(IFormatProvider, String, Object)	Ersätter formatobjektet eller objekten i en angiven sträng med strängrepresentationen av motsvarande objekt. En parameter tillhandahåller kulturspecifik formateringsinformation.
Format(String, ReadOnlySpan<Object>)	Ersätter formatobjektet i en angiven sträng med strängrepresentationen av ett motsvarande objekt i ett angivet intervall.
Format(String, Object[])	Ersätter formatobjektet i en angiven sträng med strängrepresentationen av ett motsvarande objekt i en angiven matris.
Format(String, Object)	Ersätter ett eller flera formatobjekt i en sträng med strängrepresentationen av ett angivet objekt.
Format(IFormatProvider, String, ReadOnlySpan<Object>)	Ersätter formatobjekten i en sträng med strängrepresentationer av motsvarande objekt i ett angivet intervall. En parameter tillhandahåller kulturspecifik formateringsinformation.
Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2)	Ersätter formatobjektet eller objekten i en CompositeFormat med strängrepresentationen av motsvarande objekt i det angivna formatet.
Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1)	Ersätter formatobjektet eller objekten i en CompositeFormat med strängrepresentationen av motsvarande objekt i det angivna formatet.
Format<TArg0>(IFormatProvider, CompositeFormat, TArg0)	Ersätter formatobjektet eller objekten i en CompositeFormat med strängrepresentationen av motsvarande objekt i det angivna formatet.

Exempel

Flera exempel som anropar Format-metoden finns spridda i den här artikeln. Du kan också ladda ned en fullständig uppsättning String.Format exempel som ingår i ett .NET Core-projekt för C#.

Följande är några av exemplen som ingår i artikeln:

Kom igång med metoden String.Format

Använd String.Format om du behöver infoga värdet för ett objekt, en variabel eller ett uttryck i en annan sträng. Du kan till exempel infoga värdet för ett Decimal värde i en sträng för att visa det för användaren som en enda sträng:

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.

let pricePerOunce = 17.36m
String.Format("The current price is {0} per ounce.", pricePerOunce)
|> printfn "%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.

Och du kan styra värdets formatering:

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.

let pricePerOunce = 17.36m
String.Format("The current price is {0:C2} per ounce.", pricePerOunce)
|> printfn "%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.

Förutom formatering kan du även styra justering och avstånd.

Infoga en sträng

String.Format börjar med en formatsträng följt av ett eller flera objekt eller uttryck som ska konverteras till strängar och infogas på en angiven plats i formatsträngen. Ett exempel:

decimal temp = 20.4m;
string s = String.Format("The temperature is {0}°C.", temp);
Console.WriteLine(s);
// Displays 'The temperature is 20.4°C.'

let temp = 20.4m
String.Format("The temperature is {0}°C.", temp)
|> printfn "%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.'

I formatsträngen är {0} ett formatobjekt. 0 är indexet för det objekt vars strängvärde ska infogas vid den positionen. (Index börjar vid 0.) Om objektet som ska infogas inte är en sträng anropas dess ToString metod för att konvertera det till ett innan det infogas i resultatsträngen.

Här är ett annat exempel som använder två formatobjekt och två objekt i objektlistan:

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.'

String.Format("At {0}, the temperature is {1}°C.", DateTime.Now, 20.4)
|> printfn "%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.'

Du kan ha så många formatobjekt och så många objekt i objektlistan som du vill, så länge indexet för varje formatobjekt har ett matchande objekt i objektlistan. Du behöver heller inte bekymra dig om vilken överlagring du anropar, eftersom kompilatorn kommer att välja lämplig för dig.

Kontrollera formateringen

Du kan följa indexet i ett formatobjekt med en formatsträng för att styra hur ett objekt formateras. Till exempel {0:d} tillämpar formatsträngen "d" på det första objektet i objektlistan. Här är ett exempel med ett enskilt objekt och två formatobjekt:

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'

String.Format("It is now {0:d} at {0:t}", DateTime.Now)
|> printfn "%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'

Många typer stöder formatsträngar, inklusive alla numeriska typer (både standardsträngar och anpassade formatsträngar), alla datum och tider (både standardsträngar och anpassade formatsträngar) och tidsintervall (både standardsträngar och anpassade formatsträngar), alla uppräkningstyper och GUID:er. Du kan också lägga till stöd för formatsträngar i dina egna typer.

Kontrollavstånd

Du kan definiera bredden på strängen som infogas i resultatsträngen med hjälp av syntax som {0,12}, som infogar en sträng med 12 tecken. I det här fallet är strängrepresentationen av det första objektet högerjusterad i fältet med 12 tecken. (Om strängrepresentationen av det första objektet är mer än 12 tecken långt ignoreras dock den önskade fältbredden och hela strängen infogas i resultatsträngen.)

I följande exempel definieras ett fält med 6 tecken som innehåller strängen "Year" och vissa årssträngar, samt ett fält med 15 tecken som innehåller strängen "Population" och vissa populationsdata. Observera att tecknen är högerjusterade i fältet.

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

open System
open System.Text
 
let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let sb = StringBuilder()
sb.Append(String.Format("{0,6} {1,15}\n\n", "Year", "Population")) |> ignore
for i = 0 to years.Length - 1 do
   sb.Append(String.Format("{0,6} {1,15:N0}\n", years[i], population[i])) |> ignore

printfn $"{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

Kontrolljustering

Som standardinställning är strängar högerjusterade i sitt fält om du anger en fältbredd. Om du vill vänsterjustera strängar i ett fält anger du fältbredden med ett negativt tecken, till exempel {0,-12} för att definiera ett vänsterjusterat fält med 12 tecken.

Följande exempel liknar det föregående, förutom att det vänsterjusterar både etiketter och data.

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

let years = [| 2013; 2014; 2015 |]
let population = [| 1025632; 1105967; 1148203 |]
let mutable s = String.Format("{0,-10} {1,-10}\n\n", "Year", "Population")
for i = 0 to years.Length - 1 do
    s <- s + String.Format("{0,-10} {1,-10:N0}\n", years[i], population[i])
printfn $"\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 använder den sammansatta formateringsfunktionen. Mer information finns i Sammansatt formatering.

Vilken metod anropar jag?

Objective	Anropsmetod
Formatera ett eller flera objekt med hjälp av den aktuella kulturens konventioner.	Förutom de överlagringar som innehåller en `provider` parameter innehåller de återstående Format överlagringarna en String parameter följt av en eller flera objektparametrar. På grund av detta behöver du inte avgöra vilken Format överlagring du avser att anropa. Språkkompilatorn väljer lämplig överlagring bland de överlagringar som inte har någon `provider` parameter, baserat på argumentlistan. Om din argumentlista till exempel har fem argument anropar Format(String, Object[]) kompilatorn metoden.
Formatera ett eller flera objekt med hjälp av konventionerna i en specifik kultur.	Varje Format överlagring som börjar med en `provider` parameter följs av en String parameter och en eller flera objektparametrar. På grund av detta behöver du inte avgöra vilken specifik Format överlagring du tänker anropa. Språkkompilatorn väljer lämplig överbelastning bland de överlagringar som har en `provider` parameter baserat på din argumentlista. Om din argumentlista till exempel har fem argument anropar Format(IFormatProvider, String, Object[]) kompilatorn metoden.
Utför en anpassad formateringsåtgärd antingen med en ICustomFormatter implementering eller en IFormattable implementering.	Någon av de fyra överlagringarna som har en `provider`-parameter. Kompilatorn väljer lämplig överlagring bland de överlagringar som har en `provider` parameter baserat på din argumentlista.

Format-metoden i korthet

Varje överlagring av Format-metoden använder sammansatt formateringsfunktion för att inkludera nollbaserade platshållare, kallade formatobjekt, i en sammansatt formatsträng. Vid körning ersätts varje formatobjekt med strängrepresentationen av motsvarande argument i en parameterlista. Om värdet för argumentet är nullersätts formatobjektet med String.Empty. Följande anrop till metoden innehåller till Format(String, Object, Object, Object) exempel en formatsträng med tre formatobjekt, {0}, {1}och {2}och en argumentlista med tre objekt.

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.

open System

let dat = DateTime(2012, 1, 17, 9, 30, 0) 
let city = "Chicago"
let temp = -16
String.Format("At {0} in {1}, the temperature was {2} degrees.", dat, city, temp)
|> printfn "%s"
// 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.

Formatobjektet

Ett formatobjekt har den här syntaxen:

{index[,width][:formatString]}

Klamrar anger valfria element. De inledande och avslutande klammerna krävs. (Om du vill inkludera en inledande eller avslutande klammerparentes bokstavligen i formatsträngen kan du läsa avsnittet Escaping Braces i artikeln Sammansatt formatering.)

Ett formatobjekt för att formatera ett valutavärde kan till exempel se ut så här:

var value = String.Format("{0,-10:C}", 126347.89m);
Console.WriteLine(value);

open System

String.Format("{0,-10:C}", 126347.89m)         
|> printfn "%s"

String.Format("{0,-10:C}", 126347.89D)

Ett formatobjekt har följande element:

index
Det nollbaserade indexet för argumentet vars strängrepresentation ska inkluderas på den här positionen i strängen. Om det här argumentet är nullinkluderas en tom sträng på den här positionen i strängen.

width
Optional. Ett signerat heltal som anger den totala längden på det fält som argumentet infogas i och om det är högerjusterat (ett positivt heltal) eller vänsterjusterat (ett negativt heltal). Om du utelämnar widthinfogas strängrepresentationen av motsvarande argument i ett fält utan inledande eller avslutande blanksteg.

Om värdet width för är mindre än längden på argumentet som ska infogas width ignoreras och längden på strängrepresentationen av argumentet används som fältbredd.

formatString
Optional. En sträng som anger formatet på motsvarande argument resultatsträng. Om du utelämnar formatStringanropas motsvarande arguments parameterlösa ToString metod för att skapa dess strängrepresentation. Om du anger formatStringmåste argumentet som refereras av formatobjektet implementera IFormattable gränssnittet. Typer som stöder formatsträngar är:

Alla integral- och flyttalstyper. (Se Standard numeriska formatsträngar och Anpassade numeriska formatsträngar.)
DateTime och DateTimeOffset. (Se Formatsträngar för standarddatum och tid och anpassade datum- och tidsformatsträngar.)
Alla uppräkningstyper. (Se Uppräkningsformatsträngar.)
TimeSpan värden. (Se Standard TimeSpan-formatsträngar och Anpassade TimeSpan-formatsträngar.)
Guid. (Se Guid.ToString(String) metoden.)

Alla anpassade typer kan dock implementera IFormattable eller utöka implementeringen av en befintlig typ IFormattable .

I följande exempel används argumenten width och formatString för att skapa formaterade utdata.

// 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 %

// Create a list of 5-tuples with population data for three U.S. cities, 1940-1950.
let cities = 
    [ "Los Angeles", DateTime(1940, 1, 1), 1504277, DateTime(1950, 1, 1), 1970358
      "New York", DateTime(1940, 1, 1), 7454995, DateTime(1950, 1, 1), 7891957
      "Chicago", DateTime(1940, 1, 1), 3396808, DateTime(1950, 1, 1), 3620962
      "Detroit", DateTime(1940, 1, 1), 1623452, DateTime(1950, 1, 1), 1849568 ]

// Display header
String.Format("{0,-12}{1,8}{2,12}{1,8}{2,12}{3,14}\n", "City", "Year", "Population", "Change (%)")
|> printfn "%s"

for name, year1, pop1, year2, pop2 in cities do
    String.Format("{0,-12}{1,8:yyyy}{2,12:N0}{3,8:yyyy}{4,12:N0}{5,14:P1}",
                  name, year1, pop1, year2, pop2,
                  double (pop2 - pop1) / double pop1)
    |> printfn "%s"
// 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 Example4
    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 %

Hur formateras argument

Formatobjekt bearbetas sekventiellt från början av strängen. Varje formatobjekt har ett index som motsvarar ett objekt i metodens argumentlista. Metoden Format hämtar argumentet och härleder dess strängrepresentation på följande sätt:

Om argumentet är null infogar metoden String.Empty i resultatsträngen. Du behöver inte bry dig om att hantera ett NullReferenceException för null-argument.
Om du anropar överlagringen Format(IFormatProvider, String, Object[]) och provider-objektets IFormatProvider.GetFormat-implementering returnerar en icke-null-implementering ICustomFormatter skickas argumentet till dess ICustomFormatter.Format(String, Object, IFormatProvider)-metod. Om formatobjektet innehåller ett formatString argument skickas det som det första argumentet till metoden. Om implementeringen ICustomFormatter är tillgänglig och genererar en icke-null-sträng returneras strängen som strängrepresentation av argumentet, annars körs nästa steg.
Om argumentet implementerar IFormattable-gränssnittet, anropas dess IFormattable.ToString-implementering.
Argumentets parameterlösa ToString metod, som antingen åsidosätter eller ärver från en basklassimplementering, anropas.

Ett exempel som fångar upp anrop till ICustomFormatter.Format-metoden och låter dig se vilken information Format-metoden skickar till en formateringsmetod för varje formatobjekt i en sammansatt formatsträng kan ses i Exempel: En intercept-provider och romersk talformaterare.

Mer information finns i Bearbetningsordning.

Formatera objekt som har samma index

Metoden Format genererar ett FormatException undantag om indexet för ett indexobjekt är större än eller lika med antalet argument i argumentlistan. Kan dock format innehålla fler formatobjekt än det finns argument, så länge flera formatobjekt har samma index. I anropet Format(String, Object) till metoden i följande exempel har argumentlistan ett enda argument, men formatsträngen innehåller två formatobjekt: den ena visar decimalvärdet för ett tal och det andra visar dess hexadecimala värde.

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

open System

let values= [| Int16.MinValue; -27s; 0s; 1042s; Int16.MaxValue |]
printfn "%10s  %10s\n" "Decimal" "Hex"
for value in values do
    String.Format("{0,10:G}: {0,10:X}", value)
    |> printfn "%s"
// The example displays the following output:
//       Decimal         Hex
//    
//        -32768:       8000
//           -27:       FFE5
//             0:          0
//          1042:        412
//         32767:       7FFF

Module Example1
    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 och kultur

Vanligtvis konverteras objekt i argumentlistan till sina strängrepresentationer med hjälp av konventionerna i den aktuella kulturen, som returneras av CultureInfo.CurrentCulture egenskapen. Du kan styra det här beteendet genom att anropa en av överlagringarna av Format som innehåller en provider parameter. Parametern provider är en IFormatProvider implementering som tillhandahåller anpassad och kulturspecifik formateringsinformation som används för att moderera formateringsprocessen.

Gränssnittet IFormatProvider har en enda medlem, GetFormat, som ansvarar för att returnera objektet som tillhandahåller formateringsinformation. .NET har tre IFormatProvider implementeringar som ger kulturspecifik formatering:

CultureInfo. Dess GetFormat metod returnerar ett kulturspecifikt NumberFormatInfo objekt för formatering av numeriska värden och ett kulturspecifikt DateTimeFormatInfo objekt för formatering av datum- och tidsvärden.
DateTimeFormatInfo, som används för kulturspecifik formatering av datum- och tidsvärden. Metoden GetFormat returnerar sig själv.
NumberFormatInfo, som används för kulturspecifik formatering av numeriska värden. Metoden GetFormat(Type) returnerar sig själv.

Anpassade formateringsåtgärder

Du kan också anropa någon av överlagringarna för metoden Format som har en provider parameter av typen IFormatProvider för att utföra anpassade formateringsåtgärder. Du kan till exempel formatera ett heltal som ett ID-nummer eller som ett telefonnummer. För att kunna utföra anpassad formatering måste argumentet provider implementera både gränssnitten IFormatProvider och ICustomFormatter . Format När metoden skickas en ICustomFormatter implementering som provider argument anropar Format metoden dess IFormatProvider.GetFormat implementering och begär ett objekt av typen ICustomFormatter. Den anropar sedan ICustomFormatter-metoden hos det returnerade Format-objektet för att formatera varje formatdel i den sammansatta sträng som skickats till det.

Mer information om hur du tillhandahåller anpassade formateringslösningar finns i Så här definierar och använder du anpassade numeriska formatproviders och ICustomFormatter. Ett exempel som konverterar heltal till formaterade anpassade tal finns i Exempel: En anpassad formateringsåtgärd. Ett exempel som konverterar osignerade byte till romerska siffror finns i Exempel: En avlyssningsleverantör och romersk talformaterare.

Exempel: En anpassad formateringsåtgärd

Det här exemplet definierar en formatprovider som formaterar ett heltalsvärde som ett kundkontonummer i formuläret x-xxxxx-xx.

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.

open System

type CustomerFormatter() = 
    interface IFormatProvider with
        member this.GetFormat(formatType) =
            if formatType = typeof<ICustomFormatter> then
                this
            else
                null

    interface ICustomFormatter with
        member this.Format(format, arg, formatProvider: IFormatProvider) = 
            if this.Equals formatProvider |> not then
                null
            else
                let format = 
                    if String.IsNullOrEmpty format then "G"
                    else format.ToUpper()
                
                let customerString = 
                    let s = string arg
                    if s.Length < 8 then
                        s.PadLeft(8, '0')
                    else s
                
                match format with
                | "G" ->
                    customerString.Substring(0, 1) + "-" +
                        customerString.Substring(1, 5) + "-" +
                        customerString.Substring 6
                | "S" ->                          
                    customerString.Substring(0, 1) + "/" +
                        customerString.Substring(1, 5) + "/" +
                        customerString.Substring 6
                | "P" ->                          
                    customerString.Substring(0, 1) + "." +
                        customerString.Substring(1, 5) + "." +
                        customerString.Substring 6
                | _ ->
                    raise (FormatException $"The '{format}' format specifier is not supported.")

let acctNumber = 79203159
String.Format(CustomerFormatter(), "{0}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:G}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:S}", acctNumber)
|> printfn "%s"
String.Format(CustomerFormatter(), "{0:P}", acctNumber)
|> printfn "%s"
try
    String.Format(CustomerFormatter(), "{0:X}", acctNumber)
    |> printfn "%s"
with :? FormatException as e ->
    printfn $"{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.

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.

Exempel: En avlyssningsleverantör och romersk sifferformatterare

Det här exemplet definierar en anpassad formatprovider som implementerar gränssnitten ICustomFormatter och IFormatProvider för att göra två saker:

Den visar parametrarna som skickas till implementeringen ICustomFormatter.Format . På så sätt kan vi se vilka parametrar Format(IFormatProvider, String, Object[]) metoden skickar till den anpassade formateringsimplementeringen för varje objekt som den försöker formatera. Detta kan vara användbart när du felsöker ditt program.
Om objektet som ska formateras är ett osignerat bytevärde som ska formateras med standardformatsträngen "R" formateras det numeriska värdet som ett romerskt tal.

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 FormatExample12
{
   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

open System
open System.Globalization

type InterceptProvider() =
    interface IFormatProvider with
        member this.GetFormat(formatType) =
            if formatType = typeof<ICustomFormatter> then
                this
            else
                null
    interface ICustomFormatter with
        member _.Format(format, obj, provider: IFormatProvider) = 
            // Display information about method call.
            let formatString =
                if format = null then "<null>" else format
            printfn $"Provider: {provider.GetType().Name}, Object: %A{obj}, Format String: %s{formatString}"
                                
            if obj = null then
                String.Empty
            else
                // If this is a byte and the "R" format string, format it with Roman numerals.
                match obj with
                | :? byte as value when formatString.ToUpper().Equals "R" -> 
                    let mutable returnString = String.Empty

                    // Get the hundreds digit(s)
                    let struct (result, remainder) = Math.DivRem(value, 100uy)
                    if result > 0uy then
                        returnString <- String('C', int result)
                    let value = byte remainder
                    // Get the 50s digit
                    let struct (result, remainder) = Math.DivRem(value, 50uy)
                    if result = 1uy then
                        returnString <- returnString + "L"
                    let value = byte remainder
                    // Get the tens digit.
                    let struct (result, remainder) = Math.DivRem(value, 10uy)
                    if result > 0uy then
                        returnString <- returnString + String('X', int result)
                    let value = byte remainder 
                    // Get the fives digit.
                    let struct (result, remainder) = Math.DivRem(value, 5uy)
                    if result > 0uy then
                        returnString <- returnString + "V"
                    let value = byte remainder
                    // Add the ones digit.
                    if remainder > 0uy then 
                        returnString <- returnString + String('I', int remainder)
                    
                    // Check whether we have too many X characters.
                    let pos = returnString.IndexOf "XXXX"
                    if pos >= 0 then
                        let xPos = returnString.IndexOf "L" 
                        returnString <-
                            if xPos >= 0 && xPos = pos - 1 then
                                returnString.Replace("LXXXX", "XC")
                            else
                                returnString.Replace("XXXX", "XL")   
                    // Check whether we have too many I characters
                    let pos = returnString.IndexOf "IIII"
                    if pos >= 0 then
                        returnString <-
                            if returnString.IndexOf "V" >= 0 then
                                returnString.Replace("VIIII", "IX")
                            else
                                returnString.Replace("IIII", "IV")    
                    returnString 

                // Use default for all other formatting.
                | :? IFormattable as x ->
                    x.ToString(format, CultureInfo.CurrentCulture)
                | _ ->
                    string obj

let n = 10
let value = 16.935
let day = DateTime.Now
let provider = InterceptProvider()
String.Format(provider, "{0:N0}: {1:C2} on {2:d}\n", n, value, day)
|> printfn "%s"
String.Format(provider, "{0}: {1:F}\n", "Today: ", DateTime.Now.DayOfWeek)
|> printfn "%s"
String.Format(provider, "{0:X}, {1}, {2}\n", 2uy, 12uy, 199uy)
|> printfn "%s"
String.Format(provider, "{0:R}, {1:R}, {2:R}\n", 2uy, 12uy, 199uy)
|> printfn "%s"
// 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 TypeOf obj Is IFormattable Then
         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

Vanliga frågor och svar

Varför rekommenderar du stränginterpolering över anrop till `String.Format` metoden?

Stränginterpolation är:

Mer flexibel. Den kan användas i valfri sträng utan att kräva ett anrop till en metod som stöder sammansatt formatering. Annars måste du anropa Format metoden eller en annan metod som stöder sammansatt formatering, till exempel Console.WriteLine eller StringBuilder.AppendFormat.
Mer läsbar. Eftersom uttrycket som ska infogas i en sträng visas i det interpolerade uttrycket i stället för i en argumentlista är interpolerade strängar enklare att koda och läsa. Interpolerade strängar kan också användas i strängsammanfogningsåtgärder för att skapa mer koncis och tydligare kod.

En jämförelse av följande två kodexempel visar interpolerade strängars överlägsenhet jämfört med strängkonkatenering och anrop till sammansatta formateringsmetoder. Användningen av flera strängsammanfogningsåtgärder i följande exempel ger utförlig och svårläst kod.

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.

open System

let names = [| "Balto"; "Vanya"; "Dakota"; "Samuel"; "Koani"; "Yiska"; "Yuma" |]
let output = 
    names[0] + ", " + names[1] + ", " + names[2] + ", " + 
    names[3] + ", " + names[4] + ", " + names[5] + ", " + 
    names[6] + "\n"

let date = DateTime.Now
output + String.Format("It is {0:t} on {0:d}. The day of the week is {1}.", date, date.DayOfWeek)
|> printfn "%s"
// 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 Example12
    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.

Användningen av interpolerade strängar i följande exempel ger däremot mycket tydligare, mer koncis kod än strängsammanfogningssatsen och anropet Format till metoden i föregående exempel.

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.

open System

let names = [| "Balto"; "Vanya"; "Dakota"; "Samuel"; "Koani"; "Yiska"; "Yuma" |]
let output = $"{names[0]}, {names[1]}, {names[2]}, {names[3]}, {names[4]}, {names[5]}, {names[6]}"  

let date = DateTime.Now
output + $"\nIt is {date:t} on {date:d}. The day of the week is {date.DayOfWeek}."
|> printfn "%s" 
// 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 Example13
    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.

Var hittar jag de fördefinierade formatsträngarna?

Se alla heltals- och flyttalstyper i Standard numeriska formatsträngar och Anpassade numeriska formatsträngar.
För datum- och tidsvärden, se Standard datum- och tidsformatsträngar och Anpassade datum- och tidsformatsträngar.
Information om uppräkningsvärden finns i Uppräkningsformatsträngar.
För TimeSpan-värden, se Standard TimeSpan Format Strings och Custom TimeSpan Format Strings.
Värden Guid finns i avsnittet Kommentarer på Guid.ToString(String) referenssidan.

Hur styr jag justeringen av resultatsträngarna som ersätter formatobjekt?

Den allmänna syntaxen för ett formatobjekt är:

{index[,width][: formatString]}

width är ett signerat heltal som definierar fältbredden. Om det här värdet är negativt är texten i fältet vänsterjusterad. Om det är positivt är texten högerjusterad.

Hur styr jag antalet siffror efter decimaltecknet?

Alla numeriska standardformatsträngar utom "D" (som endast används med heltal), "G", "R" och "X" tillåter en precisionsspecificerare som definierar antalet decimalsiffror i resultatsträngen. I följande exempel används numeriska standardformatsträngar för att styra antalet decimaltal i resultatsträngen.

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 %

open System

let values: obj list = [ 1603, 1794.68235, 15436.14 ]
for value in values do
   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.)
   |> printfn "%s"
// 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 Example7
    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 %

Om du använder en anpassad numerisk formatsträng använder du formatspecificeraren "0" för att styra antalet decimalsiffror i resultatsträngen, vilket visas i följande exempel.

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

let value = 16309.5436m
String.Format("{0,12:#.00000} {0,12:0,000.00} {0,12:000.00#}", value)
|> printfn "%s"
// The example displays the following output:
//        16309.54360    16,309.54    16309.544

Module Example8
    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

Hur styr jag antalet heltalssiffror?

Som standard visar formateringsåtgärder endast icke-noll integralsiffror. Om du formaterar heltal kan du använda en precisionsspecificerare med standardformatsträngarna "D" och "X" för att styra antalet siffror.

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

open System

let value = 1326
String.Format("{0,10:D6} {0,10:X8}", value)
|> printfn "%s"
// The example displays the following output:
//     001326   0000052E

Module Example10
    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

Du kan fylla på ett heltal eller flyttalsnummer med inledande nollor för att skapa en resultatsträng med ett angivet antal heltalssiffror med hjälp av den anpassade numeriska formatspecificeraren "0", som i följande exempel visas.

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

open System

let value = 16342
String.Format("{0,18:00000000} {0,18:00000000.000} {0,18:000,0000,000.0}", value)
|> printfn "%s"
// The example displays the following output:
//           00016342       00016342.000    0,000,016,342.0

Module Example9
    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

Hur många objekt kan jag ta med i formatlistan?

Det finns ingen praktisk gräns. Den andra parametern för Format(IFormatProvider, String, Object[]) metoden är taggad med ParamArrayAttribute attributet, vilket gör att du kan inkludera antingen en avgränsad lista eller en objektmatris som formatlista.

Hur tar jag med literalparenteser ("{" och "}") i resultatsträngen?

Hur förhindrar du till exempel att följande metodanrop genererar ett FormatException undantag?

result = String.Format("The text has {0} '{' characters and {1} '}' characters.",
                       nOpen, nClose);

let 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)

En enda inledande eller avslutande klammerparentes tolkas alltid som början eller slutet av ett formatobjekt. För att tolkas bokstavligen måste det undkommas. Du slipper en klammerparentes genom att lägga till en annan klammerparentes ("{{" och "}}" i stället för {" och "}"), som i följande metodanrop:

string result;
int nOpen = 1;
int nClose = 2;
result = String.Format("The text has {0} '{{' characters and {1} '}}' characters.",
                       nOpen, nClose);
Console.WriteLine(result);

let 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)

Men även undantagna klammerparenteser är lätt feltolkade. Vi rekommenderar att du inkluderar klammerparenteser i formatlistan och använder formatobjekt för att infoga dem i resultatsträngen, vilket visas i följande exempel.

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);

let result =
    String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.", nOpen, "{", nClose, "}")

result = String.Format("The text has {0} '{1}' characters and {2} '{3}' characters.",
                 nOpen, "{", nClose, "}")

Varför genererar mitt anrop till metoden String.Format ett FormatException?

Den vanligaste orsaken till undantaget är att indexet för ett formatobjekt inte motsvarar ett objekt i formatlistan. Detta indikerar vanligtvis att du har felnumrerat indexen för formatobjekt eller att du har glömt att inkludera ett objekt i formatlistan. Försök att inkludera ett icke-escapat tecken för vänster eller höger klammerparentes utlöser också en FormatException. Ibland är undantaget resultatet av ett stavfel. Ett vanligt misstag är till exempel att skriva fel "[" (vänster hakparentes) i stället för "{" (vänster klammerparentes).

Om metoden Format(System.IFormatProvider,System.String,System.Object[]) stöder parametermatriser, varför utlöser min kod ett undantag när jag använder en matris?

Följande kod genererar till exempel ett FormatException undantag:

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($"{numbers} + {1} + {2} = {3}");

open System

let rnd = Random()
let mutable total = 0
let numbers = Array.zeroCreate<int> 4
for i = 0 to 2 do
   let number = rnd.Next 1001
   numbers[i] <- number
   total <- total + number
numbers[3] <- total
Console.WriteLine("{0} + {1} + {2} = {3}", numbers)


Module Example5a
    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

Det här är ett problem med kompilatorns överbelastningsmatchning. Eftersom kompilatorn inte kan konvertera en matris med heltal till en objektmatris behandlar den heltalsmatrisen som ett enda argument, så den anropar Format(String, Object) metoden. Undantaget genereras eftersom det finns fyra formatobjekt men bara ett enda objekt i formatlistan.

Eftersom varken Visual Basic eller C# kan konvertera en heltalsmatris till en objektmatris måste du utföra konverteringen själv innan du Format(String, Object[]) anropar metoden. I följande exempel finns en implementering.

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($"{values} + {1} + {2} = {3}");

open System

let rnd = Random()
let numbers = Array.zeroCreate<int> 4
let mutable total = 0
for i = 0 to 2 do
   let number = rnd.Next 1001
   numbers[i] <- number
   total <- total + number
numbers[3] <- total
let values = Array.zeroCreate<obj> numbers.Length
numbers.CopyTo(values, 0)
Console.WriteLine("{0} + {1} + {2} = {3}", values)

Imports System.Collections.Generic

Module Example6
    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

Kommentarer

Important

I stället för att anropa metoden String.Format eller använda sammansatta formatsträngar kan du använda interpolerade strängar om språket stöder dem. En interpolerad sträng är en sträng som innehåller interpolerade uttryck. Varje interpolerat uttryck matchas med uttryckets värde och ingår i resultatsträngen när strängen tilldelas. Mer information finns i String interpolation (C#-referens) och Interpolerade strängar (Visual Basic-referens).

Format(IFormatProvider, String, Object, Object, Object)

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjekten i en sträng med strängrepresentationen av tre angivna objekt. En parameter tillhandahåller kulturspecifik formateringsinformation.

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

Parametrar

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

format: String

En sammansatt formatsträng.

arg0: Object

Det första objektet som ska formateras.

arg1: Object

Det andra objektet som ska formateras.

arg2: Object

Det tredje objektet som ska formateras.

Returer

String

En kopia av format där formatobjekten har ersatts av strängrepresentationerna av arg0, arg1och arg2.

Undantag

ArgumentNullException

format är null.

FormatException

format är ogiltigt.

-eller-

Indexet för ett formatobjekt är mindre än noll eller större än två.

Kommentarer

Important

Den här metoden använder funktionen sammansatt formatering för att konvertera tre uttryck till sina strängrepresentationer och för att bädda in dessa representationer i en sträng. Vid konverteringen använder metoden kulturkänslig formatering eller en anpassad formatering. Metoden konverterar varje Object argument till dess strängrepresentation genom att anropa metoden ToString (IFormatProvider) eller, om objektets motsvarande formatobjekt innehåller en formatsträng, genom att anropa metoden ToString(String,IFormatProvider). Om dessa metoder inte finns anropas objektets parameterlösa ToString-metod .

Men när du anropar String.Format metoden är det inte nödvändigt att fokusera på den specifika överlagring som du vill anropa. I stället kan du anropa metoden med ett objekt som tillhandahåller kulturkänslig eller anpassad formatering och en sammansatt formatsträng som innehåller ett eller flera formatobjekt. Du tilldelar varje formatobjekt ett numeriskt index. börjar det första indexet vid 0. Förutom den inledande strängen bör metodanropet ha lika många ytterligare argument som indexvärden. Till exempel bör en sträng vars formatobjekt har index på 0 och 1 ha 2 argument. en med index 0 till 5 bör ha 6 argument. Språkkompilatorn löser sedan metodanropet till en viss överlagring av String.Format metoden.

Mer detaljerad dokumentation om hur du använder String.Format metoden finns i Komma igång med metoden String.Format och Vilken metod anropar jag?.

Gäller för

Format(IFormatProvider, String, Object, Object)

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjekten i en sträng med strängrepresentationen av två angivna objekt. En parameter tillhandahåller kulturspecifik formateringsinformation.

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

Parametrar

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

format: String

En sammansatt formatsträng.

arg0: Object

Det första objektet som ska formateras.

arg1: Object

Det andra objektet som ska formateras.

Returer

String

En kopia av format i vilket formatobjekt ersätts av strängrepresentationerna av arg0 och arg1.

Undantag

ArgumentNullException

format är null.

FormatException

format är ogiltigt.

-eller-

Indexet för ett formatobjekt är inte noll eller ett.

Kommentarer

Important

Den här metoden använder funktionen för sammansatt formatering för att konvertera två uttryck till sina strängrepresentationer och för att bädda in dessa representationer i en sträng. Vid konverteringen använder metoden kulturkänslig formatering eller en anpassad formatering. Metoden konverterar varje Object argument till dess strängrepresentation genom att anropa metoden ToString (IFormatProvider) eller, om objektets motsvarande formatobjekt innehåller en formatsträng, genom att anropa metoden ToString(String,IFormatProvider). Om dessa metoder inte finns anropas objektets parameterlösa ToString-metod .

Mer detaljerad dokumentation om hur du använder String.Format metoden finns i Komma igång med metoden String.Format och Vilken metod anropar jag?.

Gäller för

Format(String, Object, Object)

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjekten i en sträng med strängrepresentationen av två angivna objekt.

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

Parametrar

format: String

En sammansatt formatsträng.

arg0: Object

Det första objektet som ska formateras.

arg1: Object

Det andra objektet som ska formateras.

Returer

String

En kopia av format i vilket formatobjekt ersätts av strängrepresentationerna av arg0 och arg1.

Undantag

ArgumentNullException

format är null.

FormatException

format är ogiltigt.

-eller-

Indexet för ett formatobjekt är inte noll eller ett.

Kommentarer

Important

Den här metoden använder funktionen sammansatt formatering för att konvertera värdet för två uttryck till deras strängrepresentationer och för att bädda in dessa representationer i en sträng.

Men när du anropar String.Format metoden är det inte nödvändigt att fokusera på den specifika överlagring som du vill anropa. I stället kan du anropa metoden med en sammansatt formatsträng som innehåller ett eller flera formatobjekt. Du tilldelar varje formatobjekt ett numeriskt index. börjar det första indexet vid 0. Förutom den inledande strängen bör metodanropet ha lika många ytterligare argument som indexvärden. Till exempel bör en sträng vars formatobjekt har index på 0 och 1 ha 2 argument. en med index 0 till 5 bör ha 6 argument. Språkkompilatorn löser sedan metodanropet till en viss överlagring av String.Format metoden.

Mer detaljerad dokumentation om hur du använder String.Format metoden finns i Komma igång med metoden String.Format och Vilken metod anropar jag?.

Exempel: Formatera två argument

I det Format(String, Object, Object) här exemplet används metoden för att visa tids- och temperaturdata som lagras i ett allmänt Dictionary<TKey,TValue> objekt. Observera att formatsträngen har tre formatobjekt, även om det bara finns två objekt att formatera. Det beror på att det första objektet i listan (ett datum- och tidsvärde) används av två formatobjekt: Det första formatobjektet visar tiden och det andra visar datumet.

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

open System
open System.Collections.Generic

let temperatureInfo = Dictionary<DateTime, float>() 
temperatureInfo.Add(DateTime(2010, 6, 1, 14, 0, 0), 87.46)
temperatureInfo.Add(DateTime(2010, 12, 1, 10, 0, 0), 36.81)

printfn $"Temperature Information:\n"
for item in temperatureInfo do
   String.Format("Temperature at {0,8:t} on {0,9:d}: {1,5:N1}°F", item.Key, item.Value)
   |> printfn "%s"
// 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

Se även

Gäller för

Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjektet eller objekten i en CompositeFormat med strängrepresentationen av motsvarande objekt i det angivna formatet.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, ReadOnlySpan<System::Object ^> args);

public static string Format(IFormatProvider? provider, System.Text.CompositeFormat format, scoped ReadOnlySpan<object?> args);

public static string Format(IFormatProvider? provider, System.Text.CompositeFormat format, ReadOnlySpan<object?> args);

static member Format : IFormatProvider * System.Text.CompositeFormat * ReadOnlySpan<obj> -> string

Public Shared Function Format (provider As IFormatProvider, format As CompositeFormat, args As ReadOnlySpan(Of Object)) As String

Parametrar

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

format: CompositeFormat

En CompositeFormat.

args: ReadOnlySpan<Object>

Ett intervall med objekt som ska formateras.

Returer

String

Den formaterade strängen.

Undantag

ArgumentNullException

format är null.

FormatException

Indexet för ett formatobjekt är större än eller lika med antalet angivna argument.

Gäller för

Format(IFormatProvider, CompositeFormat, Object[])

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjektet eller objekten i en CompositeFormat med strängrepresentationen av motsvarande objekt i det angivna formatet.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, ... cli::array <System::Object ^> ^ args);

public static string Format(IFormatProvider? provider, System.Text.CompositeFormat format, params object?[] args);

static member Format : IFormatProvider * System.Text.CompositeFormat * obj[] -> string

Public Shared Function Format (provider As IFormatProvider, format As CompositeFormat, ParamArray args As Object()) As String

Parametrar

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

format: CompositeFormat

En CompositeFormat.

args: Object[]

En matris med objekt som ska formateras.

Returer

String

Den formaterade strängen.

Undantag

ArgumentNullException

format eller args är null.

FormatException

Indexet för ett formatobjekt är större än eller lika med antalet angivna argument.

Gäller för

Format(String, Object, Object, Object)

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjekten i en sträng med strängrepresentationen av tre angivna objekt.

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

Parametrar

format: String

En sammansatt formatsträng.

arg0: Object

Det första objektet som ska formateras.

arg1: Object

Det andra objektet som ska formateras.

arg2: Object

Det tredje objektet som ska formateras.

Returer

String

En kopia av format där formatobjekten har ersatts av strängrepresentationerna av arg0, arg1och arg2.

Undantag

ArgumentNullException

format är null.

FormatException

format är ogiltigt.

-eller-

Indexet för ett formatobjekt är mindre än noll eller större än två.

Kommentarer

Important

Den här metoden använder funktionen sammansatt formatering för att konvertera värdet för tre uttryck till deras strängrepresentationer och för att bädda in dessa representationer i en sträng.

Mer detaljerad dokumentation om hur du använder String.Format metoden finns i Komma igång med metoden String.Format och Vilken metod anropar jag?.

Exempel: Formatera tre argument

I det Format(String, Object, Object, Object) här exemplet används metoden för att skapa en sträng som illustrerar resultatet av en boolesk And åtgärd med två heltalsvärden. Observera att formatsträngen innehåller sex formatobjekt, men metoden har bara tre objekt i sin parameterlista, eftersom varje objekt formateras på två olika sätt.

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)

open System

let formatString = 
    "    {0,10} ({0,8:X8})\nAnd {1,10} ({1,8:X8})\n  = {2,10} ({2,8:X8})"

let value1 = 16932
let value2 = 15421
String.Format(formatString, value1, value2, value1 &&& value2)
|> printfn "%s"
// 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)

Se även

Gäller för

Format(IFormatProvider, String, Object[])

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjekten i en sträng med strängrepresentationer av motsvarande objekt i en angiven matris. En parameter tillhandahåller kulturspecifik formateringsinformation.

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

Parametrar

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

format: String

En sammansatt formatsträng.

args: Object[]

En objektmatris som innehåller noll eller fler objekt att formatera.

Returer

String

En kopia av format där formatobjekten har ersatts av strängrepresentationen av motsvarande objekt i args.

Undantag

ArgumentNullException

format eller args är null.

FormatException

format är ogiltigt.

-eller-

Indexet för ett formatobjekt är mindre än noll eller större än eller lika med matrisens args längd.

Kommentarer

Important

Den här metoden använder funktionen sammansatt formatering för att konvertera fyra eller fler uttryck till sina strängrepresentationer och för att bädda in dessa representationer i en sträng. Vid konverteringen använder metoden kulturkänslig formatering eller en anpassad formatering. Metoden konverterar varje Object argument till dess strängrepresentation genom att anropa metoden ToString (IFormatProvider) eller, om objektets motsvarande formatobjekt innehåller en formatsträng, genom att anropa metoden ToString(String,IFormatProvider). Om dessa metoder inte finns anropas objektets parameterlösa ToString-metod .

Mer detaljerad dokumentation om hur du använder String.Format metoden finns i Komma igång med metoden String.Format och Vilken metod anropar jag?.

Exempel: Kulturkänslig formatering

I det Format(IFormatProvider, String, Object[]) här exemplet används metoden för att visa strängrepresentationen av vissa datum- och tidsvärden och numeriska värden med hjälp av flera olika kulturer.

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

open System
open System.Globalization

let cultureNames = [| "en-US"; "fr-FR"; "de-DE"; "es-ES" |]

let dateToDisplay = DateTime(2009, 9, 1, 18, 32, 0)
let value = 9164.32

printfn "Culture     Date                                Value\n"
for cultureName in cultureNames do
    let culture = CultureInfo cultureName
    String.Format(culture, "{0,-11} {1,-35:D} {2:N}", culture.Name, dateToDisplay, value)
    |> printfn "%s"
// 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 Example2
   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

Se även

Gäller för

Format(IFormatProvider, String, Object)

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjektet eller objekten i en angiven sträng med strängrepresentationen av motsvarande objekt. En parameter tillhandahåller kulturspecifik formateringsinformation.

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

Parametrar

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

format: String

En sammansatt formatsträng.

arg0: Object

Objektet som ska formateras.

Returer

String

En kopia av format där formatobjektet eller objekten har ersatts av strängrepresentationen av arg0.

Undantag

ArgumentNullException

format är null.

FormatException

format är ogiltigt.

-eller-

Indexet för ett formatobjekt är inte noll.

Kommentarer

Important

Den här metoden använder funktionen sammansatt formatering för att konvertera värdet för ett uttryck till dess strängrepresentation och för att bädda in representationen i en sträng. Vid konverteringen använder metoden kulturkänslig formatering eller en anpassad formatering. Metoden konverterar arg0 till sin strängrepresentation genom att anropa metoden ToString(IFormatProvider) eller, om objektets motsvarande formatobjekt innehåller en formatsträng, genom att anropa metoden ToString(String,IFormatProvider). Om dessa metoder inte finns anropas objektets parameterlösa ToString-metod .

Mer detaljerad dokumentation om hur du använder String.Format metoden finns i Komma igång med metoden String.Format och Vilken metod anropar jag?.

Gäller för

Format(String, ReadOnlySpan<Object>)

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjektet i en angiven sträng med strängrepresentationen av ett motsvarande objekt i ett angivet intervall.

public:
 static System::String ^ Format(System::String ^ format, ReadOnlySpan<System::Object ^> args);

public static string Format(string format, scoped ReadOnlySpan<object?> args);

static member Format : string * ReadOnlySpan<obj> -> string

Public Shared Function Format (format As String, args As ReadOnlySpan(Of Object)) As String

Parametrar

format: String

En sammansatt formatsträng.

args: ReadOnlySpan<Object>

Ett objektintervall som innehåller noll eller fler objekt att formatera.

Returer

String

En kopia av format där formatobjekten har ersatts av strängrepresentationen av motsvarande objekt i args.

Gäller för

Format(String, Object[])

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjektet i en angiven sträng med strängrepresentationen av ett motsvarande objekt i en angiven matris.

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

Parametrar

format: String

En sammansatt formatsträng.

args: Object[]

En objektmatris som innehåller noll eller fler objekt att formatera.

Returer

String

En kopia av format där formatobjekten har ersatts av strängrepresentationen av motsvarande objekt i args.

Undantag

ArgumentNullException

format eller args är null.

FormatException

format är ogiltigt.

-eller-

Indexet för ett formatobjekt är mindre än noll eller större än eller lika med matrisens args längd.

Kommentarer

Important

Den här metoden använder funktionen sammansatt formatering för att konvertera värdet för fyra eller fler uttryck till deras strängrepresentationer och för att bädda in dessa representationer i en sträng. Eftersom parametern args är markerad med System.ParamArrayAttribute attributet kan du skicka objekten till metoden som enskilda argument eller som en Object matris.

Mer detaljerad dokumentation om hur du använder String.Format metoden finns i Komma igång med metoden String.Format och Vilken metod anropar jag?.

Exempel: Formatera fler än tre argument

Det här exemplet skapar en sträng som innehåller data om den höga och låga temperaturen vid ett visst datum. Den sammansatta formatsträngen har fem formatobjekt i C#-exemplet och sex i Visual Basic exempel. Två av formatobjekten definierar bredden på motsvarande värdes strängrepresentation, och det första formatobjektet innehåller även en standardsträng för datum- och tidsformat.

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)

let date1 = DateTime(2009, 7, 1)
let hiTime = TimeSpan(14, 17, 32)
let hiTemp = 62.1m 
let loTime = TimeSpan(3, 16, 10)
let loTemp = 54.8m 

String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", date1, hiTime, hiTemp, loTime, loTemp)
|> printfn "%s\n"
      
String.Format("Temperature on {0:d}:\n{1,11}: {2} degrees (hi)\n{3,11}: {4} degrees (lo)", [| date1 :> obj; hiTime; hiTemp; loTime; loTemp |])
|> printfn "%s"
// 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)

Du kan också skicka objekten som ska formateras som en matris i stället för som en argumentlista.

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 FormatExample10
{
   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

open System

type CityInfo =
  { Name: string
    Population: int
    Area: Decimal
    Year: int }

let showPopulationData city =
    let args: obj[] = [| city.Name; city.Year; city.Population; city.Area |]
    String.Format("{0} in {1}: Population {2:N0}, Area {3:N1} sq. feet", args)
    |> printfn "%s"

{ Name = "New York"; Population = 8175133; Area = 302.64m; Year = 2010 }
|> showPopulationData

 
{ Name = "Seattle"; Population = 608660; Area = 83.94m; Year = 2010 }      
|> showPopulationData 

// 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

Se även

Gäller för

Format(String, Object)

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter ett eller flera formatobjekt i en sträng med strängrepresentationen av ett angivet objekt.

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

Parametrar

format: String

En sammansatt formatsträng.

arg0: Object

Objektet som ska formateras.

Returer

String

En kopia av format i vilken formatobjekt ersätts av strängrepresentationen av arg0.

Undantag

ArgumentNullException

format är null.

FormatException

Formatobjektet i format är ogiltigt.

-eller-

Indexet för ett formatobjekt är inte noll.

Kommentarer

Important

Den här metoden använder funktionen sammansatt formatering för att konvertera värdet för ett uttryck till dess strängrepresentation och för att bädda in representationen i en sträng.

Mer detaljerad dokumentation om hur du använder String.Format metoden finns i Komma igång med metoden String.Format och Vilken metod anropar jag?.

Exempel: Formatera ett enskilt argument

I följande exempel används Format(String, Object) metoden för att bädda in en individs ålder mitt i en sträng.

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.

let birthdate = DateTime(1993, 7, 28)
let dates = 
    [ DateTime(1993, 8, 16) 
      DateTime(1994, 7, 28)
      DateTime(2000, 10, 16)
      DateTime(2003, 7, 27)
      DateTime(2007, 5, 27) ]

for dateValue in dates do
    let interval = dateValue - birthdate
    // Get the approximate number of years, without accounting for leap years.
    let years = (int interval.TotalDays) / 365
    // See if adding the number of years exceeds dateValue.
    if birthdate.AddYears years <= dateValue then
        String.Format("You are now {0} years old.", years)
    else
        String.Format("You are now {0} years old.", years - 1)
    |> printfn "%s"
// 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.

Se även

Gäller för

Format(IFormatProvider, String, ReadOnlySpan<Object>)

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjekten i en sträng med strängrepresentationer av motsvarande objekt i ett angivet intervall. En parameter tillhandahåller kulturspecifik formateringsinformation.

public:
 static System::String ^ Format(IFormatProvider ^ provider, System::String ^ format, ReadOnlySpan<System::Object ^> args);

public static string Format(IFormatProvider? provider, string format, scoped ReadOnlySpan<object?> args);

static member Format : IFormatProvider * string * ReadOnlySpan<obj> -> string

Public Shared Function Format (provider As IFormatProvider, format As String, args As ReadOnlySpan(Of Object)) As String

Parametrar

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

format: String

En sammansatt formatsträng.

args: ReadOnlySpan<Object>

Ett objektintervall som innehåller noll eller fler objekt att formatera.

Returer

String

En kopia av format där formatobjekten har ersatts av strängrepresentationen av motsvarande objekt i args.

Gäller för

Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2)

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjektet eller objekten i en CompositeFormat med strängrepresentationen av motsvarande objekt i det angivna formatet.

public:
generic <typename TArg0, typename TArg1, typename TArg2>
 static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, TArg0 arg0, TArg1 arg1, TArg2 arg2);

public static string Format<TArg0,TArg1,TArg2>(IFormatProvider? provider, System.Text.CompositeFormat format, TArg0 arg0, TArg1 arg1, TArg2 arg2);

static member Format : IFormatProvider * System.Text.CompositeFormat * 'TArg0 * 'TArg1 * 'TArg2 -> string

Public Shared Function Format(Of TArg0, TArg1, TArg2) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0, arg1 As TArg1, arg2 As TArg2) As String

Typparametrar

TArg0

Typen av det första objektet som ska formateras.

TArg1

Typ av det andra objektet som ska formateras.

TArg2

Typ av det tredje objektet som ska formateras.

Parametrar

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

format: CompositeFormat

En CompositeFormat.

arg0: TArg0

Det första objektet som ska formateras.

arg1: TArg1

Det andra objektet som ska formateras.

arg2: TArg2

Det tredje objektet som ska formateras.

Returer

String

Den formaterade strängen.

Undantag

ArgumentNullException

format är null.

FormatException

Indexet för ett formatobjekt är större än eller lika med antalet angivna argument.

Gäller för

Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1)

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjektet eller objekten i en CompositeFormat med strängrepresentationen av motsvarande objekt i det angivna formatet.

public:
generic <typename TArg0, typename TArg1>
 static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, TArg0 arg0, TArg1 arg1);

public static string Format<TArg0,TArg1>(IFormatProvider? provider, System.Text.CompositeFormat format, TArg0 arg0, TArg1 arg1);

static member Format : IFormatProvider * System.Text.CompositeFormat * 'TArg0 * 'TArg1 -> string

Public Shared Function Format(Of TArg0, TArg1) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0, arg1 As TArg1) As String

Typparametrar

TArg0

Typen av det första objektet som ska formateras.

TArg1

Typ av det andra objektet som ska formateras.

Parametrar

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

format: CompositeFormat

En CompositeFormat.

arg0: TArg0

Det första objektet som ska formateras.

arg1: TArg1

Det andra objektet som ska formateras.

Returer

String

Den formaterade strängen.

Undantag

ArgumentNullException

format är null.

FormatException

Indexet för ett formatobjekt är större än eller lika med antalet angivna argument.

Gäller för

Format<TArg0>(IFormatProvider, CompositeFormat, TArg0)

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Källa:: String.Manipulation.cs

Ersätter formatobjektet eller objekten i en CompositeFormat med strängrepresentationen av motsvarande objekt i det angivna formatet.

public:
generic <typename TArg0>
 static System::String ^ Format(IFormatProvider ^ provider, System::Text::CompositeFormat ^ format, TArg0 arg0);

public static string Format<TArg0>(IFormatProvider? provider, System.Text.CompositeFormat format, TArg0 arg0);

static member Format : IFormatProvider * System.Text.CompositeFormat * 'TArg0 -> string

Public Shared Function Format(Of TArg0) (provider As IFormatProvider, format As CompositeFormat, arg0 As TArg0) As String

Typparametrar

TArg0

Typen av det första objektet som ska formateras.

Parametrar

provider: IFormatProvider

Ett objekt som tillhandahåller kulturspecifik formateringsinformation.

format: CompositeFormat

En CompositeFormat.

arg0: TArg0

Det första objektet som ska formateras.

Returer

String

Den formaterade strängen.

Undantag

ArgumentNullException

format är null.

FormatException

Indexet för ett formatobjekt är större än eller lika med antalet angivna argument.

Gäller för

Feedback

Var den här sidan till hjälp?

String.Format Metod

Definition

Överlagringar

Exempel

Skapa en formatsträng

Kontrollera formaterade utdata

Gör formatsträngar kulturkänsliga

Anpassa formateringsåtgärden

Kom igång med metoden String.Format

Infoga en sträng

Kontrollera formateringen

Kontrollavstånd

Kontrolljustering

Vilken metod anropar jag?

Format-metoden i korthet

Formatobjektet

Hur formateras argument

Formatera objekt som har samma index

Format och kultur

Anpassade formateringsåtgärder

Exempel: En anpassad formateringsåtgärd

Exempel: En avlyssningsleverantör och romersk sifferformatterare

Vanliga frågor och svar

Varför rekommenderar du stränginterpolering över anrop till String.Format metoden?

Var hittar jag de fördefinierade formatsträngarna?

Hur styr jag justeringen av resultatsträngarna som ersätter formatobjekt?

Hur styr jag antalet siffror efter decimaltecknet?

Hur styr jag antalet heltalssiffror?

Hur många objekt kan jag ta med i formatlistan?

Hur tar jag med literalparenteser ("{" och "}") i resultatsträngen?

Varför genererar mitt anrop till metoden String.Format ett FormatException?

Om metoden Format(System.IFormatProvider,System.String,System.Object[]) stöder parametermatriser, varför utlöser min kod ett undantag när jag använder en matris?

Kommentarer

Format(IFormatProvider, String, Object, Object, Object)

Parametrar

Returer

Undantag

Kommentarer

Gäller för

Format(IFormatProvider, String, Object, Object)

Parametrar

Returer

Undantag

Kommentarer

Gäller för

Format(String, Object, Object)

Parametrar

Returer

Undantag

Kommentarer

Exempel: Formatera två argument

Se även

Gäller för

Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)

Parametrar

Returer

Undantag

Gäller för

Format(IFormatProvider, CompositeFormat, Object[])

Parametrar

Returer

Undantag

Gäller för

Format(String, Object, Object, Object)

Parametrar

Returer

Undantag

Kommentarer

Exempel: Formatera tre argument

Se även

Gäller för

Format(IFormatProvider, String, Object[])

Parametrar

Returer

Undantag

Kommentarer

Exempel: Kulturkänslig formatering

Se även

Gäller för

Format(IFormatProvider, String, Object)

Varför rekommenderar du stränginterpolering över anrop till `String.Format` metoden?