Anpassade datum- och tidsformatsträngar

En datum- och tidsformatsträng definierar textrepresentationen av ett DateTime eller DateTimeOffset -värde som är resultatet av en formateringsåtgärd. Den kan också definiera representationen av ett datum- och tidsvärde som krävs i en parsningsåtgärd för att konvertera strängen till ett datum och en tid. En anpassad formatsträng består av en eller flera anpassade datum- och tidsformatsspecificerare. Alla strängar som inte är en standardsträng för datum- och tidsformat tolkas som en anpassad datum- och tidsformatsträng.

Tips

Du kan ladda ned formateringsverktyget, ett .NET Core-Windows Forms program som gör att du kan använda formatsträngar på numeriska värden eller datum- och tidsvärden och visa resultatsträngen. Källkoden är tillgänglig för C# och Visual Basic.

Anpassade datum- och tidsformatsträngar kan användas med både DateTime och DateTimeOffset värden.

Anteckning

Några av C#-exemplen i den här artikeln körs i Try.NET inline code runner och playground. Välj knappen Kör för att köra ett exempel i ett interaktivt fönster. När du har kört koden kan du ändra den och köra den ändrade koden genom att välja Kör igen. Den ändrade koden körs antingen i det interaktiva fönstret eller, om kompilering misslyckas, visar det interaktiva fönstret alla felmeddelanden från C#-kompilatorn.

Den lokala tidszonenför Try.NET infogad kodkörare och lekplats är Coordinated Universal Time eller UTC. Detta kan påverka beteendet och utdata från exempel som illustrerar typerna DateTime, DateTimeOffsetoch TimeZoneInfo och deras medlemmar.

I formateringsåtgärder kan anpassade datum- och tidsformatsträngar användas antingen med ToString metoden för en datum- och tidsinstans eller med en metod som stöder sammansatt formatering. I följande exempel visas båda användningsområdena.

DateTime thisDate1 = new DateTime(2011, 6, 10);
Console.WriteLine("Today is " + thisDate1.ToString("MMMM dd, yyyy") + ".");

DateTimeOffset thisDate2 = new DateTimeOffset(2011, 6, 10, 15, 24, 16,
                                              TimeSpan.Zero);
Console.WriteLine("The current date and time: {0:MM/dd/yy H:mm:ss zzz}",
                   thisDate2);
// The example displays the following output:
//    Today is June 10, 2011.
//    The current date and time: 06/10/11 15:24:16 +00:00
Dim thisDate1 As Date = #6/10/2011#
Console.WriteLine("Today is " + thisDate1.ToString("MMMM dd, yyyy") + ".")

Dim thisDate2 As New DateTimeOffset(2011, 6, 10, 15, 24, 16, TimeSpan.Zero)
Console.WriteLine("The current date and time: {0:MM/dd/yy H:mm:ss zzz}",
                  thisDate2)
' The example displays the following output:
'    Today is June 10, 2011.
'    The current date and time: 06/10/11 15:24:16 +00:00

Vid parsningsåtgärder kan anpassade datum- och tidsformatsträngar användas med DateTime.ParseExactmetoderna , DateTime.TryParseExact, DateTimeOffset.ParseExactoch DateTimeOffset.TryParseExact . Dessa metoder kräver att en indatasträng exakt överensstämmer med ett visst mönster för att parsningsåtgärden ska lyckas. I följande exempel visas ett anrop till DateTimeOffset.ParseExact(String, String, IFormatProvider) metoden för att parsa ett datum som måste innehålla en dag, en månad och ett tvåsiffrigt år.

using System;
using System.Globalization;

public class Example1
{
    public static void Main()
    {
        string[] dateValues = { "30-12-2011", "12-30-2011",
                              "30-12-11", "12-30-11" };
        string pattern = "MM-dd-yy";
        DateTime parsedDate;

        foreach (var dateValue in dateValues)
        {
            if (DateTime.TryParseExact(dateValue, pattern, null,
                                      DateTimeStyles.None, out parsedDate))
                Console.WriteLine("Converted '{0}' to {1:d}.",
                                  dateValue, parsedDate);
            else
                Console.WriteLine("Unable to convert '{0}' to a date and time.",
                                  dateValue);
        }
    }
}
// The example displays the following output:
//    Unable to convert '30-12-2011' to a date and time.
//    Unable to convert '12-30-2011' to a date and time.
//    Unable to convert '30-12-11' to a date and time.
//    Converted '12-30-11' to 12/30/2011.
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim dateValues() As String = {"30-12-2011", "12-30-2011",
                                        "30-12-11", "12-30-11"}
        Dim pattern As String = "MM-dd-yy"
        Dim parsedDate As Date

        For Each dateValue As String In dateValues
            If DateTime.TryParseExact(dateValue, pattern, Nothing,
                                      DateTimeStyles.None, parsedDate) Then
                Console.WriteLine("Converted '{0}' to {1:d}.",
                                  dateValue, parsedDate)
            Else
                Console.WriteLine("Unable to convert '{0}' to a date and time.",
                                  dateValue)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'    Unable to convert '30-12-2011' to a date and time.
'    Unable to convert '12-30-2011' to a date and time.
'    Unable to convert '30-12-11' to a date and time.
'    Converted '12-30-11' to 12/30/2011.

I följande tabell beskrivs de anpassade datum- och tidsformatsspecificerarna och en resultatsträng som skapas av varje formatspecificerare. Som standard återspeglar resultatsträngarna formateringskonventionerna för en-US-kulturen. Om en viss formatspecificerare skapar en lokaliserad resultatsträng, noterar exemplet även den kultur som resultatsträngen gäller för. Mer information om hur du använder anpassade datum- och tidsformatsträngar finns i avsnittet Anteckningar .

Formatspecificerare Description Exempel
"d" Dagen i månaden, från 1 till 31.

Mer information: Den anpassade formatspecificeraren "d".
2009-06-01T13:45:30 -> 1

2009-06-15T13:45:30 -> 15
"dd" Dagen i månaden, från 01 till 31.

Mer information: Den anpassade formatspecificeraren "dd".
2009-06-01T13:45:30 -> 01

2009-06-15T13:45:30 -> 15
"ddd" Det förkortade namnet på veckodagen.

Mer information: Den anpassade formatspecificeraren "ddd".
2009-06-15T13:45:30 -> Mån (en-US)

2009-06-15T13:45:30 -> Пн (ru-RU)

2009-06-15T13:45:30 -> lun. (fr-FR)
"dddd" Det fullständiga namnet på veckodagen.

Mer information: Den anpassade formatsspecificeraren "ddddd".
2009-06-15T13:45:30 -> Måndag (en-US)

2009-06-15T13:45:30 -> понедельник (ru-RU)

2009-06-15T13:45:30 -> lundi (fr-FR)
"f" Tiondelar av en sekund i ett datum- och tidsvärde.

Mer information: Den anpassade formatspecificeraren "f".
2009-06-15T13:45:30.6170000 -> 6

2009-06-15T13:45:30.05 -> 0
"ff" Hundradelar av en sekund i ett datum- och tidsvärde.

Mer information: Den anpassade formatspecificeraren "ff".
2009-06-15T13:45:30.6170000 -> 61

2009-06-15T13:45:30.0050000 -> 00
"fff" Millisekunderna i ett datum- och tidsvärde.

Mer information: Den anpassade formatspecificeraren "fff".
2009-06-15 13:45:30.617 -> 617

2009-06-15 13:45:30.0005 -> 000
"ffffff" De tio tusendels sekunden i ett datum- och tidsvärde.

Mer information: Den anpassade formatspecificeraren "ffffff".
2009-06-15T13:45:30.6175000 -> 6175

2009-06-15T13:45:30.0000500 -> 0000
"fffff" Hundratusendelar av en sekund i ett datum- och tidsvärde.

Mer information: Den anpassade formatspecificeraren "fffff".
2009-06-15T13:45:30.6175400 -> 61754

2009-06-15 13:45:30.000005 -> 00000
"ffffff" Miljondelar av en sekund i ett datum- och tidsvärde.

Mer information: Den anpassade formatspecificeraren "ffffff".
2009-06-15T13:45:30.6175420 -> 617542

2009-06-15T13:45:30.0000005 -> 000000
"fffffff" De tio miljoner av en sekund i ett datum- och tidsvärde.

Mer information: Den anpassade formatspecificeraren "fffffff".
2009-06-15T13:45:30.6175425 -> 6175425

2009-06-15T13:45:30.0001150 -> 0001150
"F" Om det inte är noll, tiondelar av en sekund i ett datum- och tidsvärde.

Mer information: Den anpassade formatsspecificeraren "F".
2009-06-15T13:45:30.6170000 -> 6

2009-06-15T13:45:30.0500000 -> (inga utdata)
"FF" Om det inte är noll, hundradelar av en sekund i ett datum- och tidsvärde.

Mer information: Den anpassade formatsspecificeraren för "FF".
2009-06-15T13:45:30.6170000 -> 61

2009-06-15T13:45:30.0050000 -> (inga utdata)
"FFF" Om det inte är noll anges millisekunderna i ett datum- och tidsvärde.

Mer information: Den anpassade formatspecificeraren "FFF".
2009-06-15T13:45:30.6170000 -> 617

2009-06-15T13:45:30.0005000 –> (inga utdata)
"FFFF" Om värdet inte är noll är det tiotusendel av en sekund i ett datum- och tidsvärde.

