Standardformatsträngar för datum och tid

En standardsträng för datum- och tidsformat använder ett enda tecken som formatspecificerare för att definiera textrepresentationen av ett DateTime eller ett DateTimeOffset värde. Alla datum- och tidsformatsträngar som innehåller mer än ett tecken, inklusive blanksteg, tolkas som en anpassad datum- och tidsformatsträng. En standardsträng eller en anpassad formatsträng kan användas på två sätt:

  • Definiera strängen som är resultatet av en formateringsåtgärd.

  • Definiera textrepresentationen av ett datum- och tidsvärde som kan konverteras till ett DateTime eller-värde DateTimeOffset med en parsningsåtgärd.

Tips

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

Anteckning

Några av C#-exemplen i den här artikeln körs i Try.NET infogad kodkörare och lekplats. 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 för C#-kompilatorn.

Den lokala tidszonen fö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.

Tabell med formatspecificerare

I följande tabell beskrivs standardspecificerarna för datum- och tidsformat. Om inget annat anges skapar en viss standardspecificerare för datum- och tidsformat en identisk strängrepresentation oavsett om den används med ett DateTime eller ett DateTimeOffset värde. Mer information om hur du använder standardsträngar för datum- och tidsformat finns i Kontrollpanelen Inställningar och DateTimeFormatInfo-egenskaper.

Formatspecificerare Beskrivning Exempel
"d" Kort datummönster.

Mer information:Formatspecificeraren för kort datum ("d").
2009-06-15T13:45:30 -> 2009-06-15 (en-US)

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

2009-06-15T13:45:30 -> 2009/06/15 (ja-JP)
"D" Långt datummönster.

Mer information:Formatspecificeraren för långt datum ("D").
2009-06-15T13:45:30 -> Måndag, Juni 15, 2009 (en-US)

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

2009-06-15T13:45:30 -> Montag, 15. Juni 2009 (de-DE)
"f" Mönster för fullständigt datum/tid (kort tid).

