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
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
Datum- och tidsformat
Den här gruppen innehåller följande format:
- Formatspecificeraren för fullständigt datum ("f")
- Formatspecificeraren för fullständigt datum ("F")
- Den allmänna kort tidsformatsspecificeraren för datum ("g")
- Formatspecificeraren för allmänt datum ("G")
- Formatspecificeraren för tur och retur ("O", "o")
- RFC1123-formatspecificeraren ("R", "r")
- Den sorterbara formatspecificeraren ("s")
- Den universella sorterbara formatspecificeraren ("u")
- Den universella fullständiga formatspecificeraren ("U")
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
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
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
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
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 Parse
metoderna DateTime , TryParse
, ParseExact
och 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.
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
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
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
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
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
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
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
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
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.