Mer information: Den anpassade formatspecificeraren "FFFF".
2009-06-15T13:45:30.5275000 -> 5275

2009-06-15T13:45:30.0000500 –> (inga utdata)
"FFFFF" Om det inte är noll, hundratusende av en sekund i ett datum- och tidsvärde.

Mer information: Den anpassade formatspecificeraren "FFFFF".
2009-06-15T13:45:30.6175400 -> 61754

2009-06-15T13:45:30.0000050 –> (inga utdata)
"FFFFFF" Om det inte är noll, miljondelarna av en sekund i ett datum- och tidsvärde.

Mer information: Den anpassade formatspecificeraren "FFFFFF".
2009-06-15T13:45:30.6175420 –> 617542

2009-06-15T13:45:30.0000005 –> (inga utdata)
"FFFFFFF" Om det inte är noll är det tio miljoner av en sekund i ett datum- och tidsvärde.

Mer information: Den anpassade formatspecificeraren "FFFFFFF".
2009-06-15T13:45:30.6175425 –> 6175425

2009-06-15T13:45:30.0001150 –> 000115
"g", "gg" Perioden eller eran.

Mer information: Den anpassade formatspecificeraren "g" eller "gg".
2009-06-15T13:45:30.6170000 –> A.D.
"h" Timmen, med en 12-timmarsklocka från 1 till 12.

Mer information: Den anpassade formatspecificeraren "h".
2009-06-15T01:45:30 -> 1

2009-06-15T13:45:30 -> 1
"hh" Timmen, med en 12-timmarsklocka från 01 till 12.

Mer information: Den anpassade formatspecificeraren "hh".
2009-06-15T01:45:30 -> 01

2009-06-15T13:45:30 -> 01
"H" Timmen, med en 24-timmarsklocka från 0 till 23.

Mer information: Den anpassade formatspecificeraren "H".
2009-06-15T01:45:30 -> 1

2009-06-15T13:45:30 -> 13
"HH" Timmen, med en 24-timmarsklocka från 00 till 23.

Mer information: Den anpassade formatspecificeraren för "HH".
2009-06-15T01:45:30 -> 01

2009-06-15T13:45:30 -> 13
"K" Tidszonsinformation.

Mer information: Den anpassade formatspecificeraren "K".
Med DateTime värden:

2009-06-15T13:45:30, Sort ospecificerad ->

2009-06-15T13:45:30, Kind Utc –> Z

2009-06-15T13:45:30, Kind Local –> -07:00 (beror på lokala datorinställningar)

Med DateTimeOffset värden:

2009-06-15T01:45:30-07:00 --> -07:00

2009-06-15T08:45:30+00:00 --> +00:00
"m" Minuten, från 0 till 59.

Mer information: Den anpassade formatspecificeraren "m".
2009-06-15T01:09:30 -> 9

2009-06-15T13:29:30 -> 29
"mm" Minuten, från 00 till 59.

Mer information: Den anpassade formatspecificeraren "mm".
2009-06-15T01:09:30 -> 09

2009-06-15T01:45:30 -> 45
"M" Månaden, från 1 till 12.

Mer information: Specificeraren för anpassat M-format.
2009-06-15T13:45:30 -> 6
"MM" Månaden, från 01 till 12.

Mer information: Den anpassade formatspecificeraren för "MM".
2009-06-15T13:45:30 -> 06
"MMM" Månadens förkortade namn.

Mer information: Den anpassade formatspecificeraren "MMM".
2009-06-15T13:45:30 –> Jun (en-US)

2009-06-15T13:45:30 -> juin (fr-FR)

2009-06-15T13:45:30 -> Jun (zu-ZA)
"MMMM" Månadens fullständiga namn.

Mer information: Den anpassade formatspecificeraren "MMMM".
2009-06-15T13:45:30 –> Juni (en-US)

2009-06-15T13:45:30 –> juni (da-DK)

2009-06-15T13:45:30 -> uJuni (zu-ZA)
"s" Den andra, från 0 till 59.

Mer information: Den anpassade formatspecificeraren "s".
2009-06-15T13:45:09 -> 9
"ss" Den andra, från 00 till 59.

Mer information: Den anpassade formatspecificeraren för "ss".
2009-06-15T13:45:09 -> 09
"t" Det första tecknet i AM/PM-designatorn.

Mer information: Den anpassade formatspecificeraren "t".
2009-06-15T13:45:30 –> P (en-US)

2009-06-15T13:45:30 -> 午 (ja-JP)

2009-06-15T13:45:30 -> (fr-FR)
"tt" AM/PM-designatorn.

Mer information: Den anpassade formatspecificeraren "tt".
2009-06-15T13:45:30 -> PM (en-US)

2009-06-15T13:45:30 -> 午後 (ja-JP)

2009-06-15T13:45:30 -> (fr-FR)
"y" Året, från 0 till 99.

Mer information: Den anpassade formatspecificeraren "y".
0001-01-01T00:00:00 -> 1

0900-01-01T00:00:00 -> 0

1900-01-01T00:00:00 -> 0

2009-06-15T13:45:30 -> 9

2019-06-15T13:45:30 -> 19
"yyy" Året, från 00 till 99.

Mer information: "ååå" anpassad formatspecificerare.
0001-01-01T00:00:00 -> 01

0900-01-01T00:00:00 -> 00

1900-01-01T00:00:00 -> 00

2019-06-15T13:45:30 -> 19
"yyyy" Året med minst tre siffror.

Mer information: Den anpassade formatspecificeraren "åå".
0001-01-01T00:00:00 -> 001

0900-01-01T00:00:00 -> 900

1900-01-01T00:00:00 -> 1900

2009-06-15T13:45:30 -> 2009
"yyyy" Året som ett fyrsiffrigt tal.

Mer information: Den anpassade formatspecificeraren "åååå".
0001-01-01T00:00:00 -> 0001

0900-01-01T00:00:00 -> 0900

1900-01-01T00:00:00 -> 1900

2009-06-15T13:45:30 -> 2009
"yyyyy" Året som ett femsiffrigt tal.

Mer information: Den anpassade formatspecificeraren "ååååå".
0001-01-01T00:00:00 -> 00001

2009-06-15T13:45:30 -> 02009
"z" Timmar förskjutna från UTC, utan inledande nollor.

Mer information: Den anpassade formatspecificeraren "z".
2009-06-15T13:45:30-07:00 -> -7
"zz" Timförskjutning från UTC, med inledande nolla för ett ensiffrigt värde.

Mer information: Den anpassade formatspecificeraren "zz".
2009-06-15T13:45:30-07:00 -> -07
"zzz" Förskjutning av timmar och minuter från UTC.

Mer information: Den anpassade formatspecificeraren "zzz".
2009-06-15T13:45:30-07:00 -> -07:00
":" Tidsavgränsaren.

Mer information: Den ":"Anpassade formatspecificeraren.
2009-06-15T13:45:30 -> : (en-US)

2009-06-15T13:45:30 -> . (it-IT)

2009-06-15T13:45:30 -> : (ja-JP)
"/" Datumavgränsaren.

Mer information: Den anpassade formatspecificeraren "/".
2009-06-15T13:45:30 -> / (en-US)

2009-06-15T13:45:30 -> - (ar-DZ)

2009-06-15T13:45:30 -> . (tr-TR)
"sträng"

"sträng"
Literal sträng avgränsare.

Mer information: Teckenliteraler.
2009-06-15T13:45:30 ("arr:" h:m t) -> arr: 1:45 P

2009-06-15T13:45:30 ('arr:' h:m t) -> arr: 1:45 P
% Definierar följande tecken som en anpassad formatspecificerare.

Mer information:Använda enstaka anpassade formatspecificerare.
2009-06-15T13:45:30 (%h) -> 1
\ Escape-tecknet.

Mer information: Teckenliteraler och Använda Escape-tecknet.
2009-06-15T13:45:30 (h \h) -> 1 h
Andra tecken Tecknet kopieras till resultatsträngen oförändrad.

Mer information: Teckenliteraler.
2009-06-15T01:45:30 (arr hh:mm t) -> arr 01:45 A

Följande avsnitt innehåller ytterligare information om varje anpassad datum- och tidsformatsspecificerare. Om inget annat anges skapar varje specificerare en identisk strängrepresentation oavsett om den används med ett DateTime värde eller ett DateTimeOffset värde.

Formatspecificerare för dag "d"

Den anpassade formatspecificeraren "d"

Den anpassade formatspecificeraren d representerar dagen i månaden som ett tal mellan 1 och 31. En ensiffrig dag formateras utan inledande nolla.

Om formatspecificeraren "d" används utan andra anpassade formatspecificerare tolkas det som standardformatsspecificeraren d. Mer information om hur du använder en enskild formatspecificerare finns i Använda enskilda anpassade formatspecificerare senare i den här artikeln.

I följande exempel ingår den anpassade formatspecificeraren "d" i flera formatsträngar.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("d, M",
                  CultureInfo.InvariantCulture));
// Displays 29, 8