Mer information: Formatspecificeraren för fullständig kort tid ("f").
2009-06-15T13:45:30 –> Måndag 15 juni 2009 13:45 (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 13:45 (sv-SE)

2009-06-15T13:45:30 -> Δευτέρα, 15 Ιουνίου 2009 1:45 μμ (el-GR)
"F" Mönster för fullständigt datum/tid (lång tid).

Mer information: Formatspecificeraren för fullständigt datum ("F").
2009-06-15T13:45:30 –> måndag 15 juni 2009 13:45:30 (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 13:45:30 (sv-SE)

2009-06-15T13:45:30 -> Δευτέρα, 15 Ιουνίου 2009 1:45:30 μμ (el-GR)
"g" Allmänt datum-/tidsmönster (kort tid).

Mer information: Formatspecificeraren för kort tid ("g") för allmänt datum.
2009-06-15T13:45:30 -> 2009-06-15 13:45 (en-US)

2009-06-15T13:45:30 -> 2009-15-06 13:45 (es-ES)

2009-06-15T13:45:30 -> 2009/6/15 13:45 (zh-CN)
"G" Allmänt datum-/tidsmönster (lång tid).

Mer information: Formatspecificeraren för allmän datum/lång tid ("G").
2009-06-15T13:45:30 -> 2009-06-15 13:30 (en-US)

2009-06-15T13:45:30 -> 15/06/2009 13:45:30 (es-ES)

2009-06-15T13:45:30 -> 2009/6/15 13:45:30 (zh-CN)
"M", "m" Mönster för månad/dag.

Mer information: Month ("M", "m") formatspecificerare.
2009-06-15T13:45:30 -> 15 juni (en-US)

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

2009-06-15T13:45:30 –> 15 Juni (id-ID)
"O", "o" datum-/tidsmönster för tur och retur.

Mer information: Returformatsspecificeraren ("O", "o").
DateTime Värden:

2009-06-15T13:45:30 (DateTimeKind.Local) --> 2009-06-15T13:45:30.0000000-07:00

2009-06-15T13:45:30 (DateTimeKind.Utc) --> 2009-06-15T13:45:30.0000000Z

2009-06-15T13:45:30 (DateTimeKind.Unspecified) --> 2009-06-15T13:45:30.0000000

DateTimeOffset Värden:

2009-06-15T13:45:30-07:00 --> 2009-06-15T13:45:30.0000000-07:00
"R", "r" RFC1123-mönster.

Mer information: Formatspecificeraren RFC1123 ("R", "r").
DateTimeOffset input: 2009-06-15T13:45:30 -> Mån, 15 jun 2009 20:45:30 GMT
DateTime input: 2009-06-15T13:45:30 -> Mån, 15 jun 2009 13:45:30 GMT
"s" Sorterbart datum-/tidsmönster.

Mer information: Den sorterbara formatspecificeraren ("s").
2009-06-15T13:45:30 (DateTimeKind.Local) -> 2009-06-15T13:45:30

2009-06-15T13:45:30 (DateTimeKind.Utc) –> 2009-06-15T13:45:30
"t" Kort tidsmönster.

Mer information: Formatspecificeraren för kort tid ("t").
2009-06-15T13:45:30-> 13:45 (en-US)

2009-06-15T13:45:30 -> 13:45 (hr-HR)

2009-06-15T13:45:30 -> 01:45 م (ar-EG)
"T" Mönster för lång tid.

Mer information: Formatspecificeraren för lång tid ("T").
2009-06-15T13:45:30-> 13:45:30 (en-US)

2009-06-15T13:45:30 -> 13:45:30 (hr-HR)

2009-06-15T13:45:30 -> 01:45:30 م (ar-EG)
"u" Universellt sorterbart datum/tid-mönster.

Mer information: Den universella sorterbara formatspecificeraren ("u").
Med ett DateTime värde: 2009-06-15T13:45:30 -> 2009-06-15 13:45:30Z

Med ett DateTimeOffset värde: 2009-06-15T13:45:30 -> 2009-06-15 20:45:30Z
"U" Universellt fullständigt datum/tid-mönster.

Mer information: Den universella fullständiga formatspecificeraren ("U").
2009-06-15T13:45:30 -> Måndag 15 juni 2009 20:45:30 (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 20:45:30 (sv-SE)

2009-06-15T13:45:30 -> Δευτέρα, 15 Ιουνίου 2009 8:45:30 μμ (el-GR)
"Y", "y" Årsmånadsmönster.

Mer information: Formatspecificeraren årsmånad ("Y").
2009-06-15T13:45:30 -> Juni 2009 (en-US)

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

2009-06-15T13:45:30 –> Juni 2009 (id-ID)
Alla andra enkla tecken Okänd specificerare. Genererar en körning FormatException.

Så här fungerar standardformatsträngar

I en formateringsåtgärd är en standardformatsträng helt enkelt ett alias för en anpassad formatsträng. Fördelen med att använda ett alias för att referera till en anpassad formatsträng är att även om aliaset förblir invariant kan själva den anpassade formatsträngen variera. Detta är viktigt eftersom strängrepresentationerna av datum- och tidsvärden vanligtvis varierar beroende på kultur. Standardformatsträngen "d" anger till exempel att ett datum- och tidsvärde ska visas med ett kort datummönster. För den invarianta kulturen är det här mönstret "MM/dd/åååå". För fr-FR-kulturen är det "dd/MM/åååå". För ja-JP-kulturen är det "yyyy/MM/dd".

Om en standardformatsträng i en formateringsåtgärd mappar till en viss kulturs anpassade formatsträng kan ditt program definiera den specifika kultur vars anpassade formatsträngar används på något av följande sätt:

  • Du kan använda standardkulturen (eller aktuell). I följande exempel visas ett datum med den aktuella kulturens korta datumformat. I det här fallet är den aktuella kulturen en-US.

    // Display using current (en-us) culture's short date format
    DateTime thisDate = new DateTime(2008, 3, 15);
    Console.WriteLine(thisDate.ToString("d"));           // Displays 3/15/2008
    
    ' Display using current (en-us) culture's short date format
    Dim thisDate As Date = #03/15/2008#
    Console.WriteLine(thisDate.ToString("d"))     ' Displays 3/15/2008
    
  • Du kan skicka ett CultureInfo objekt som representerar kulturen vars formatering ska användas till en metod som har en IFormatProvider parameter. I följande exempel visas ett datum med det korta datumformatet för pt-BR-kulturen.

    // Display using pt-BR culture's short date format
    DateTime thisDate = new DateTime(2008, 3, 15);
    CultureInfo culture = new CultureInfo("pt-BR");
    Console.WriteLine(thisDate.ToString("d", culture));  // Displays 15/3/2008
    
    ' Display using pt-BR culture's short date format
    Dim thisDate As Date = #03/15/2008#
    Dim culture As New CultureInfo("pt-BR")
    Console.WriteLine(thisDate.ToString("d", culture))   ' Displays 15/3/2008
    
  • Du kan skicka ett DateTimeFormatInfo objekt som tillhandahåller formateringsinformation till en metod som har en IFormatProvider parameter. I följande exempel visas ett datum med det korta datumformatet från ett DateTimeFormatInfo objekt för hr-HR-kulturen.

    // Display using date format information from hr-HR culture
    DateTime thisDate = new DateTime(2008, 3, 15);
    DateTimeFormatInfo fmt = (new CultureInfo("hr-HR")).DateTimeFormat;
    Console.WriteLine(thisDate.ToString("d", fmt));      // Displays 15.3.2008
    
    ' Display using date format information from hr-HR culture
    Dim thisDate As Date = #03/15/2008#
    Dim fmt As DateTimeFormatInfo = (New CultureInfo("hr-HR")).DateTimeFormat
    Console.WriteLine(thisDate.ToString("d", fmt))   ' Displays 15.3.2008
    

Anteckning

Information om hur du anpassar de mönster eller strängar som används för att formatera datum- och tidsvärden finns i klassavsnittet NumberFormatInfo .

I vissa fall fungerar standardformatsträngen som en praktisk förkortning för en längre anpassad formatsträng som är invariant. Fyra standardformatsträngar tillhör den här kategorin: "O" (eller "o"), "R" (eller "r"), "s" och "u". Dessa strängar motsvarar anpassade formatsträngar som definieras av den invarianta kulturen. De skapar strängrepresentationer av datum- och tidsvärden som är avsedda att vara identiska mellan kulturer. Följande tabell innehåller information om dessa fyra standardsträngar för datum- och tidsformat.

Standardformatsträng Definieras av egenskapen DateTimeFormatInfo.InvariantInfo Anpassad formatsträng
"O" eller "o" Ingen yyyy'-'MM'-'dd'T'HH':'mm'ss'. fffffffK
"R" eller "r" RFC1123Pattern ddd, dd MMM yyyy HH':'mm':ss 'GMT'
"s" SortableDateTimePattern yyyy'-'MM'-'dd'T'HH':'mm':'ss
"u" UniversalSortableDateTimePattern yyyy'-'MM'-'dd HH':'mm':'ss'Z'

Standardformatsträngar kan också användas för att parsa åtgärder med DateTime.ParseExact metoderna eller DateTimeOffset.ParseExact , vilket kräver att en indatasträng exakt överensstämmer med ett visst mönster för att parsningsåtgärden ska lyckas. Många standardformatsträngar mappas till flera anpassade formatsträngar, så ett datum- och tidsvärde kan representeras i olika format och parsningsåtgärden kommer fortfarande att lyckas. Du kan fastställa den anpassade formatsträngen eller strängarna som motsvarar en standardformatsträng genom att anropa DateTimeFormatInfo.GetAllDateTimePatterns(Char) metoden. I följande exempel visas de anpassade formatsträngar som mappar till standardformatsträngen "d" (kort datummönster).

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      Console.WriteLine("'d' standard format string:");
      foreach (var customString in DateTimeFormatInfo.CurrentInfo.GetAllDateTimePatterns('d'))
          Console.WriteLine("   {0}", customString);
   }
}
// The example displays the following output:
//       'd' standard format string:
//          M/d/yyyy
//          M/d/yy
//          MM/dd/yy
//          MM/dd/yyyy
//          yy/MM/dd
//          yyyy-MM-dd
//          dd-MMM-yy
Imports System.Globalization

Module Example
    Public Sub Main()
        Console.WriteLine("'d' standard format string:")
        For Each customString In DateTimeFormatInfo.CurrentInfo.GetAllDateTimePatterns("d"c)
            Console.WriteLine("   {0}", customString)
        Next
    End Sub
End Module
' The example displays the following output:
'    'd' standard format string:
'       M/d/yyyy
'       M/d/yy
'       MM/dd/yy
'       MM/dd/yyyy
'       yy/MM/dd
'       yyyy-MM-dd
'       dd-MMM-yy

I följande avsnitt beskrivs standardformatsspecificerare för DateTime och DateTimeOffset värden.

Datumformat

Den här gruppen innehåller följande format:

Formatspecificeraren för kort datum ("d")

Standardformatsspecificeraren d representerar en anpassad datum- och tidsformatsträng som definieras av en specifik kulturs DateTimeFormatInfo.ShortDatePattern egenskap. Till exempel är den anpassade formatsträngen ShortDatePattern som returneras av egenskapen för den invarianta kulturen "MM/dd/åååå".

I följande tabell visas de DateTimeFormatInfo objektegenskaper som styr formateringen av den returnerade strängen.

Egenskap Beskrivning
ShortDatePattern Definierar det övergripande formatet för resultatsträngen.
DateSeparator Definierar strängen som separerar komponenterna år, månad och dag för ett datum.

I följande exempel används formatspecificeraren "d" för att visa ett datum- och tidsvärde.

DateTime date1 = new DateTime(2008,4, 10);
Console.WriteLine(date1.ToString("d", DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008
Console.WriteLine(date1.ToString("d",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays 4/10/2008
Console.WriteLine(date1.ToString("d",
                  CultureInfo.CreateSpecificCulture("en-NZ")));
// Displays 10/04/2008
Console.WriteLine(date1.ToString("d",
                  CultureInfo.CreateSpecificCulture("de-DE")));
// Displays 10.04.2008
Dim date1 As Date = #4/10/2008#
Console.WriteLine(date1.ToString("d", DateTimeFormatInfo.InvariantInfo))
' Displays 04/10/2008
Console.WriteLine(date1.ToString("d", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays 4/10/2008                       
Console.WriteLine(date1.ToString("d", _
                  CultureInfo.CreateSpecificCulture("en-NZ")))
' Displays 10/04/2008                       
Console.WriteLine(date1.ToString("d", _
                  CultureInfo.CreateSpecificCulture("de-DE")))
' Displays 10.04.2008                       

Tillbaka till tabellen

Formatspecificeraren för långt datum ("D")

Standardformatsspecificeraren "D" representerar en anpassad datum- och tidsformatsträng som definieras av den aktuella DateTimeFormatInfo.LongDatePattern egenskapen. Till exempel är den anpassade formatsträngen för den invarianta kulturen "dddd, dd MMMM yyyyy".

I följande tabell visas egenskaperna för objektet DateTimeFormatInfo som styr formateringen av den returnerade strängen.

Egenskap Beskrivning
LongDatePattern Definierar det övergripande formatet för resultatsträngen.
DayNames Definierar de lokaliserade dagnamnen som kan visas i resultatsträngen.
MonthNames Definierar de lokaliserade månadsnamnen som kan visas i resultatsträngen.

I följande exempel används formatspecificeraren "D" för att visa ett datum- och tidsvärde.

DateTime date1 = new DateTime(2008, 4, 10);
Console.WriteLine(date1.ToString("D",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008
Console.WriteLine(date1.ToString("D",
                  CultureInfo.CreateSpecificCulture("pt-BR")));
// Displays quinta-feira, 10 de abril de 2008
Console.WriteLine(date1.ToString("D",
                  CultureInfo.CreateSpecificCulture("es-MX")));
// Displays jueves, 10 de abril de 2008
Dim date1 As Date = #4/10/2008#
Console.WriteLine(date1.ToString("D", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008                        
Console.WriteLine(date1.ToString("D", _
                  CultureInfo.CreateSpecificCulture("pt-BR")))
' Displays quinta-feira, 10 de abril de 2008                        
Console.WriteLine(date1.ToString("D", _
                  CultureInfo.CreateSpecificCulture("es-MX")))
' Displays jueves, 10 de abril de 2008                        

Tillbaka till tabellen

Datum- och tidsformat

Den här gruppen innehåller följande format:

Formatspecificeraren för fullständigt datum ("f")

Standardformatsspecificeraren "f" representerar en kombination av de långa datummönstren ("D") och korta tidsmönster ("t") avgränsade med ett blanksteg.

Resultatsträngen påverkas av formateringsinformationen för ett visst DateTimeFormatInfo objekt. I följande tabell visas de DateTimeFormatInfo objektegenskaper som kan styra formateringen av den returnerade strängen. Den anpassade formatspecificeraren som returneras av DateTimeFormatInfo.LongDatePattern egenskaperna och DateTimeFormatInfo.ShortTimePattern i vissa kulturer kanske inte använder alla egenskaper.

Egenskap Beskrivning
LongDatePattern Definierar formatet för datumkomponenten i resultatsträngen.
ShortTimePattern Definierar formatet för tidskomponenten i resultatsträngen.
DayNames Definierar de lokaliserade dagnamnen som kan visas i resultatsträngen.
MonthNames Definierar de lokaliserade månadsnamnen som kan visas i resultatsträngen.
TimeSeparator Definierar strängen som separerar komponenterna timme, minut och sekund i en tid.
AMDesignator Definierar strängen som anger tider från midnatt till före 12:00 i en 12-timmarsklocka.
PMDesignator Definierar strängen som anger tider från 12:00 till före midnatt i en 12-timmarsklocka.

I följande exempel används formatspecificeraren "f" för att visa ett datum- och tidsvärde.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("f",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008 6:30 AM
Console.WriteLine(date1.ToString("f",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays jeudi 10 avril 2008 06:30
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("f", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008 6:30 AM                        
Console.WriteLine(date1.ToString("f", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays jeudi 10 avril 2008 06:30                       

Tillbaka till tabellen

Formatspecificeraren för fullständigt datum ("F")

Standardformatsspecificeraren F representerar en anpassad datum- och tidsformatsträng som definieras av den aktuella DateTimeFormatInfo.FullDateTimePattern egenskapen. Den anpassade formatsträngen för den invarianta kulturen är till exempel "dddd, dd MMMM ååå HH:mm:ss".

I följande tabell visas de DateTimeFormatInfo objektegenskaper som kan styra formateringen av den returnerade strängen. Den anpassade formatspecificeraren som returneras av FullDateTimePattern egenskapen för vissa kulturer kanske inte använder alla egenskaper.

Egenskap Beskrivning
FullDateTimePattern Definierar det övergripande formatet för resultatsträngen.
DayNames Definierar de lokaliserade dagnamnen som kan visas i resultatsträngen.
MonthNames Definierar de lokaliserade månadsnamnen som kan visas i resultatsträngen.
TimeSeparator Definierar strängen som separerar komponenterna timme, minut och sekund i en tid.
AMDesignator Definierar strängen som anger tider från midnatt till före 12:00 i en 12-timmarsklocka.
PMDesignator Definierar strängen som anger tider från 12:00 till före midnatt i en 12-timmarsklocka.

I följande exempel används formatspecificeraren "F" för att visa ett datum- och tidsvärde.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("F",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008 6:30:00 AM
Console.WriteLine(date1.ToString("F",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays jeudi 10 avril 2008 06:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("F", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008 6:30:00 AM                        
Console.WriteLine(date1.ToString("F", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays jeudi 10 avril 2008 06:30:00                       

Tillbaka till tabellen

Specificeraren för kort tid för allmänt datum ("g")

Standardformatsspecificeraren "g" representerar en kombination av kort datummönster ("d") och korta tidsmönster ("t") avgränsade med ett blanksteg.

Resultatsträngen påverkas av formateringsinformationen för ett visst DateTimeFormatInfo objekt. I följande tabell visas de DateTimeFormatInfo objektegenskaper som kan styra formateringen av den returnerade strängen. Den anpassade formatspecificeraren som returneras av DateTimeFormatInfo.ShortDatePattern egenskaperna och DateTimeFormatInfo.ShortTimePattern i vissa kulturer kanske inte använder alla egenskaper.

Egenskap Beskrivning
ShortDatePattern Definierar formatet för datumkomponenten i resultatsträngen.
ShortTimePattern Definierar formatet för tidskomponenten i resultatsträngen.
DateSeparator Definierar strängen som separerar komponenterna för år, månad och dag för ett datum.
TimeSeparator Definierar strängen som separerar komponenterna timme, minut och sekund i en tid.
AMDesignator Definierar strängen som anger tider från midnatt till före 12:00 i en 12-timmarsklocka.
PMDesignator Definierar strängen som anger tider från 12:00 till före midnatt i en 12-timmarsklocka.

I följande exempel används "g"-formatspecificeraren för att visa ett datum- och tidsvärde.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("g",
                  DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008 06:30
Console.WriteLine(date1.ToString("g",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 4/10/2008 6:30 AM
Console.WriteLine(date1.ToString("g",
                  CultureInfo.CreateSpecificCulture("fr-BE")));
// Displays 10/04/2008 6:30
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("g", _
                  DateTimeFormatInfo.InvariantInfo))
' Displays 04/10/2008 06:30                      
Console.WriteLine(date1.ToString("g", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 4/10/2008 6:30 AM                       
Console.WriteLine(date1.ToString("g", _
                  CultureInfo.CreateSpecificCulture("fr-BE")))
' Displays 10/04/2008 6:30                        

Tillbaka till tabellen

Formatspecificeraren för allmän datum/lång tid ("G")

Standardformatsspecificeraren "G" representerar en kombination av kort datum ("d") och långa tidsmönster ("T") avgränsade med ett blanksteg.

Resultatsträngen påverkas av formateringsinformationen för ett visst DateTimeFormatInfo objekt. I följande tabell visas de DateTimeFormatInfo objektegenskaper som kan styra formateringen av den returnerade strängen. Den anpassade formatspecificeraren som returneras av DateTimeFormatInfo.ShortDatePattern egenskaperna och DateTimeFormatInfo.LongTimePattern i vissa kulturer kanske inte använder alla egenskaper.

Egenskap Beskrivning
ShortDatePattern Definierar formatet för datumkomponenten i resultatsträngen.
LongTimePattern Definierar formatet för tidskomponenten i resultatsträngen.
DateSeparator Definierar strängen som separerar komponenterna för år, månad och dag för ett datum.
TimeSeparator Definierar strängen som separerar komponenterna timme, minut och sekund i en tid.
AMDesignator Definierar strängen som anger tider från midnatt till före 12:00 i en 12-timmarsklocka.
PMDesignator Definierar strängen som anger tider från 12:00 till före midnatt i en 12-timmarsklocka.

I följande exempel används formatspecificeraren "G" för att visa ett datum- och tidsvärde.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("G",
                  DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008 06:30:00
Console.WriteLine(date1.ToString("G",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 4/10/2008 6:30:00 AM
Console.WriteLine(date1.ToString("G",
                  CultureInfo.CreateSpecificCulture("nl-BE")));
// Displays 10/04/2008 6:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("G", _
                  DateTimeFormatInfo.InvariantInfo))
' Displays 04/10/2008 06:30:00
Console.WriteLine(date1.ToString("G", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 4/10/2008 6:30:00 AM                        
Console.WriteLine(date1.ToString("G", _
                  CultureInfo.CreateSpecificCulture("nl-BE")))
' Displays 10/04/2008 6:30:00                       

Tillbaka till tabellen

Formatspecificeraren rundresa ("O", "o")

Standardformatsspecificeraren "O" eller "o" representerar en anpassad datum- och tidsformatsträng med ett mönster som bevarar tidszonsinformation och genererar en resultatsträng som uppfyller ISO 8601. För DateTime värden är den här formatspecificeraren utformad för att bevara datum- och tidsvärden tillsammans med DateTime.Kind egenskapen i text. Den formaterade strängen kan parsas tillbaka med hjälp DateTime.Parse(String, IFormatProvider, DateTimeStyles) av metoden eller DateTime.ParseExact om parametern styles är inställd på DateTimeStyles.RoundtripKind.

Standardformatsspecificeraren "O" eller "o" motsvarar "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.". fffffffK" anpassad formatsträng för DateTime värden och till "yyyy'-'MM'-'dd'T'HH':'mm':'ss'." fffffffzzz" anpassad formatsträng för DateTimeOffset värden. I den här strängen anger paren med enkla citattecken som avgränsar enskilda tecken, till exempel bindestreck, kolon och bokstaven "T", att det enskilda tecknet är en literal som inte kan ändras. Apostrofer visas inte i utdatasträngen.

Standardformatsspecificeraren "O" eller "o" (och "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.". fffffffK" anpassad formatsträng) utnyttjar de tre sätt som ISO 8601 representerar tidszonsinformation för att bevara Kind egenskapen för DateTime värden:

  • Tidszonskomponenten DateTimeKind.Local för datum- och tidsvärden är en förskjutning från UTC (till exempel +01:00, -07:00). Alla DateTimeOffset värden representeras också i det här formatet.

  • Tidszonskomponenten DateTimeKind.Utc för datum- och tidsvärden använder "Z" (som står för nollförskjutning) för att representera UTC.

  • DateTimeKind.Unspecified datum- och tidsvärden saknar tidszonsinformation.

Eftersom standardformatsspecificeraren "O" eller "o" överensstämmer med en internationell standard använder formaterings- eller parsningsåtgärden som använder specificeraren alltid den invarianta kulturen och den gregorianska kalendern.

Strängar som skickas till Parsemetoderna DateTime , TryParse, ParseExactoch TryParseExact för och DateTimeOffset kan parsas med formatspecificeraren "O" eller "o" om de har något av dessa format. När det gäller DateTime objekt bör den parsningsöverlagring som du anropar även innehålla en styles parameter med värdet DateTimeStyles.RoundtripKind. Observera att om du anropar en parsningsmetod med den anpassade formatsträngen som motsvarar formatspecificeraren "O" eller "o" får du inte samma resultat som "O" eller "o". Det beror på att parsningsmetoder som använder en anpassad formatsträng inte kan parsa strängrepresentationen av datum- och tidsvärden som saknar en tidszonskomponent eller använda "Z" för att ange UTC.

I följande exempel används formatspecificeraren "o" för att visa en serie DateTime värden och ett DateTimeOffset värde i ett system i tidszonen USA Stillahavsområdet.

using System;

public class Example
{
   public static void Main()
   {
       DateTime dat = new DateTime(2009, 6, 15, 13, 45, 30,
                                   DateTimeKind.Unspecified);
       Console.WriteLine("{0} ({1}) --> {0:O}", dat, dat.Kind);

       DateTime uDat = new DateTime(2009, 6, 15, 13, 45, 30,
                                    DateTimeKind.Utc);
       Console.WriteLine("{0} ({1}) --> {0:O}", uDat, uDat.Kind);

       DateTime lDat = new DateTime(2009, 6, 15, 13, 45, 30,
                                    DateTimeKind.Local);
       Console.WriteLine("{0} ({1}) --> {0:O}\n", lDat, lDat.Kind);

       DateTimeOffset dto = new DateTimeOffset(lDat);
       Console.WriteLine("{0} --> {0:O}", dto);
   }
}
// The example displays the following output:
//    6/15/2009 1:45:30 PM (Unspecified) --> 2009-06-15T13:45:30.0000000
//    6/15/2009 1:45:30 PM (Utc) --> 2009-06-15T13:45:30.0000000Z
//    6/15/2009 1:45:30 PM (Local) --> 2009-06-15T13:45:30.0000000-07:00
//
//    6/15/2009 1:45:30 PM -07:00 --> 2009-06-15T13:45:30.0000000-07:00
Module Example
    Public Sub Main()
        Dim dat As New Date(2009, 6, 15, 13, 45, 30,
                            DateTimeKind.Unspecified)
        Console.WriteLine("{0} ({1}) --> {0:O}", dat, dat.Kind)

        Dim uDat As New Date(2009, 6, 15, 13, 45, 30, DateTimeKind.Utc)
        Console.WriteLine("{0} ({1}) --> {0:O}", uDat, uDat.Kind)

        Dim lDat As New Date(2009, 6, 15, 13, 45, 30, DateTimeKind.Local)
        Console.WriteLine("{0} ({1}) --> {0:O}", lDat, lDat.Kind)
        Console.WriteLine()

        Dim dto As New DateTimeOffset(lDat)
        Console.WriteLine("{0} --> {0:O}", dto)
    End Sub
End Module
' The example displays the following output:
'    6/15/2009 1:45:30 PM (Unspecified) --> 2009-06-15T13:45:30.0000000
'    6/15/2009 1:45:30 PM (Utc) --> 2009-06-15T13:45:30.0000000Z
'    6/15/2009 1:45:30 PM (Local) --> 2009-06-15T13:45:30.0000000-07:00
'    
'    6/15/2009 1:45:30 PM -07:00 --> 2009-06-15T13:45:30.0000000-07:00

I följande exempel används formatspecificeraren "o" för att skapa en formaterad sträng och återställer sedan det ursprungliga datum- och tidsvärdet genom att anropa en datum- och tidsmetod Parse .

// Round-trip DateTime values.
DateTime originalDate, newDate;
string dateString;
// Round-trip a local time.
originalDate = DateTime.SpecifyKind(new DateTime(2008, 4, 10, 6, 30, 0), DateTimeKind.Local);
dateString = originalDate.ToString("o");
newDate = DateTime.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind,
                  newDate, newDate.Kind);
// Round-trip a UTC time.
originalDate = DateTime.SpecifyKind(new DateTime(2008, 4, 12, 9, 30, 0), DateTimeKind.Utc);
dateString = originalDate.ToString("o");
newDate = DateTime.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind,
                  newDate, newDate.Kind);
// Round-trip time in an unspecified time zone.
originalDate = DateTime.SpecifyKind(new DateTime(2008, 4, 13, 12, 30, 0), DateTimeKind.Unspecified);
dateString = originalDate.ToString("o");
newDate = DateTime.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind,
                  newDate, newDate.Kind);

// Round-trip a DateTimeOffset value.
DateTimeOffset originalDTO = new DateTimeOffset(2008, 4, 12, 9, 30, 0, new TimeSpan(-8, 0, 0));
dateString = originalDTO.ToString("o");
DateTimeOffset newDTO = DateTimeOffset.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine("Round-tripped {0} to {1}.", originalDTO, newDTO);
// The example displays the following output:
//    Round-tripped 4/10/2008 6:30:00 AM Local to 4/10/2008 6:30:00 AM Local.
//    Round-tripped 4/12/2008 9:30:00 AM Utc to 4/12/2008 9:30:00 AM Utc.
//    Round-tripped 4/13/2008 12:30:00 PM Unspecified to 4/13/2008 12:30:00 PM Unspecified.
//    Round-tripped 4/12/2008 9:30:00 AM -08:00 to 4/12/2008 9:30:00 AM -08:00.
' Round-trip DateTime values.
Dim originalDate, newDate As Date
Dim dateString As String
' Round-trip a local time.
originalDate = Date.SpecifyKind(#4/10/2008 6:30AM#, DateTimeKind.Local)
dateString = originalDate.ToString("o")
newDate = Date.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind, _
                  newDate, newDate.Kind)
' Round-trip a UTC time.
originalDate = Date.SpecifyKind(#4/12/2008 9:30AM#, DateTimeKind.Utc)
dateString = originalDate.ToString("o")
newDate = Date.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind, _
                  newDate, newDate.Kind)
' Round-trip time in an unspecified time zone.
originalDate = Date.SpecifyKind(#4/13/2008 12:30PM#, DateTimeKind.Unspecified)
dateString = originalDate.ToString("o")
newDate = Date.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind, _
                  newDate, newDate.Kind)

' Round-trip a DateTimeOffset value.
Dim originalDTO As New DateTimeOffset(#4/12/2008 9:30AM#, New TimeSpan(-8, 0, 0))
dateString = originalDTO.ToString("o")
Dim newDTO As DateTimeOffset = DateTimeOffset.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} to {1}.", originalDTO, newDTO)
' The example displays the following output:
'    Round-tripped 4/10/2008 6:30:00 AM Local to 4/10/2008 6:30:00 AM Local.
'    Round-tripped 4/12/2008 9:30:00 AM Utc to 4/12/2008 9:30:00 AM Utc.
'    Round-tripped 4/13/2008 12:30:00 PM Unspecified to 4/13/2008 12:30:00 PM Unspecified.
'    Round-tripped 4/12/2008 9:30:00 AM -08:00 to 4/12/2008 9:30:00 AM -08:00.

Tillbaka till tabellen

RFC1123-formatspecificeraren ("R", "r")

Standardformatsspecificeraren "R" eller "r" representerar en anpassad datum- och tidsformatsträng som definieras av DateTimeFormatInfo.RFC1123Pattern egenskapen . Mönstret återspeglar en definierad standard och egenskapen är skrivskyddad. Därför är den alltid densamma, oavsett vilken kultur som används eller vilken formatprovider som tillhandahålls. Den anpassade formatsträngen är "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'". När den här standardformatsspecificeraren används använder formaterings- eller parsningsåtgärden alltid den invarianta kulturen.

Resultatsträngen påverkas av följande egenskaper för objektet DateTimeFormatInfo som returneras av DateTimeFormatInfo.InvariantInfo egenskapen som representerar den invarianta kulturen.

Egenskap Beskrivning
RFC1123Pattern Definierar formatet för resultatsträngen.
AbbreviatedDayNames Definierar de förkortade dagnamnen som kan visas i resultatsträngen.
AbbreviatedMonthNames Definierar de förkortade månadsnamnen som kan visas i resultatsträngen.

Även om RFC 1123-standarden uttrycker en tid som Coordinated Universal Time (UTC), ändrar formateringsåtgärden inte värdet för det DateTime objekt som formateras. Därför måste du konvertera värdet DateTime till UTC genom att anropa DateTime.ToUniversalTime metoden innan du utför formateringsåtgärden. Värden utför däremot DateTimeOffset den här konverteringen automatiskt. Du behöver inte anropa DateTimeOffset.ToUniversalTime metoden före formateringsåtgärden.

I följande exempel används formatspecificeraren "r" för att visa ett DateTime och ett DateTimeOffset värde i ett system i tidszonen USA Stillahavsområdet.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
DateTimeOffset dateOffset = new DateTimeOffset(date1,
                            TimeZoneInfo.Local.GetUtcOffset(date1));
Console.WriteLine(date1.ToUniversalTime().ToString("r"));
// Displays Thu, 10 Apr 2008 13:30:00 GMT
Console.WriteLine(dateOffset.ToUniversalTime().ToString("r"));
// Displays Thu, 10 Apr 2008 13:30:00 GMT
Dim date1 As Date = #4/10/2008 6:30AM#
Dim dateOffset As New DateTimeOffset(date1, TimeZoneInfo.Local.GetUtcOFfset(date1))
Console.WriteLine(date1.ToUniversalTime.ToString("r"))
' Displays Thu, 10 Apr 2008 13:30:00 GMT                       
Console.WriteLine(dateOffset.ToUniversalTime.ToString("r"))
' Displays Thu, 10 Apr 2008 13:30:00 GMT                        

Tillbaka till tabellen

Den sorterbara formatspecificeraren ("s")

Standardformatsspecificeraren "s" representerar en anpassad datum- och tidsformatsträng som definieras av DateTimeFormatInfo.SortableDateTimePattern egenskapen . Mönstret återspeglar en definierad standard (ISO 8601) och egenskapen är skrivskyddad. Därför är den alltid densamma, oavsett vilken kultur som används eller vilken formatprovider som tillhandahålls. Den anpassade formatsträngen är "yyyy'-'MM'-'dd'T'HH':'mm':'ss".

Syftet med formatspecificeraren "s" är att skapa resultatsträngar som sorteras konsekvent i stigande eller fallande ordning baserat på datum- och tidsvärden. Även om standardformatsspecificeraren "s" representerar ett datum- och tidsvärde i ett konsekvent format ändrar formateringsåtgärden inte värdet för det datum- och tidsobjekt som formateras för att återspegla dess DateTime.Kind egenskap eller värde DateTimeOffset.Offset . Resultatsträngarna som skapas genom formatering av datum- och tidsvärdena 2014-11-15T18:32:17+00:00 och 2014-11-15T18:32:17+08:00 är identiska.

När den här standardformatsspecificeraren används använder formaterings- eller parsningsåtgärden alltid den invarianta kulturen.

I följande exempel används formatspecificeraren "s" för att visa ett DateTime och ett DateTimeOffset värde i ett system i us Pacific Time Zone.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("s"));
// Displays 2008-04-10T06:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("s"))
' Displays 2008-04-10T06:30:00                       

Tillbaka till tabellen

Den universella sorterbara formatspecificeraren ("u")

Standardformatsspecificeraren "u" representerar en anpassad datum- och tidsformatsträng som definieras av DateTimeFormatInfo.UniversalSortableDateTimePattern egenskapen. Mönstret återspeglar en definierad standard och egenskapen är skrivskyddad. Därför är det alltid samma sak, oavsett vilken kultur som används eller vilken formatprovider som tillhandahålls. Den anpassade formatsträngen är "yyyy'-'MM'-'dd HH':'mm':'ss'Z'". När den här standardformatsspecificeraren används använder formaterings- eller parsningsåtgärden alltid den invarianta kulturen.

Även om resultatsträngen ska uttrycka en tid som Coordinated Universal Time (UTC), utförs ingen konvertering av det ursprungliga DateTime värdet under formateringsåtgärden. Därför måste du konvertera ett DateTime värde till UTC genom att anropa DateTime.ToUniversalTime metoden innan du formaterar den. Värden utför däremot DateTimeOffset den här konverteringen automatiskt. Det finns inget behov av DateTimeOffset.ToUniversalTime att anropa metoden före formateringsåtgärden.

I följande exempel används formatspecificeraren "u" för att visa ett datum- och tidsvärde.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToUniversalTime().ToString("u"));
// Displays 2008-04-10 13:30:00Z
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToUniversalTime.ToString("u"))
' Displays 2008-04-10 13:30:00Z                       

Tillbaka till tabellen

Den universella fullständiga formatspecificeraren ("U")

Standardformatsspecificeraren "U" representerar en anpassad datum- och tidsformatsträng som definieras av en angiven kulturs DateTimeFormatInfo.FullDateTimePattern egenskap. Mönstret är samma som "F"-mönstret. Värdet konverteras dock DateTime automatiskt till UTC innan det formateras.

I följande tabell visas de DateTimeFormatInfo objektegenskaper som kan styra formateringen av den returnerade strängen. Den anpassade formatspecificeraren som returneras av FullDateTimePattern egenskapen för vissa kulturer kanske inte använder alla egenskaper.

Egenskap Beskrivning
FullDateTimePattern Definierar det övergripande formatet för resultatsträngen.
DayNames Definierar de lokaliserade dagnamnen som kan visas i resultatsträngen.
MonthNames Definierar de lokaliserade månadsnamnen som kan visas i resultatsträngen.
TimeSeparator Definierar strängen som separerar tim-, minut- och andra komponenterna i en tid.
AMDesignator Definierar strängen som anger tider från midnatt till före middagstid i en 12-timmarsklocka.
PMDesignator Definierar strängen som anger tider från middagstid till före midnatt i en 12-timmarsklocka.

Formatspecificeraren "U" stöds inte av DateTimeOffset typen och genererar en FormatException om den används för att formatera ett DateTimeOffset värde.

I följande exempel används formatspecificeraren "U" för att visa ett datum- och tidsvärde.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("U",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008 1:30:00 PM
Console.WriteLine(date1.ToString("U",
                  CultureInfo.CreateSpecificCulture("sv-FI")));
// Displays den 10 april 2008 13:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("U", CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008 1:30:00 PM                       
Console.WriteLine(date1.ToString("U", CultureInfo.CreateSpecificCulture("sv-FI")))
' Displays den 10 april 2008 13:30:00                       

Tillbaka till tabellen

Tidsformat

Den här gruppen innehåller följande format:

Formatspecificeraren för kort tid ("t")

Standardformatsspecificeraren "t" representerar en anpassad datum- och tidsformatsträng som definieras av den aktuella DateTimeFormatInfo.ShortTimePattern egenskapen. Den anpassade formatsträngen för den invarianta kulturen är till exempel "HH:mm".

Resultatsträngen påverkas av formateringsinformationen för ett visst DateTimeFormatInfo objekt. I följande tabell visas de DateTimeFormatInfo objektegenskaper som kan styra formateringen av den returnerade strängen. Den anpassade formatspecificeraren som returneras av DateTimeFormatInfo.ShortTimePattern egenskapen för vissa kulturer kanske inte använder alla egenskaper.

Egenskap Beskrivning
ShortTimePattern Definierar formatet för tidskomponenten i resultatsträngen.
TimeSeparator Definierar strängen som separerar tim-, minut- och andra komponenterna i en tid.
AMDesignator Definierar strängen som anger tider från midnatt till före middagstid i en 12-timmarsklocka.
PMDesignator Definierar strängen som anger tider från middagstid till före midnatt i en 12-timmarsklocka.

I följande exempel används formatspecificeraren "t" för att visa ett datum- och tidsvärde.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("t",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 6:30 AM
Console.WriteLine(date1.ToString("t",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays 6:30
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("t", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 6:30 AM                        
Console.WriteLine(date1.ToString("t", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays 6:30                      

Tillbaka till tabellen

Formatspecificeraren för lång tid ("T")

Standardformatsspecificeraren "T" representerar en anpassad datum- och tidsformatsträng som definieras av en specifik kulturs DateTimeFormatInfo.LongTimePattern egenskap. Den anpassade formatsträngen för den invarianta kulturen är till exempel "HH:mm:ss".

I följande tabell visas de DateTimeFormatInfo objektegenskaper som kan styra formateringen av den returnerade strängen. Den anpassade formatspecificeraren som returneras av DateTimeFormatInfo.LongTimePattern egenskapen för vissa kulturer kanske inte använder alla egenskaper.

Egenskap Beskrivning
LongTimePattern Definierar formatet för tidskomponenten i resultatsträngen.
TimeSeparator Definierar strängen som separerar tim-, minut- och andra komponenterna i en tid.
AMDesignator Definierar strängen som anger tider från midnatt till före middagstid i en 12-timmarsklocka.
PMDesignator Definierar strängen som anger tider från middagstid till före midnatt i en 12-timmarsklocka.

I följande exempel används formatspecificeraren "T" för att visa ett datum- och tidsvärde.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("T",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 6:30:00 AM
Console.WriteLine(date1.ToString("T",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays 6:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("T", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 6:30:00 AM                       
Console.WriteLine(date1.ToString("T", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays 6:30:00                      

Tillbaka till tabellen

Partiella datumformat

Den här gruppen innehåller följande format:

Formatspecificeraren för månad ("M", "m")

Standardformatsspecificeraren "M" eller "m" representerar en anpassad datum- och tidsformatsträng som definieras av den aktuella DateTimeFormatInfo.MonthDayPattern egenskapen. Till exempel är den anpassade formatsträngen för den invarianta kulturen "MMMM dd".

I följande tabell visas de DateTimeFormatInfo objektegenskaper som styr formateringen av den returnerade strängen.

Egenskap Beskrivning
MonthDayPattern Definierar det övergripande formatet för resultatsträngen.
MonthNames Definierar de lokaliserade månadsnamnen som kan visas i resultatsträngen.

I följande exempel används formatspecificeraren "m" för att visa ett datum- och tidsvärde.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("m",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays April 10
Console.WriteLine(date1.ToString("m",
                  CultureInfo.CreateSpecificCulture("ms-MY")));
// Displays 10 April
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("m", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays April 10                        
Console.WriteLine(date1.ToString("m", _
                  CultureInfo.CreateSpecificCulture("ms-MY")))
' Displays 10 April                       

Tillbaka till tabellen

Formatspecificeraren årsmånad ("Y", "y")

Standardformatsspecificeraren "Y" eller "y" representerar en anpassad datum- och tidsformatsträng som definieras av egenskapen för DateTimeFormatInfo.YearMonthPattern en angiven kultur. Den anpassade formatsträngen för den invarianta kulturen är till exempel "ååååå MMMM".

I följande tabell visas de DateTimeFormatInfo objektegenskaper som styr formateringen av den returnerade strängen.

Egenskap Beskrivning
YearMonthPattern Definierar det övergripande formatet för resultatsträngen.
MonthNames Definierar de lokaliserade månadsnamnen som kan visas i resultatsträngen.

I följande exempel används formatspecificeraren "y" för att visa ett datum- och tidsvärde.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("Y",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays April, 2008
Console.WriteLine(date1.ToString("y",
                  CultureInfo.CreateSpecificCulture("af-ZA")));
// Displays April 2008
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("Y", CultureInfo.CreateSpecificCulture("en-US")))
' Displays April, 2008                       
Console.WriteLine(date1.ToString("y", CultureInfo.CreateSpecificCulture("af-ZA")))
' Displays April 2008                       

Tillbaka till tabellen

Kontrollpanelen inställningar

I Windows påverkar inställningarna i objektet Nationella alternativ och Språkalternativ i Kontrollpanelen resultatsträngen som skapas av en formateringsåtgärd. 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 ska ditt program ange ett CultureInfo objekt, som representerar en kultur eller ett DateTimeFormatInfo objekt, som representerar en viss kulturs datum- och tidsformateringskonventioner. Många av standardspecificerarna för datum- och tidsformat är alias för formateringsmönster som definieras av egenskaperna för det aktuella DateTimeFormatInfo objektet. Ditt program kan ändra resultatet som genereras av vissa standarddatum- och tidsformatsspecificerare genom att ändra motsvarande datum- och tidsformatmönster för motsvarande DateTimeFormatInfo egenskap.

Se även