Dela via


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 en 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 standard- eller anpassad formatsträng kan användas på två sätt:

  • Så här definierar du 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 DateTimeOffset värde 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.

Anmärkning

Några av C#-exemplen i den här artikeln körs i Try.NET infogad kodlöpare 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 den Try.NET infogade kodlöparen och lekplatsen är Coordinated Universal Time eller UTC. Detta kan påverka beteendet och utdata från exempel som illustrerar DateTime, DateTimeOffsetoch TimeZoneInfo typer och deras medlemmar.

Tabell med formatspecificerare

I följande tabell beskrivs standardformatsspecificerarna för datum och tid. Om inget annat anges skapar en viss standardformatsspecificerare en identisk strängrepresentation oavsett om den används med en DateTime eller ett DateTimeOffset värde. Mer information om hur du använder standardformatsträngar finns i Inställningar för kontrollpanelen 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 -> 15/06/2009 (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 15 juni 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ändigt datum ("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" Fullständigt datum/tid-mönster (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/tid-mönster (kort tid).

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

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

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

Mer information: Formatspecificeraren för allmänt datum ("G").
2009-06-15T13:45:30 -> 2009-06-15 13:45: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: Formatspecificeraren month ("M", "m").
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: Formatspecificeraren rundresa ("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.000000Z

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 indata: 2009-06-15T13:45:30 -> mån, 15 jun 2009 20:45:30 GMT
DateTime indata: 2009-06-15T13:45:30 -> mån, 15 jun 2009 13:45:30 GMT
"s" Sorterbart datum/tid-mö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 mönster för fullständigt datum/tid.

Mer information: Den universella fullständiga formatspecificeraren ("U").
2009-06-15T13:45:30 -> måndag 15 juni 2009 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" Mönster för årsmånad.

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 enskilda tecken Okänd specificerare. Genererar en körnings-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 sträng i anpassat format är att även om aliaset fortfarande är invariant kan 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 "åååå/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 nuvarande 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 den kultur 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 kultur.

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

Anmärkning

Information om hur du anpassar mönster eller strängar som används i formatering av datum- och tidsvärden finns i avsnittet NumberFormatInfo klass.

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 standardformatsträngar för datum och tid.

Standardformatsträng Definieras av egenskapen DateTimeFormatInfo.InvariantInfo Sträng för anpassat format
"O" eller "o" Ingen yyyyy'-'MM'-'dd'T'HH':'mm':'ss'.' fffffffK
"R" eller "r" RFC1123Pattern ddd, dd MMM ååååå HH':'mm':ss 'GMT'
"s" SortableDateTimePattern yyyyy'-'MM'-'dd'T'HH':'mm':'ss
"u" UniversalSortableDateTimePattern yyyyy'-'MM'-'dd HH':'mm':'ss'Z'

Standardformatsträngar kan också användas för att parsa åtgärder med metoderna DateTime.ParseExact 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 lyckas fortfarande. Du kan fastställa den anpassade formatsträngen eller strängarna som motsvarar en standardformatsträng genom att anropa metoden DateTimeFormatInfo.GetAllDateTimePatterns(Char). I följande exempel visas de anpassade formatsträngar som mappas 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($"   {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 standardformatsspecificerarna 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 som returneras av egenskapen ShortDatePattern i den invarianta kulturen "MM/dd/åååå".

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

Fastighet 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 egenskapen DateTimeFormatInfo.LongDatePattern. Till exempel är den anpassade formatsträngen för den invarianta kulturen "dddd, dd MMMM åååå".

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

Fastighet Beskrivning
LongDatePattern Definierar det övergripande formatet för resultatsträngen.
DayNames Definierar de lokaliserade dagnamn som kan visas i resultatsträngen.
MonthNames Definierar de lokaliserade månadsnamn 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 mönster för långt datum ("D") och kort tid ("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 för den returnerade strängen. Den anpassade formatspecificeraren som returneras av egenskaperna DateTimeFormatInfo.LongDatePattern och DateTimeFormatInfo.ShortTimePattern för vissa kulturer kanske inte använder alla egenskaper.

Fastighet Beskrivning
LongDatePattern Definierar formatet för datumkomponenten i resultatsträngen.
ShortTimePattern Definierar formatet för tidskomponenten i resultatsträngen.
DayNames Definierar de lokaliserade dagnamn som kan visas i resultatsträngen.
MonthNames Definierar de lokaliserade månadsnamn 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 klockan 12 på 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 egenskapen DateTimeFormatInfo.FullDateTimePattern. Till exempel är den anpassade formatsträngen för den invarianta kulturen "dddd, dd MMMM åååå HH:mm:ss".

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

Fastighet Beskrivning
FullDateTimePattern Definierar det övergripande formatet för resultatsträngen.
DayNames Definierar de lokaliserade dagnamn som kan visas i resultatsträngen.
MonthNames Definierar de lokaliserade månadsnamn 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 klockan 12 på 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

Formatspecificeraren för generell kort tid ("g")

Standardformatsspecificeraren "g" representerar en kombination av de korta datummönstren ("d") och kort tid ("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 för den returnerade strängen. Den anpassade formatspecificeraren som returneras av egenskaperna DateTimeFormatInfo.ShortDatePattern och DateTimeFormatInfo.ShortTimePattern för vissa kulturer kanske inte använder alla egenskaper.

Fastighet 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 å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 klockan 12 på 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
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 datumlång tid ("G")

Standardformatsspecificeraren "G" representerar en kombination av de korta datummönstren ("d") och lång tid ("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 för den returnerade strängen. Den anpassade formatspecificeraren som returneras av egenskaperna DateTimeFormatInfo.ShortDatePattern och DateTimeFormatInfo.LongTimePattern för vissa kulturer kanske inte använder alla egenskaper.

Fastighet 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 å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 klockan 12 på 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 egenskapen DateTime.Kind i text. Den formaterade strängen kan parsas tillbaka med hjälp av metoden DateTime.Parse(String, IFormatProvider, DateTimeStyles) eller DateTime.ParseExact om parametern styles är inställd på DateTimeStyles.RoundtripKind.

Standardformatsspecificeraren "O" eller "o" motsvarar "åååå"-'MM'-'dd'T'HH':'mm':'ss'.' fffffffK" anpassad formatsträng för DateTime värden och till "åååå"-'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 "yyyyy'-'MM'-'dd'T'HH':'mm':'ss'.". fffffffK" anpassad formatsträng) utnyttjar de tre sätt som ISO 8601 representerar tidszonsinformation för att bevara egenskapen Kind för DateTime värden:

  • Tidszonskomponenten för DateTimeKind.Local 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 i DateTimeKind.Utc datum- och tidsvärden använder "Z" (som står för noll offset) för att representera UTC.

  • DateTimeKind.Unspecified datum- och tidsvärden har ingen 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 Parse, TryParse, ParseExactoch TryParseExact metoder för DateTime och DateTimeOffset kan parsas med formatspecificeraren "O" eller "o" om de finns i 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änder "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 och 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($"{dto} --> {dto:O}");
   }
}
// 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 Parse metod för datum och tid.

// 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 {originalDate} {originalDate.Kind} to {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 {originalDate} {originalDate.Kind} to {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 {originalDate} {originalDate.Kind} to {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 {originalDTO} to {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

Formatspecificeraren RFC1123 ("R", "r")

Standardformatsspecificeraren "R" eller "r" representerar en anpassad datum- och tidsformatsträng som definieras av egenskapen DateTimeFormatInfo.RFC1123Pattern. 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 yyyyy 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 det DateTimeFormatInfo objekt som returneras av egenskapen DateTimeFormatInfo.InvariantInfo som representerar den invarianta kulturen.

Fastighet Beskrivning
RFC1123Pattern Definierar formatet på resultatsträngen.
AbbreviatedDayNames Definierar de förkortade dagnamn 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 UTC (Coordinated Universal Time) ändrar formateringsåtgärden inte värdet för det DateTime objekt som formateras. Därför måste du konvertera DateTime-värdet till UTC genom att anropa metoden DateTime.ToUniversalTime innan du utför formateringsåtgärden. Däremot utför DateTimeOffset värden den här konverteringen automatiskt. Du behöver inte anropa metoden DateTimeOffset.ToUniversalTime 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 och 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 egenskapen DateTimeFormatInfo.SortableDateTimePattern. 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 "åååå'-'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 dess DateTimeOffset.Offset värde. 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 tidszonen usa och Stillahavsområdet.

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 egenskapen DateTimeFormatInfo.UniversalSortableDateTimePattern. 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 "åååå'-'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 metoden DateTime.ToUniversalTime innan du formaterar det. Däremot utför DateTimeOffset värden den här konverteringen automatiskt. du behöver inte anropa metoden DateTimeOffset.ToUniversalTime 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 detsamma som "F"-mönstret. Men DateTime-värdet konverteras automatiskt till UTC innan det formateras.

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

Fastighet Beskrivning
FullDateTimePattern Definierar det övergripande formatet för resultatsträngen.
DayNames Definierar de lokaliserade dagnamn som kan visas i resultatsträngen.
MonthNames Definierar de lokaliserade månadsnamn 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 klockan 12 på en 12-timmarsklocka.
PMDesignator Definierar strängen som anger tider från 12:00 till före midnatt i en 12-timmarsklocka.

Formatspecificeraren U stöds inte av den 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 egenskapen DateTimeFormatInfo.ShortTimePattern. Till exempel är den anpassade formatsträngen för den invarianta kulturen "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 för den returnerade strängen. Den anpassade formatspecificeraren som returneras av egenskapen DateTimeFormatInfo.ShortTimePattern för vissa kulturer kanske inte använder alla egenskaper.

Fastighet Beskrivning
ShortTimePattern Definierar formatet för tidskomponenten 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 klockan 12 på 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 "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 för den returnerade strängen. Den anpassade formatspecificeraren som returneras av egenskapen DateTimeFormatInfo.LongTimePattern för vissa kulturer kanske inte använder alla egenskaper.

Fastighet Beskrivning
LongTimePattern Definierar formatet för tidskomponenten 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 klockan 12 på 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 "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

Deldatumformat

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 egenskapen DateTimeFormatInfo.MonthDayPattern. 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 för den returnerade strängen.

Fastighet Beskrivning
MonthDayPattern Definierar det övergripande formatet för resultatsträngen.
MonthNames Definierar de lokaliserade månadsnamn 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 DateTimeFormatInfo.YearMonthPattern för en angiven kultur. Till exempel är den anpassade formatsträngen för den invarianta kulturen "åååå MMMM".

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

Fastighet Beskrivning
YearMonthPattern Definierar det övergripande formatet för resultatsträngen.
MonthNames Definierar de lokaliserade månadsnamn 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

Inställningar för Kontrollpanelen

I Windows påverkar inställningarna i nationella alternativ och språkalternativ objekt på Kontrollpanelen resultatsträngen som skapas av en formateringsåtgärd. De här inställningarna används för att initiera det DateTimeFormatInfo objekt som är associerat med den aktuella kulturen, vilket ger 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 alla anpassningar som har upprättats av Regionala alternativ och språkalternativ objekt 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 standardformatsspecificerarna för datum och tid ä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