Console.WriteLine(date1.ToString("d MMMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays 29 August
Console.WriteLine(date1.ToString("d MMMM",
                  CultureInfo.CreateSpecificCulture("es-MX")));
// Displays 29 agosto
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("d, M", _
                  CultureInfo.InvariantCulture))
' Displays 29, 8

Console.WriteLine(date1.ToString("d MMMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays 29 August
Console.WriteLine(date1.ToString("d MMMM", _
                  CultureInfo.CreateSpecificCulture("es-MX")))
' Displays 29 agosto                                                

Tillbaka till tabellen

Den anpassade formatspecificeraren "dd"

Den anpassade formatsträngen "dd" representerar dagen i månaden som ett tal mellan 01 och 31. En ensiffrig dag formateras med inledande nolla.

I följande exempel ingår den anpassade formatspecificeraren "dd" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 1, 2, 6, 30, 15);

Console.WriteLine(date1.ToString("dd, MM",
                  CultureInfo.InvariantCulture));
// 02, 01
Dim date1 As Date = #1/2/2008 6:30:15AM#

Console.WriteLine(date1.ToString("dd, MM", _
                  CultureInfo.InvariantCulture))
' 02, 01

Tillbaka till tabellen

Den anpassade formatspecificeraren "ddd"

Den anpassade formatspecificeraren "ddd" representerar det förkortade namnet på veckodagen. Det lokaliserade förkortade namnet på veckodagen hämtas från egenskapen för den DateTimeFormatInfo.AbbreviatedDayNames aktuella eller angivna kulturen.

I följande exempel ingår den anpassade formatspecificeraren "ddd" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("ddd d MMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays ven. 29 août
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("ddd d MMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays ven. 29 août                                                

Tillbaka till tabellen

Den anpassade formatspecificeraren "dddd"

Den anpassade formatspecificeraren "dddd" (plus valfritt antal ytterligare "d"-specificerare) representerar det fullständiga namnet på veckodagen. Det lokaliserade namnet på veckodagen hämtas från DateTimeFormatInfo.DayNames egenskapen för den aktuella eller angivna kulturen.

I följande exempel ingår den anpassade formatspecificeraren "dddd" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("dddd dd MMMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM",
                  CultureInfo.CreateSpecificCulture("it-IT")));
// Displays venerdì 29 agosto
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("dddd dd MMMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM", _
                  CultureInfo.CreateSpecificCulture("it-IT")))
' Displays venerdì 29 agosto                                          

Tillbaka till tabellen

Gemener sekunder "f" bråkspecificerare

Den anpassade formatspecificeraren "f"

Den anpassade formatspecificeraren "f" representerar den viktigaste siffran i sekundfraktionen. Det innebär att den representerar tiondelar av en sekund i ett datum- och tidsvärde.

Om formatspecificeraren "f" används utan andra formatspecificerare tolkas den som standardformatsspecificeraren "f". Mer information om hur du använder en enskild formatspecificerare finns i Använda enskilda anpassade formatspecificerare senare i den här artikeln.

När du använder "f"-formatspecificerare som en del av en formatsträng som anges till ParseExactmetoden , TryParseExact, ParseExacteller TryParseExact anger antalet "f"-formatspecificerare antalet signifikanta siffror i sekundfraktionen som måste finnas för att strängen ska kunna parsas.

I följande exempel ingår den anpassade formatspecificeraren "f" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Tillbaka till tabellen

Den anpassade formatspecificeraren "ff"

Den anpassade formatspecificeraren "ff" representerar de två viktigaste siffrorna i sekundfraktionen. Det innebär att den representerar hundradelar av en sekund i ett datum- och tidsvärde.

i följande exempel ingår den anpassade formatspecificeraren "ff" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Tillbaka till tabellen

Den anpassade formatspecificeraren "fff"

Den anpassade formatspecificeraren "fff" representerar de tre viktigaste siffrorna i sekundfraktionen. Det innebär att den representerar millisekunderna i ett datum- och tidsvärde.

I följande exempel ingår den anpassade formatspecificeraren "fff" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Tillbaka till tabellen

Den anpassade formatspecificeraren "ffff"

Den anpassade formatspecificeraren "ffff" representerar de fyra viktigaste siffrorna i sekundfraktionen. Det innebär att den representerar de tio tusendelarna av en sekund i ett datum- och tidsvärde.

Även om det är möjligt att visa de tio tusendelarna av en andra komponent i ett tidsvärde, kanske det värdet inte är meningsfullt. Precisionen för datum- och tidsvärden beror på systemklockans upplösning. På Windows NT version 3.5 (och senare) och Windows Vista operativsystem, klockans upplösning är cirka 10-15 millisekunder.

Tillbaka till tabellen

Den anpassade formatspecificeraren "fffff"

Den anpassade formatspecificeraren "fffff" representerar de fem viktigaste siffrorna i sekundfraktionen. Det innebär att den representerar hundratusendelar av en sekund i ett datum- och tidsvärde.

Även om det är möjligt att visa hundra tusendelar av en andra komponent i ett tidsvärde, är det värdet kanske inte meningsfullt. Precisionen för datum- och tidsvärden beror på systemklockans upplösning. På Windows NT 3.5 (och senare) och Windows Vista-operativsystem är klockans upplösning cirka 10–15 millisekunder.

Tillbaka till tabellen

Den anpassade formatspecificeraren "ffffff"

Den anpassade formatspecificeraren "ffffff" representerar de sex viktigaste siffrorna i sekundfraktionen. Det innebär att den representerar miljondelarna av en sekund i ett datum- och tidsvärde.

Även om det är möjligt att visa miljondelarna av en andra komponent i ett tidsvärde kanske det värdet inte är meningsfullt. Precisionen för datum- och tidsvärden beror på systemklockans upplösning. På Windows NT 3.5 (och senare) och Windows Vista-operativsystem är klockans upplösning cirka 10–15 millisekunder.

Tillbaka till tabellen

Den anpassade formatspecificeraren "fffffff"

Den anpassade formatspecificeraren "fffffff" representerar de sju viktigaste siffrorna i sekundfraktionen. Det innebär att den representerar de tio miljonerdelarna av en sekund i ett datum- och tidsvärde.

Även om det är möjligt att visa de tio miljoner av en andra komponent i ett tidsvärde, kanske det värdet inte är meningsfullt. Precisionen för datum- och tidsvärden beror på systemklockans upplösning. På Windows NT 3.5 (och senare) och Windows Vista-operativsystem är klockans upplösning cirka 10–15 millisekunder.

Tillbaka till tabellen

Bråkspecificerare för versaler i sekunder "F"

Den anpassade formatspecificeraren "F"

Den anpassade formatspecificeraren "F" representerar den viktigaste siffran i sekundfraktionen. Det innebär att den representerar tiondelar av en sekund i ett datum- och tidsvärde. Ingenting visas om siffran är noll, och decimaltecknet som följer antalet sekunder visas inte heller.

Om formatspecificeraren "F" används utan andra formatspecificerare tolkas den som standardformatsspecificeraren "F". Mer information om hur du använder en enskild formatspecificerare finns i Använda enskilda anpassade formatspecificerare senare i den här artikeln.

Antalet "F"-formatspecificerare som används med ParseExactmetoden , TryParseExact, ParseExacteller TryParseExact anger det maximala antalet av de viktigaste siffrorna i sekundfraktionen som kan finnas för att parsa strängen.

I följande exempel ingår den anpassade formatspecificeraren "F" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Tillbaka till tabellen

Den anpassade formatspecificeraren "FF"

Den anpassade formatspecificeraren "FF" representerar de två viktigaste siffrorna i sekundfraktionen. Det innebär att den representerar hundradelar av en sekund i ett datum- och tidsvärde. Avslutande nollor visas inte. Ingenting visas om de två signifikanta siffrorna är noll, och i så fall visas inte heller decimaltecknet som följer antalet sekunder.

I följande exempel ingår den anpassade formatspecificeraren "FF" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Tillbaka till tabellen

Den anpassade formatspecificeraren "FFF"

Den anpassade formatspecificeraren "FFF" representerar de tre viktigaste siffrorna i sekundfraktionen. Det innebär att den representerar millisekunderna i ett datum- och tidsvärde. Avslutande nollor visas inte. Ingenting visas om de tre signifikanta siffrorna är noll, och i så fall visas inte heller decimaltecknet som följer antalet sekunder.

I följande exempel ingår den anpassade formatspecificeraren "FFF" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);
CultureInfo ci = CultureInfo.InvariantCulture;

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Dim date1 As New Date(2008, 8, 29, 19, 27, 15, 018)
Dim ci As CultureInfo = CultureInfo.InvariantCulture

Console.WriteLine(date1.ToString("hh:mm:ss.f", ci))
' Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci))
' Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci))
' Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci))
' Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci))
' Displays 07:27:15.018

Tillbaka till tabellen

Den anpassade formatspecificeraren "FFFF"

Den anpassade formatspecificeraren "FFFF" representerar de fyra viktigaste siffrorna i sekundfraktionen. Det innebär att den representerar de tio tusendelarna av en sekund i ett datum- och tidsvärde. Avslutande nollor visas inte. Ingenting visas om de fyra signifikanta siffrorna är noll, och i så fall visas inte heller decimaltecknet som följer antalet sekunder.

Även om det är möjligt att visa de tio tusendelarna av en andra komponent i ett tidsvärde, kanske det värdet inte är meningsfullt. Precisionen för datum- och tidsvärden beror på systemklockans upplösning. På Windows NT 3.5 (och senare) och Windows Vista-operativsystem är klockans upplösning cirka 10–15 millisekunder.

Tillbaka till tabellen

Den anpassade formatspecificeraren "FFFFF"

Den anpassade formatspecificeraren "FFFFF" representerar de fem viktigaste siffrorna i sekundfraktionen. Det innebär att den representerar hundratusendelar av en sekund i ett datum- och tidsvärde. Avslutande nollor visas inte. Ingenting visas om de fem signifikanta siffrorna är noll, och i så fall visas inte heller decimaltecknet som följer antalet sekunder.

Även om det är möjligt att visa hundra tusendelar av en andra komponent i ett tidsvärde, är det värdet kanske inte meningsfullt. Precisionen för datum- och tidsvärden beror på systemklockans upplösning. På Windows NT 3.5 (och senare) och Windows Vista-operativsystem är klockans upplösning cirka 10–15 millisekunder.

Tillbaka till tabellen

Den anpassade formatspecificeraren "FFFFFF"

Den anpassade formatspecificeraren "FFFFFF" representerar de sex viktigaste siffrorna i sekundfraktionen. Det innebär att den representerar miljondelarna av en sekund i ett datum- och tidsvärde. Avslutande nollor visas inte. Ingenting visas om de sex signifikanta siffrorna är noll, och i så fall visas inte heller decimaltecknet som följer antalet sekunder.

Även om det är möjligt att visa miljondelarna av en andra komponent i ett tidsvärde kanske det värdet inte är meningsfullt. Precisionen för datum- och tidsvärden beror på systemklockans upplösning. På Windows NT 3.5 (och senare) och Windows Vista-operativsystem är klockans upplösning cirka 10–15 millisekunder.

Tillbaka till tabellen

Den anpassade formatspecificeraren "FFFFFFF"

Den anpassade formatspecificeraren "FFFFFFF" representerar de sju viktigaste siffrorna i sekundfraktionen. Det innebär att den representerar de tio miljonerdelarna av en sekund i ett datum- och tidsvärde. Avslutande nollor visas inte. Ingenting visas om de sju signifikanta siffrorna är noll, och i så fall visas inte heller decimaltecknet som följer antalet sekunder.

Även om det är möjligt att visa de tio miljoner av en andra komponent i ett tidsvärde, kanske det värdet inte är meningsfullt. Precisionen för datum- och tidsvärden beror på systemklockans upplösning. På Windows NT 3.5 (och senare) och Windows Vista-operativsystem är klockans upplösning cirka 10–15 millisekunder.

Tillbaka till tabellen

Formatspecificerare för era "g"

Den anpassade formatspecificeraren "g" eller "gg"

De anpassade formatspecificerarna "g" eller "gg" (plus valfritt antal ytterligare "g"-specificerare) representerar perioden eller eran, till exempel A.D. Formateringsåtgärden ignorerar den här specificeraren om datumet som ska formateras inte har någon associerad period- eller erasträng.

Om "g"-formatspecificeraren används utan andra anpassade formatspecificerare tolkas det som standardformatsspecificeraren "g". Mer information om hur du använder en enskild formatspecificerare finns i Using Single Custom Format Specifiers (Använda enstaka anpassade formatspecificerare ) senare i den här artikeln.

I följande exempel ingår den anpassade formatspecificeraren "g" i en anpassad formatsträng.

DateTime date1 = new DateTime(70, 08, 04);

Console.WriteLine(date1.ToString("MM/dd/yyyy g",
                  CultureInfo.InvariantCulture));
// Displays 08/04/0070 A.D.
Console.WriteLine(date1.ToString("MM/dd/yyyy g",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 08/04/0070 ap. J.-C.
Dim date1 As Date = #08/04/0070#

Console.WriteLine(date1.ToString("MM/dd/yyyy g", _
                  CultureInfo.InvariantCulture))
' Displays 08/04/0070 A.D.                        
Console.WriteLine(date1.ToString("MM/dd/yyyy g", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 08/04/0070 ap. J.-C.

Tillbaka till tabellen

Formatspecificerare för gementtimmesformatet "h"

Den anpassade formatspecificeraren "h"

Den anpassade formatspecificeraren "h" representerar timmen som ett tal mellan 1 och 12. Det innebär att timmen representeras av en 12-timmarsklocka som räknar hela timmarna sedan midnatt eller 12.00. En viss timme efter midnatt kan inte skiljas från samma timme efter middagstid. Timmen avrundas inte och en ensiffrig timme formateras utan inledande nolla. Till exempel, med en tid på 5:43 på morgonen eller eftermiddagen, visar den här anpassade formatspecificeraren "5".

Om formatspecificeraren "h" används utan andra anpassade formatspecificerare tolkas det som en standardspecificerare för datum- och tidsformat och genererar en FormatException. Mer information om hur du använder en enskild formatspecificerare finns i Using Single Custom Format Specifiers (Använda enstaka anpassade formatspecificerare ) senare i den här artikeln.

I följande exempel ingår den anpassade formatspecificeraren "h" i en anpassad formatsträng.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1 µ                        
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1.5 µ

Tillbaka till tabellen

Den anpassade formatspecificeraren "hh"

Den anpassade formatspecificeraren "hh" (plus valfritt antal ytterligare "h"-specificerare) representerar timmen som ett tal mellan 01 och 12. Det innebär att timmen representeras av en 12-timmarsklocka som räknar hela timmarna sedan midnatt eller 12.00. En viss timme efter midnatt kan inte skiljas från samma timme efter middagstid. Timmen avrundas inte och en ensiffrig timme formateras med inledande nolla. Till exempel, med en tid på 5:43 på morgonen eller eftermiddagen, visar den här formatspecificeraren "05".

I följande exempel ingår den anpassade formatspecificeraren "hh" i en anpassad formatsträng.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01 du.
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01.50 du.

Tillbaka till tabellen

Formatspecificerare för versaltimmen "H"

Den anpassade formatspecificeraren "H"

Den anpassade formatspecificeraren "H" representerar timmen som ett tal mellan 0 och 23. Det innebär att timmen representeras av en nollbaserad 24-timmarsklocka som räknar timmarna sedan midnatt. En ensiffrig timme formateras utan inledande nolla.

Om "H"-formatspecificeraren används utan andra anpassade formatspecificerare tolkas det som en standardspecificerare för datum- och tidsformat och genererar en FormatException. Mer information om hur du använder en enskild formatspecificerare finns i Using Single Custom Format Specifiers (Använda enstaka anpassade formatspecificerare ) senare i den här artikeln.

I följande exempel ingår den anpassade formatspecificeraren "H" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 1, 1, 6, 9, 1);
Console.WriteLine(date1.ToString("H:mm:ss",
                  CultureInfo.InvariantCulture));
// Displays 6:09:01
Dim date1 As Date = #6:09:01AM#
Console.WriteLine(date1.ToString("H:mm:ss", _
                  CultureInfo.InvariantCulture))
' Displays 6:09:01                        

Tillbaka till tabellen

Den anpassade formatspecificeraren "HH"

Den anpassade formatspecificeraren "HH" (plus valfritt antal ytterligare "H"-specificerare) representerar timmen som ett tal mellan 00 och 23. Det innebär att timmen representeras av en nollbaserad 24-timmarsklocka som räknar timmarna sedan midnatt. En ensiffrig timme formateras med inledande nolla.

I följande exempel ingår den anpassade formatspecificeraren "HH" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 1, 1, 6, 9, 1);
Console.WriteLine(date1.ToString("HH:mm:ss",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01
Dim date1 As Date = #6:09:01AM#
Console.WriteLine(date1.ToString("HH:mm:ss", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01                        

Tillbaka till tabellen

Time zone "K"-formatspecificerare

Den anpassade formatspecificeraren "K"

Den anpassade formatspecificeraren "K" representerar tidszonsinformationen för ett datum- och tidsvärde. När formatspecificeraren används med DateTime värden definieras resultatsträngen av värdet för DateTime.Kind egenskapen:

För DateTimeOffset värden motsvarar "K"-formatspecificeraren "zzz"-formatspecificeraren och genererar en resultatsträng som innehåller DateTimeOffset värdets förskjutning från UTC.

Om "K"-formatspecificeraren används utan andra anpassade formatspecificerare tolkas det som en standardspecificerare för datum- och tidsformat och genererar en FormatException. Mer information om hur du använder en enskild formatspecificerare finns i Using Single Custom Format Specifiers (Använda enstaka anpassade formatspecificerare ) senare i den här artikeln.

I följande exempel visas strängen som är resultatet av att använda den anpassade formatspecificeraren "K" med olika DateTime värden och DateTimeOffset i ett system i tidszonen USA Stillahavsområdet.

Console.WriteLine(DateTime.Now.ToString("%K"));
// Displays -07:00
Console.WriteLine(DateTime.UtcNow.ToString("%K"));
// Displays Z
Console.WriteLine("'{0}'",
                  DateTime.SpecifyKind(DateTime.Now,
                       DateTimeKind.Unspecified).ToString("%K"));
// Displays ''
Console.WriteLine(DateTimeOffset.Now.ToString("%K"));
// Displays -07:00
Console.WriteLine(DateTimeOffset.UtcNow.ToString("%K"));
// Displays +00:00
Console.WriteLine(new DateTimeOffset(2008, 5, 1, 6, 30, 0,
                      new TimeSpan(5, 0, 0)).ToString("%K"));
// Displays +05:00
Console.WriteLine(Date.Now.ToString("%K"))
' Displays -07:00
Console.WriteLine(Date.UtcNow.ToString("%K"))
' Displays Z      
Console.WriteLine("'{0}'", _
                  Date.SpecifyKind(Date.Now, _
                                   DateTimeKind.Unspecified). _
                  ToString("%K"))
' Displays ''      
Console.WriteLine(DateTimeOffset.Now.ToString("%K"))
' Displays -07:00
Console.WriteLine(DateTimeOffset.UtcNow.ToString("%K"))
' Displays +00:00
Console.WriteLine(New DateTimeOffset(2008, 5, 1, 6, 30, 0, _
                                     New TimeSpan(5, 0, 0)). _
                  ToString("%K"))
' Displays +05:00                        

Tillbaka till tabellen

Minutformatsspecificerare för "m"

Den anpassade formatspecificeraren "m"

Den anpassade formatspecificeraren "m" representerar minuten som ett tal mellan 0 och 59. Minuten representerar hela minuter som har passerat sedan den senaste timmen. En ensiffrig minut formateras utan inledande nolla.

Om formatspecificeraren "m" används utan andra anpassade formatspecificerare tolkas det som standardformatsspecificeraren "m". Mer information om hur du använder en enskild formatspecificerare finns i Using Single Custom Format Specifiers (Använda enstaka anpassade formatspecificerare ) senare i den här artikeln.

I följande exempel ingår den anpassade formatspecificeraren "m" i en anpassad formatsträng.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1 µ                        
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1.5 µ

Tillbaka till tabellen

Den anpassade formatspecificeraren "mm"

Den anpassade formatspecificeraren "mm" (plus valfritt antal ytterligare "m"-specificerare) representerar minuten som ett tal mellan 00 och 59. Minuten representerar hela minuter som har passerat sedan den senaste timmen. En ensiffrig minut formateras med inledande nolla.

I följande exempel ingår den anpassade formatspecificeraren "mm" i en anpassad formatsträng.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01 du.
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01.50 du.

Tillbaka till tabellen

Month "M"-formatspecificerare

Den anpassade formatspecificeraren "M"

Den anpassade formatspecificeraren "M" representerar månaden som ett tal mellan 1 och 12 (eller från 1 till 13 för kalendrar som har 13 månader). En ensiffrig månad formateras utan inledande nolla.

Om "M"-formatspecificeraren används utan andra anpassade formatspecificerare tolkas det som standardformatsspecificeraren "M". Mer information om hur du använder en enskild formatspecificerare finns i Using Single Custom Format Specifiers (Använda enstaka anpassade formatspecificerare ) senare i den här artikeln.

I följande exempel ingår den anpassade formatspecificeraren "M" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 8, 18);
Console.WriteLine(date1.ToString("(M) MMM, MMMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays (8) Aug, August
Console.WriteLine(date1.ToString("(M) MMM, MMMM",
                  CultureInfo.CreateSpecificCulture("nl-NL")));
// Displays (8) aug, augustus
Console.WriteLine(date1.ToString("(M) MMM, MMMM",
                  CultureInfo.CreateSpecificCulture("lv-LV")));
// Displays (8) Aug, augusts
Dim date1 As Date = #8/18/2008#
Console.WriteLine(date1.ToString("(M) MMM, MMMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays (8) Aug, August
Console.WriteLine(date1.ToString("(M) MMM, MMMM", _
                  CultureInfo.CreateSpecificCulture("nl-NL")))
' Displays (8) aug, augustus
Console.WriteLine(date1.ToString("(M) MMM, MMMM", _
                  CultureInfo.CreateSpecificCulture("lv-LV")))
' Displays (8) Aug, augusts                       

Tillbaka till tabellen

Den anpassade formatspecificeraren "MM"

Den anpassade formatspecificeraren "MM" representerar månaden som ett tal mellan 01 och 12 (eller från 1 till 13 för kalendrar som har 13 månader). En ensiffrig månad formateras med inledande nolla.

I följande exempel ingår den anpassade formatspecificeraren "MM" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 1, 2, 6, 30, 15);

Console.WriteLine(date1.ToString("dd, MM",
                  CultureInfo.InvariantCulture));
// 02, 01
Dim date1 As Date = #1/2/2008 6:30:15AM#

Console.WriteLine(date1.ToString("dd, MM", _
                  CultureInfo.InvariantCulture))
' 02, 01

Tillbaka till tabellen

Den anpassade formatspecificeraren "MMM"

Den anpassade formatspecificeraren "MMM" representerar månadens förkortade namn. Det lokaliserade förkortade namnet på månaden hämtas från DateTimeFormatInfo.AbbreviatedMonthNames egenskapen för den aktuella eller angivna kulturen.

I följande exempel ingår den anpassade formatspecificeraren "MMM" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("ddd d MMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays ven. 29 août
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("ddd d MMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Fri 29 Aug
Console.WriteLine(date1.ToString("ddd d MMM", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays ven. 29 août                                                

Tillbaka till tabellen

Den anpassade formatspecificeraren "MMMM"

Den anpassade formatspecificeraren "MMMM" representerar månadens fullständiga namn. Månadens lokaliserade namn hämtas från DateTimeFormatInfo.MonthNames egenskapen för den aktuella eller angivna kulturen.

I följande exempel ingår den anpassade formatspecificeraren "MMMM" i en anpassad formatsträng.

DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15);

Console.WriteLine(date1.ToString("dddd dd MMMM",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM",
                  CultureInfo.CreateSpecificCulture("it-IT")));
// Displays venerdì 29 agosto
Dim date1 As Date = #08/29/2008 7:27:15PM#

Console.WriteLine(date1.ToString("dddd dd MMMM", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Friday 29 August
Console.WriteLine(date1.ToString("dddd dd MMMM", _
                  CultureInfo.CreateSpecificCulture("it-IT")))
' Displays venerdì 29 agosto                                          

Tillbaka till tabellen

Sekundformatsspecificerare

Den anpassade formatspecificeraren "s"

Den anpassade formatspecificeraren "s" representerar sekunderna som ett tal mellan 0 och 59. Resultatet representerar hela sekunder som har passerat sedan den senaste minuten. En ensiffrig sekund formateras utan inledande nolla.

Om formatspecificeraren "s" används utan andra anpassade formatspecificerare tolkas det som standardspecificeraren för datum- och tidsformat för "s". Mer information om hur du använder en enskild formatspecificerare finns i Using Single Custom Format Specifiers (Använda enstaka anpassade formatspecificerare ) senare i den här artikeln.

I följande exempel ingår den anpassade formatspecificeraren "s" i en anpassad formatsträng.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1 µ                        
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1.5 µ

Tillbaka till tabellen

Den anpassade formatspecificeraren "ss"

Den anpassade formatspecificeraren "ss" (plus valfritt antal ytterligare "s"-specificerare) representerar sekunderna som ett tal mellan 00 och 59. Resultatet representerar hela sekunder som har passerat sedan den senaste minuten. En ensiffrig sekund formateras med inledande nolla.

I följande exempel ingår den anpassade formatspecificeraren "ss" i en anpassad formatsträng.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01 du.
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01.50 du.

Tillbaka till tabellen

Formatspecificerare för Meridiem "t"

Den anpassade formatspecificeraren "t"

Den anpassade formatspecificeraren "t" representerar det första tecknet i AM/PM-designatorn. Lämplig lokaliserad designator hämtas från DateTimeFormatInfo.AMDesignator egenskapen eller DateTimeFormatInfo.PMDesignator för den aktuella eller specifika kulturen. AM-designatorn används för alla tider från 0:00:00 (midnatt) till 11:59:59.999. PM-designatorn används för alla tider från 12:00:00 (12:00) till 23:59:59.999.

Om formatspecificeraren "t" används utan andra anpassade formatspecificerare tolkas det som standardformatsspecificeraren "t". Mer information om hur du använder en enskild formatspecificerare finns i Använda enskilda anpassade formatspecificerare senare i den här artikeln.

I följande exempel ingår den anpassade formatspecificeraren "t" i en anpassad formatsträng.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.InvariantCulture));
// Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t",
                  CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1.5 µ
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1 µ                        
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.InvariantCulture))
' Displays 6:9:1.5 P
Console.WriteLine(date1.ToString("h:m:s.F t", _
                  CultureInfo.CreateSpecificCulture("el-GR")))
' Displays 6:9:1.5 µ

Tillbaka till tabellen

Den anpassade formatspecificeraren "tt"

Den anpassade formatspecificeraren "tt" (plus valfritt antal ytterligare "t"-specificerare) representerar hela AM/PM-designatorn. Lämplig lokaliserad designator hämtas från DateTimeFormatInfo.AMDesignator egenskapen eller DateTimeFormatInfo.PMDesignator för den aktuella eller specifika kulturen. AM-designatorn används för alla tider från 0:00:00 (midnatt) till 11:59:59.999. PM-designatorn används för alla tider från 12:00:00 (12:00) till 23:59:59.999.

Se till att använda "tt"-specificeraren för språk som det är nödvändigt att upprätthålla skillnaden mellan AM och PM. Ett exempel är japanska, där am- och PM-designern skiljer sig åt i det andra tecknet i stället för det första tecknet.

I följande exempel ingår den anpassade formatspecificeraren "tt" i en anpassad formatsträng.

DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01 PM
Console.WriteLine(date1.ToString("hh:mm:ss tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.InvariantCulture));
// Displays 06:09:01.50 PM
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
                  CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01.50 du.
Dim date1 As Date
date1 = #6:09:01PM#
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01 du.
date1 = New Date(2008, 1, 1, 18, 9, 1, 500)
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.InvariantCulture))
' Displays 06:09:01.50 PM                        
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt", _
                  CultureInfo.CreateSpecificCulture("hu-HU")))
' Displays 06:09:01.50 du.

Tillbaka till tabellen

Formatspecificerare för år "y"

Den anpassade formatspecificeraren "y"

Den anpassade formatspecificeraren "y" representerar året som ett ensiffrigt eller tvåsiffrigt tal. Om året har fler än två siffror visas endast de två lågordningssiffrorna i resultatet. Om den första siffran i ett tvåsiffrigt år börjar med en nolla (till exempel 2008) formateras talet utan inledande nolla.

Om formatspecificeraren "y" används utan andra anpassade formatspecificerare tolkas den som standardspecificeraren för datum- och tidsformatet "y". Mer information om hur du använder en enskild formatspecificerare finns i Använda enskilda anpassade formatspecificerare senare i den här artikeln.

I följande exempel ingår den anpassade formatspecificeraren "y" i en anpassad formatsträng.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Tillbaka till tabellen

Den anpassade formatspecificeraren "yy"

Den anpassade formatspecificeraren "yy" representerar året som ett tvåsiffrigt tal. Om året har fler än två siffror visas endast de två lågordningssiffrorna i resultatet. Om det tvåsiffriga året har färre än två signifikanta siffror, är talet vadderat med inledande nollor för att producera två siffror.

I en parsningsåtgärd tolkas ett tvåsiffrigt år som parsas med den anpassade formatspecificeraren "yy" baserat på Calendar.TwoDigitYearMax egenskapen för formatproviderns aktuella kalender. I följande exempel parsas strängrepresentationen av ett datum som har ett tvåsiffrigt år med hjälp av den gregorianska standardkalendern för kulturen en-US, som i det här fallet är den aktuella kulturen. Den ändrar sedan den aktuella kulturens CultureInfo objekt så att det använder ett GregorianCalendar objekt vars TwoDigitYearMax egenskap har ändrats.

using System;
using System.Globalization;
using System.Threading;

public class Example7
{
    public static void Main()
    {
        string fmt = "dd-MMM-yy";
        string value = "24-Jan-49";

        Calendar cal = (Calendar)CultureInfo.CurrentCulture.Calendar.Clone();
        Console.WriteLine("Two Digit Year Range: {0} - {1}",
                          cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax);

        Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, null));
        Console.WriteLine();

        cal.TwoDigitYearMax = 2099;
        CultureInfo culture = (CultureInfo)CultureInfo.CurrentCulture.Clone();
        culture.DateTimeFormat.Calendar = cal;
        Thread.CurrentThread.CurrentCulture = culture;

        Console.WriteLine("Two Digit Year Range: {0} - {1}",
                          cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax);
        Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, null));
    }
}
// The example displays the following output:
//       Two Digit Year Range: 1930 - 2029
//       1/24/1949
//
//       Two Digit Year Range: 2000 - 2099
//       1/24/2049
Imports System.Globalization
Imports System.Threading

Module Example
    Public Sub Main()
        Dim fmt As String = "dd-MMM-yy"
        Dim value As String = "24-Jan-49"

        Dim cal As Calendar = CType(CultureInfo.CurrentCulture.Calendar.Clone(), Calendar)
        Console.WriteLine("Two Digit Year Range: {0} - {1}",
                          cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax)

        Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, Nothing))
        Console.WriteLine()

        cal.TwoDigitYearMax = 2099
        Dim culture As CultureInfo = CType(CultureInfo.CurrentCulture.Clone(), CultureInfo)
        culture.DateTimeFormat.Calendar = cal
        Thread.CurrentThread.CurrentCulture = culture

        Console.WriteLine("Two Digit Year Range: {0} - {1}",
                          cal.TwoDigitYearMax - 99, cal.TwoDigitYearMax)
        Console.WriteLine("{0:d}", DateTime.ParseExact(value, fmt, Nothing))
    End Sub
End Module
' The example displays the following output:
'       Two Digit Year Range: 1930 - 2029
'       1/24/1949
'       
'       Two Digit Year Range: 2000 - 2099
'       1/24/2049

I följande exempel ingår den anpassade formatspecificeraren "yy" i en anpassad formatsträng.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Tillbaka till tabellen

Den anpassade formatspecificeraren "ååå"

Den anpassade formatspecificeraren "åå" representerar året med minst tre siffror. Om året har fler än tre signifikanta siffror inkluderas de i resultatsträngen. Om året har färre än tre siffror är talet vadderat med inledande nollor för att producera tre siffror.

Anteckning

För den thailändska buddhistiska kalendern, som kan ha femsiffriga år, visar den här formatspecificeraren alla viktiga siffror.

I följande exempel ingår den anpassade formatspecificeraren "ååå" i en anpassad formatsträng.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Tillbaka till tabellen

Den anpassade formatspecificeraren "åååå"

Den anpassade formatspecificeraren "åååå" representerar året med minst fyra siffror. Om året har fler än fyra signifikanta siffror inkluderas de i resultatsträngen. Om året har färre än fyra siffror är talet vadderat med inledande nollor för att producera fyra siffror.

Anteckning

För den thailändska buddhistiska kalendern, som kan ha femsiffriga år, visar den här formatspecificeraren minst fyra siffror.

I följande exempel ingår den anpassade formatspecificeraren "åååå" i en anpassad formatsträng.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Tillbaka till tabellen

Den anpassade formatspecificeraren "ååååå"

Den anpassade formatspecificeraren "ååååå" (plus valfritt antal ytterligare "y"-specificerare) representerar året med minst fem siffror. Om året har fler än fem signifikanta siffror inkluderas de i resultatsträngen. Om året har färre än fem siffror är talet vadderat med inledande nollor för att producera fem siffror.

Om det finns ytterligare "y"-specificerare, är talet vadderat med så många inledande nollor som behövs för att producera antalet "y"-specificerare.

I följande exempel ingår den anpassade formatspecificeraren "ååååå" i en anpassad formatsträng.

DateTime date1 = new DateTime(1, 12, 1);
DateTime date2 = new DateTime(2010, 1, 1);
Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
Console.WriteLine(date2.ToString("%y"));
// Displays 10
Console.WriteLine(date2.ToString("yy"));
// Displays 10
Console.WriteLine(date2.ToString("yyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyy"));
// Displays 2010
Console.WriteLine(date2.ToString("yyyyy"));
// Displays 02010
Dim date1 As Date = #12/1/0001#
Dim date2 As Date = #1/1/2010#
Console.WriteLine(date1.ToString("%y"))
' Displays 1
Console.WriteLine(date1.ToString("yy"))
' Displays 01
Console.WriteLine(date1.ToString("yyy"))
' Displays 001
Console.WriteLine(date1.ToString("yyyy"))
' Displays 0001
Console.WriteLine(date1.ToString("yyyyy"))
' Displays 00001
Console.WriteLine(date2.ToString("%y"))
' Displays 10
Console.WriteLine(date2.ToString("yy"))
' Displays 10
Console.WriteLine(date2.ToString("yyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyy"))
' Displays 2010      
Console.WriteLine(date2.ToString("yyyyy"))
' Displays 02010      

Tillbaka till tabellen

Offset "z"-formatspecificerare

Den anpassade formatspecificeraren "z"

Med DateTime värden representerar den anpassade formatspecificeraren "z" den signerade förskjutningen för den angivna tidszonen från Coordinated Universal Time (UTC), mätt i timmar. Förskjutningen visas alltid med ett inledande tecken. Ett plustecken (+) anger timmar före UTC och ett minustecken (-) anger timmar bakom UTC. En ensiffrig förskjutning formateras utan inledande nolla.

Följande tabell visar hur förskjutningsvärdet ändras beroende på DateTimeKind.

DateTimeKind Värde Förskjutet värde
Local Den signerade förskjutningen av det lokala operativsystemets tidszon från UTC.
Unspecified Den signerade förskjutningen av det lokala operativsystemets tidszon från UTC.
Utc +0 på .NET Core och .NET 5+.

På .NET Framework, den signerade förskjutningen av det lokala operativsystemets tidszon från UTC.

Med DateTimeOffset värden representerar DateTimeOffset den här formatspecificeraren värdets förskjutning från UTC i timmar.

Om formatspecificeraren "z" används utan andra anpassade formatspecificerare tolkas det som en standardspecificerare för datum- och tidsformat och genererar en FormatException. Mer information om hur du använder en enskild formatspecificerare finns i Använda enskilda anpassade formatspecificerare senare i den här artikeln.

I följande exempel ingår den anpassade formatspecificeraren "z" i en anpassad formatsträng.

DateTime date1 = DateTime.UtcNow;
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date1));
// Displays -7, -07, -07:00 on .NET Framework
// Displays +0, +00, +00:00 on .NET Core and .NET 5+

DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0,
                                          new TimeSpan(6, 0, 0));
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date2));
// Displays +6, +06, +06:00
Dim date1 As Date = Date.UtcNow
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date1))
' Displays -7, -07, -07:00 on .NET Framework
' Displays +0, +00, +00:00 on .NET Core and .NET 5+

Dim date2 As New DateTimeOffset(2008, 8, 1, 0, 0, 0, _
                                New Timespan(6, 0, 0))
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date2))
' Displays +6, +06, +06:00

Tillbaka till tabellen

Den anpassade formatspecificeraren "zz"

Med DateTime värden representerar den anpassade formatspecificeraren "zz" den signerade förskjutningen för den angivna tidszonen från UTC, mätt i timmar. Förskjutningen visas alltid med ett inledande tecken. Ett plustecken (+) anger timmar före UTC och ett minustecken (-) anger timmar bakom UTC. En ensiffrig förskjutning formateras med inledande nolla.

Följande tabell visar hur förskjutningsvärdet ändras beroende på DateTimeKind.

DateTimeKind Värde Förskjutet värde
Local Den signerade förskjutningen av det lokala operativsystemets tidszon från UTC.
Unspecified Den signerade förskjutningen av det lokala operativsystemets tidszon från UTC.
Utc +00 på .NET Core och .NET 5+.

På .NET Framework, den signerade förskjutningen av det lokala operativsystemets tidszon från UTC.

Med DateTimeOffset värden representerar DateTimeOffset den här formatspecificeraren värdets förskjutning från UTC i timmar.

I följande exempel ingår den anpassade formatspecificeraren "zz" i en anpassad formatsträng.

DateTime date1 = DateTime.UtcNow;
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date1));
// Displays -7, -07, -07:00 on .NET Framework
// Displays +0, +00, +00:00 on .NET Core and .NET 5+

DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0,
                                          new TimeSpan(6, 0, 0));
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date2));
// Displays +6, +06, +06:00
Dim date1 As Date = Date.UtcNow
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date1))
' Displays -7, -07, -07:00 on .NET Framework
' Displays +0, +00, +00:00 on .NET Core and .NET 5+

Dim date2 As New DateTimeOffset(2008, 8, 1, 0, 0, 0, _
                                New Timespan(6, 0, 0))
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date2))
' Displays +6, +06, +06:00

Tillbaka till tabellen

Den anpassade formatspecificeraren "zzz"

Med DateTime värden representerar den anpassade formatspecificeraren "zzz" den signerade förskjutningen för den angivna tidszonen från UTC, mätt i timmar och minuter. Förskjutningen visas alltid med ett inledande tecken. Ett plustecken (+) anger timmar före UTC och ett minustecken (-) anger timmar bakom UTC. En ensiffrig förskjutning formateras med inledande nolla.

Följande tabell visar hur förskjutningsvärdet ändras beroende på DateTimeKind.

DateTimeKind Värde Förskjutet värde
Local Den signerade förskjutningen av det lokala operativsystemets tidszon från UTC.
Unspecified Den signerade förskjutningen av det lokala operativsystemets tidszon från UTC.
Utc +00:00 på .NET Core och .NET 5+.

På .NET Framework, den signerade förskjutningen av det lokala operativsystemets tidszon från UTC.

Med DateTimeOffset värden representerar DateTimeOffset den här formatspecificeraren värdets förskjutning från UTC i timmar och minuter.

I följande exempel ingår den anpassade formatspecificeraren "zzz" i en anpassad formatsträng.

DateTime date1 = DateTime.UtcNow;
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date1));
// Displays -7, -07, -07:00 on .NET Framework
// Displays +0, +00, +00:00 on .NET Core and .NET 5+

DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0,
                                          new TimeSpan(6, 0, 0));
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
                  date2));
// Displays +6, +06, +06:00
Dim date1 As Date = Date.UtcNow
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date1))
' Displays -7, -07, -07:00 on .NET Framework
' Displays +0, +00, +00:00 on .NET Core and .NET 5+

Dim date2 As New DateTimeOffset(2008, 8, 1, 0, 0, 0, _
                                New Timespan(6, 0, 0))
Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}", _
                  date2))
' Displays +6, +06, +06:00

Tillbaka till tabellen

Datum- och tidsavgränsare

Den ":"anpassade formatspecificeraren

Den ":" anpassade formatspecificeraren representerar tidsavgränsaren, som används för att särskilja timmar, minuter och sekunder. Lämplig lokaliserad tidsavgränsare hämtas från egenskapen för den DateTimeFormatInfo.TimeSeparator aktuella eller angivna kulturen.

Anteckning

Om du vill ändra tidsavgränsaren för en viss datum- och tidssträng anger du avgränsarens tecken i en strängavgränsare. Den anpassade formatsträngen hh'_'dd'_'ss skapar till exempel en resultatsträng där "_" (ett understreck) alltid används som tidsavgränsare. Om du vill ändra tidsavgränsaren för alla datum för en kultur ändrar du antingen värdet för egenskapen för den DateTimeFormatInfo.TimeSeparator aktuella kulturen eller instansierar ett DateTimeFormatInfo objekt, tilldelar tecknet till dess TimeSeparator egenskap och anropar en överlagring av formateringsmetoden som innehåller en IFormatProvider parameter.

Om formatspecificeraren ":"används utan andra anpassade formatspecificerare tolkas den som en standardspecificerare för datum- och tidsformat och genererar en FormatException. Mer information om hur du använder en enskild formatspecificerare finns i Använda enskilda anpassade formatspecificerare senare i den här artikeln.

Tillbaka till tabellen

Den anpassade formatspecificeraren "/"

Den anpassade formatspecificeraren "/" representerar datumavgränsaren, som används för att särskilja år, månader och dagar. Lämplig lokaliserad datumavgränsare hämtas från egenskapen för den DateTimeFormatInfo.DateSeparator aktuella eller angivna kulturen.

Anteckning

Om du vill ändra datumavgränsaren för en viss datum- och tidssträng anger du avgränsarens tecken i en literalsträngavgränsare. Den anpassade formatsträngen mm'/'dd'/'yyyy skapar till exempel en resultatsträng där "/" alltid används som datumavgränsare. Om du vill ändra datumavgränsaren för alla datum för en kultur ändrar du antingen värdet för egenskapen för den DateTimeFormatInfo.DateSeparator aktuella kulturen eller instansierar ett DateTimeFormatInfo objekt, tilldelar tecknet till dess DateSeparator egenskap och anropar en överlagring av formateringsmetoden som innehåller en IFormatProvider parameter.

Om formatspecificeraren "/" används utan andra anpassade formatspecificerare tolkas den som en standardspecificerare för datum- och tidsformat och genererar en FormatException. Mer information om hur du använder en enskild formatspecificerare finns i Använda enskilda anpassade formatspecificerare senare i den här artikeln.

Tillbaka till tabellen

Teckenliteraler

Följande tecken i en anpassad datum- och tidsformatsträng är reserverade och tolkas alltid som formateringstecken eller, när det gäller ", ', /och \, som specialtecken.

  • F
  • H
  • K
  • M
  • d
  • f
  • g
  • h
  • m
  • s
  • t
  • y
  • z
  • %
  • :
  • /
  • "
  • '
  • \

Alla andra tecken tolkas alltid som teckenliteraler och ingår i resultatsträngen oförändrad i en formateringsåtgärd. I en parsningsåtgärd måste de matcha tecknen i indatasträngen exakt. jämförelsen är skiftlägeskänslig.

I följande exempel ingår de literala tecknen "PST" (för Pacific Standard Time) och "PDT" (för Pacific Daylight Time) för att representera den lokala tidszonen i en formatsträng. Observera att strängen ingår i resultatsträngen och att en sträng som innehåller den lokala tidszonssträngen också parsar korrekt.

using System;
using System.Globalization;

public class Example5
{
    public static void Main()
    {
        String[] formats = { "dd MMM yyyy hh:mm tt PST",
                           "dd MMM yyyy hh:mm tt PDT" };
        var dat = new DateTime(2016, 8, 18, 16, 50, 0);
        // Display the result string.
        Console.WriteLine(dat.ToString(formats[1]));

        // Parse a string.
        String value = "25 Dec 2016 12:00 pm PST";
        DateTime newDate;
        if (DateTime.TryParseExact(value, formats, null,
                                   DateTimeStyles.None, out newDate))
            Console.WriteLine(newDate);
        else
            Console.WriteLine("Unable to parse '{0}'", value);
    }
}
// The example displays the following output:
//       18 Aug 2016 04:50 PM PDT
//       12/25/2016 12:00:00 PM
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim formats() As String = {"dd MMM yyyy hh:mm tt PST",
                                    "dd MMM yyyy hh:mm tt PDT"}
        Dim dat As New Date(2016, 8, 18, 16, 50, 0)
        ' Display the result string. 
        Console.WriteLine(dat.ToString(formats(1)))

        ' Parse a string. 
        Dim value As String = "25 Dec 2016 12:00 pm PST"
        Dim newDate As Date
        If Date.TryParseExact(value, formats, Nothing,
                              DateTimeStyles.None, newDate) Then
            Console.WriteLine(newDate)
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If
    End Sub
End Module
' The example displays the following output:
'       18 Aug 2016 04:50 PM PDT
'       12/25/2016 12:00:00 PM

Det finns två sätt att ange att tecken ska tolkas som literaltecken och inte som reserverade tecken, så att de kan inkluderas i en resultatsträng eller parsas i en indatasträng:

I följande exempel ingår de literala tecknen "pst" (för Pacific Standard-tid) för att representera den lokala tidszonen i en formatsträng. Eftersom både "s" och "t" är anpassade formatsträngar måste båda tecknen inte tolkas som teckenliteraler.

using System;
using System.Globalization;

public class Example3
{
    public static void Main()
    {
        String format = "dd MMM yyyy hh:mm tt p\\s\\t";
        var dat = new DateTime(2016, 8, 18, 16, 50, 0);
        // Display the result string.
        Console.WriteLine(dat.ToString(format));

        // Parse a string.
        String value = "25 Dec 2016 12:00 pm pst";
        DateTime newDate;
        if (DateTime.TryParseExact(value, format, null,
                                   DateTimeStyles.None, out newDate))
            Console.WriteLine(newDate);
        else
            Console.WriteLine("Unable to parse '{0}'", value);
    }
}
// The example displays the following output:
//       18 Aug 2016 04:50 PM pst
//       12/25/2016 12:00:00 PM
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim fmt As String = "dd MMM yyyy hh:mm tt p\s\t"
        Dim dat As New Date(2016, 8, 18, 16, 50, 0)
        ' Display the result string. 
        Console.WriteLine(dat.ToString(fmt))

        ' Parse a string. 
        Dim value As String = "25 Dec 2016 12:00 pm pst"
        Dim newDate As Date
        If Date.TryParseExact(value, fmt, Nothing,
                              DateTimeStyles.None, newDate) Then
            Console.WriteLine(newDate)
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If
    End Sub
End Module
' The example displays the following output:
'       18 Aug 2016 04:50 PM pst
'       12/25/2016 12:00:00 PM
  • Genom att omsluta hela literalsträngen inom citattecken eller apostrofer. Följande exempel liknar det föregående, förutom att "pst" omges av citattecken för att indikera att hela den avgränsade strängen ska tolkas som teckenliteraler.
using System;
using System.Globalization;

public class Example6
{
    public static void Main()
    {
        String format = "dd MMM yyyy hh:mm tt \"pst\"";
        var dat = new DateTime(2016, 8, 18, 16, 50, 0);
        // Display the result string.
        Console.WriteLine(dat.ToString(format));

        // Parse a string.
        String value = "25 Dec 2016 12:00 pm pst";
        DateTime newDate;
        if (DateTime.TryParseExact(value, format, null,
                                   DateTimeStyles.None, out newDate))
            Console.WriteLine(newDate);
        else
            Console.WriteLine("Unable to parse '{0}'", value);
    }
}
// The example displays the following output:
//       18 Aug 2016 04:50 PM pst
//       12/25/2016 12:00:00 PM
Imports System.Globalization

Module Example
    Public Sub Main()
        Dim fmt As String = "dd MMM yyyy hh:mm tt ""pst"""
        Dim dat As New Date(2016, 8, 18, 16, 50, 0)
        ' Display the result string. 
        Console.WriteLine(dat.ToString(fmt))

        ' Parse a string. 
        Dim value As String = "25 Dec 2016 12:00 pm pst"
        Dim newDate As Date
        If Date.TryParseExact(value, fmt, Nothing,
                              DateTimeStyles.None, newDate) Then
            Console.WriteLine(newDate)
        Else
            Console.WriteLine("Unable to parse '{0}'", value)
        End If
    End Sub
End Module
' The example displays the following output:
'       18 Aug 2016 04:50 PM pst
'       12/25/2016 12:00:00 PM

Kommentarer

Använda enstaka anpassade formatspecificerare

En anpassad datum- och tidsformatsträng består av två eller flera tecken. Formateringsmetoder för datum och tid tolkar en sträng med en tecken som en standardsträng för datum- och tidsformat. Om de inte känner igen tecknet som en giltig formatspecificerare genererar de en FormatException. Till exempel tolkas en formatsträng som endast består av specificeraren "h" som en standardsträng för datum- och tidsformat. I det här fallet utlöses dock ett undantag eftersom det inte finns någon "h"-standardspecificerare för datum- och tidsformat.

Om du vill använda någon av de anpassade datum- och tidsformatsspecificerarna som enda specificerare i en formatsträng (d.ex. om du vill använda formatspecificeraren "d", "f", "F", "g", "h", "H", "K", "m", "M", "s", "t", "y", "z", ":", eller "/" egen formatspecificerare), inkludera ett blanksteg före eller efter specificeraren, eller inkludera en procentformatsspecificerare (%).

"%h" tolkas till exempel som en anpassad datum- och tidsformatsträng som visar timmen som representeras av det aktuella datum- och tidsvärdet. Du kan också använda formatsträngen " h" eller "h", även om detta inkluderar ett blanksteg i resultatsträngen tillsammans med timmen. I följande exempel visas dessa tre formatsträngar.

DateTime dat1 = new DateTime(2009, 6, 15, 13, 45, 0);

Console.WriteLine("'{0:%h}'", dat1);
Console.WriteLine("'{0: h}'", dat1);
Console.WriteLine("'{0:h }'", dat1);
// The example displays the following output:
//       '1'
//       ' 1'
//       '1 '
Dim dat1 As Date = #6/15/2009 1:45PM#

Console.WriteLine("'{0:%h}'", dat1)
Console.WriteLine("'{0: h}'", dat1)
Console.WriteLine("'{0:h }'", dat1)
' The example displays the following output:
'       '1'
'       ' 1'
'       '1 '

Använda Escape-tecknet

Tecknen "d", "f", "F", "g", "h", "H", "K", "m", "M", "s", "t", "y", "z", ":", eller "/" i en formatsträng tolkas som anpassade formatspecificerare snarare än som literaltecken. Om du vill förhindra att ett tecken tolkas som en formatspecificerare kan du föregå det med ett omvänt snedstreck (\), vilket är escape-tecknet. Escape-tecknet betyder att följande tecken är en teckenliteral som ska inkluderas i resultatsträngen oförändrad.

Om du vill inkludera ett omvänt snedstreck i en resultatsträng måste du undvika det med ett annat omvänt snedstreck (\\).

Anteckning

Vissa kompilatorer, till exempel C++ och C#-kompilatorer, kan också tolka ett enda omvänt snedstreck som ett escape-tecken. För att säkerställa att en sträng tolkas korrekt vid formatering kan du använda det ordagranna strängliteraltecknet (@-tecknet) före strängen i C#, eller lägga till ytterligare ett omvänt snedstreck före varje omvänt snedstreck i C# och C++. I följande C#-exempel visas båda metoderna.

I följande exempel används escape-tecknet för att förhindra formateringsåtgärden från att tolka tecknen "h" och "m" som formatspecificerare.

DateTime date = new DateTime(2009, 06, 15, 13, 45, 30, 90);
string fmt1 = "h \\h m \\m";
string fmt2 = @"h \h m \m";

Console.WriteLine("{0} ({1}) -> {2}", date, fmt1, date.ToString(fmt1));
Console.WriteLine("{0} ({1}) -> {2}", date, fmt2, date.ToString(fmt2));
// The example displays the following output:
//       6/15/2009 1:45:30 PM (h \h m \m) -> 1 h 45 m
//       6/15/2009 1:45:30 PM (h \h m \m) -> 1 h 45 m
Dim date1 As Date = #6/15/2009 13:45#
Dim fmt As String = "h \h m \m"

Console.WriteLine("{0} ({1}) -> {2}", date1, fmt, date1.ToString(fmt))
' The example displays the following output:
'       6/15/2009 1:45:00 PM (h \h m \m) -> 1 h 45 m      

Kontrollpanelen inställningar

Inställningarna nationella alternativ och språkalternativ i Kontrollpanelen påverka resultatsträngen som skapas av en formateringsåtgärd som innehåller många av de anpassade datum- och tidsformatsspecificerarna. De här inställningarna används för att initiera objektet DateTimeFormatInfo som är associerat med den aktuella kulturen, som innehåller värden som används för att styra formateringen. Datorer som använder olika inställningar genererar olika resultatsträngar.

Om du använder CultureInfo(String) konstruktorn för att instansiera ett nytt CultureInfo objekt som representerar samma kultur som den aktuella systemkulturen tillämpas dessutom eventuella anpassningar som har upprättats av objektet Nationella alternativ och Språkalternativ i Kontrollpanelen på det nya CultureInfo objektet. Du kan använda CultureInfo(String, Boolean) konstruktorn för att skapa ett CultureInfo objekt som inte återspeglar ett systems anpassningar.

DateTimeFormatInfo-egenskaper

Formateringen påverkas av egenskaperna för det aktuella DateTimeFormatInfo objektet, som tillhandahålls implicit av den aktuella kulturen eller uttryckligen av parametern IFormatProvider för metoden som anropar formatering. För parametern IFormatProvider bör du ange ett CultureInfo objekt som representerar en kultur eller ett DateTimeFormatInfo objekt.

Resultatsträngen som skapas av många av de anpassade datum- och tidsformatsspecificerarna beror också på egenskaperna för det aktuella DateTimeFormatInfo objektet. Ditt program kan ändra resultatet från vissa anpassade datum- och tidsformatsspecificerare genom att ändra motsvarande DateTimeFormatInfo egenskap. Till exempel lägger formatspecificeraren "ddd" till ett förkortat veckodagsnamn som finns i strängmatrisen AbbreviatedDayNames i resultatsträngen. På samma sätt lägger formatspecificeraren "MMMM" till ett fullständigt månadsnamn som finns i strängmatrisen MonthNames i resultatsträngen.

Se även