Globalisering
Globalisering innebär att utforma och utveckla en världsklar app som stöder lokaliserade gränssnitt och regionala data för användare i flera kulturer. Innan du påbörjar designfasen bör du bestämma vilka kulturer som din app ska stödja. Även om en app är avsedd för en enskild kultur eller region som standard kan du utforma och skriva den så att den enkelt kan utökas till användare i andra kulturer eller regioner.
Som utvecklare har vi alla antaganden om användargränssnitt och data som skapas av våra kulturer. För en engelsktalande utvecklare i USA verkar det till exempel helt rimligt att serialisera datum- och tidsdata som en sträng i formatetMM/dd/yyyy hh:mm:ss. Att deserialisera strängen på ett system i en annan kultur kommer dock sannolikt att utlösa ett FormatException undantag eller generera felaktiga data. Med globalisering kan vi identifiera sådana kulturspecifika antaganden och se till att de inte påverkar appens design eller kod.
I den här artikeln beskrivs några av de viktigaste problemen du bör tänka på och de metodtips du kan följa när du hanterar strängar, datum- och tidsvärden och numeriska värden i en globaliserad app.
Strängar
Hanteringen av tecken och strängar är ett centralt fokus för globaliseringen, eftersom varje kultur eller region kan använda olika tecken och teckenuppsättningar och sortera dem på olika sätt. Det här avsnittet innehåller rekommendationer för att använda strängar i globaliserade appar.
Använda Unicode internt
Som standard använder .NET Unicode-strängar. En Unicode-sträng består av noll, ett eller flera Char objekt, som var och en representerar en UTF-16-kodenhet. Det finns en Unicode-representation för nästan alla tecken i varje teckenuppsättning som används över hela världen.
Många program och operativsystem, inklusive Windows-operativsystemet, kan också använda kodsidor för att representera teckenuppsättningar. Kodsidor innehåller vanligtvis standardvärdena för ASCII från 0x00 till 0x7F och mappar andra tecken till de återstående värdena från 0x80 till 0xFF. Tolkningen av värden från 0x80 till 0xFF beror på den specifika kodsidan. Därför bör du undvika att använda kodsidor i en globaliserad app om möjligt.
I följande exempel visas farorna med att tolka kodsidedata när standardkodsidan i ett system skiljer sig från den kodsida där data sparades. (För att simulera det här scenariot anger exemplet uttryckligen olika kodsidor.) Först definierar exemplet en matris som består av versaler i det grekiska alfabetet. Den kodar dem till en bytematris med hjälp av kodsidan 737 (även kallad MS-DOS Greek) och sparar bytematrisen i en fil. Om filen hämtas och bytematrisen avkodas med hjälp av kodsidan 737 återställs de ursprungliga tecknen. Men om filen hämtas och dess bytematris avkodas med hjälp av kodsidan 1252 (eller Windows-1252, som representerar tecken i det latinska alfabetet), går de ursprungliga tecknen förlorade.
using System;
using System.IO;
using System.Text;
public class Example
{
public static void CodePages()
{
// Represent Greek uppercase characters in code page 737.
char[] greekChars =
{
'Α', 'Β', 'Γ', 'Δ', 'Ε', 'Ζ', 'Η', 'Θ',
'Ι', 'Κ', 'Λ', 'Μ', 'Ν', 'Ξ', 'Ο', 'Π',
'Ρ', 'Σ', 'Τ', 'Υ', 'Φ', 'Χ', 'Ψ', 'Ω'
};
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
Encoding cp737 = Encoding.GetEncoding(737);
int nBytes = cp737.GetByteCount(greekChars);
byte[] bytes737 = new byte[nBytes];
bytes737 = cp737.GetBytes(greekChars);
// Write the bytes to a file.
FileStream fs = new FileStream(@".\\CodePageBytes.dat", FileMode.Create);
fs.Write(bytes737, 0, bytes737.Length);
fs.Close();
// Retrieve the byte data from the file.
fs = new FileStream(@".\\CodePageBytes.dat", FileMode.Open);
byte[] bytes1 = new byte[fs.Length];
fs.Read(bytes1, 0, (int)fs.Length);
fs.Close();
// Restore the data on a system whose code page is 737.
string data = cp737.GetString(bytes1);
Console.WriteLine(data);
Console.WriteLine();
// Restore the data on a system whose code page is 1252.
Encoding cp1252 = Encoding.GetEncoding(1252);
data = cp1252.GetString(bytes1);
Console.WriteLine(data);
}
}
// The example displays the following output:
// ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ
// €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’""•–—
Imports System.IO
Imports System.Text
Module Example
Public Sub CodePages()
' Represent Greek uppercase characters in code page 737.
Dim greekChars() As Char = {"Α"c, "Β"c, "Γ"c, "Δ"c, "Ε"c, "Ζ"c, "Η"c, "Θ"c,
"Ι"c, "Κ"c, "Λ"c, "Μ"c, "Ν"c, "Ξ"c, "Ο"c, "Π"c,
"Ρ"c, "Σ"c, "Τ"c, "Υ"c, "Φ"c, "Χ"c, "Ψ"c, "Ω"c}
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance)
Dim cp737 As Encoding = Encoding.GetEncoding(737)
Dim nBytes As Integer = CInt(cp737.GetByteCount(greekChars))
Dim bytes737(nBytes - 1) As Byte
bytes737 = cp737.GetBytes(greekChars)
' Write the bytes to a file.
Dim fs As New FileStream(".\CodePageBytes.dat", FileMode.Create)
fs.Write(bytes737, 0, bytes737.Length)
fs.Close()
' Retrieve the byte data from the file.
fs = New FileStream(".\CodePageBytes.dat", FileMode.Open)
Dim bytes1(CInt(fs.Length - 1)) As Byte
fs.Read(bytes1, 0, CInt(fs.Length))
fs.Close()
' Restore the data on a system whose code page is 737.
Dim data As String = cp737.GetString(bytes1)
Console.WriteLine(data)
Console.WriteLine()
' Restore the data on a system whose code page is 1252.
Dim cp1252 As Encoding = Encoding.GetEncoding(1252)
data = cp1252.GetString(bytes1)
Console.WriteLine(data)
End Sub
End Module
' The example displays the following output:
' ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ
' €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’""•–—
Användningen av Unicode säkerställer att samma kodenheter alltid mappas till samma tecken och att samma tecken alltid mappas till samma bytematriser.
Använda resursfiler
Även om du utvecklar en app som är inriktad på en enskild kultur eller region bör du använda resursfiler för att lagra strängar och andra resurser som visas i användargränssnittet. Du bör aldrig lägga till dem direkt i koden. Att använda resursfiler har ett antal fördelar:
- Alla strängar finns på en enda plats. Du behöver inte söka i källkoden för att identifiera strängar som ska ändras för ett visst språk eller en viss kultur.
- Du behöver inte duplicera strängar. Utvecklare som inte använder resursfiler definierar ofta samma sträng i flera källkodsfiler. Den här dupliceringen ökar sannolikheten för att en eller flera instanser förbises när en sträng ändras.
- Du kan inkludera icke-strängresurser, till exempel bilder eller binära data, i resursfilen i stället för att lagra dem i en separat fristående fil, så att de enkelt kan hämtas.
Att använda resursfiler har särskilda fördelar om du skapar en lokaliserad app. När du distribuerar resurser i satellitsammansättningar väljer den gemensamma språkkörningen automatiskt en kulturanpassad resurs baserat på användarens aktuella användargränssnittskultur som definieras av CultureInfo.CurrentUICulture egenskapen. Så länge du tillhandahåller en lämplig kulturspecifik resurs och korrekt instansierar ett ResourceManager objekt eller använder en starkt skriven resursklass, hanterar körningen information om hur du hämtar lämpliga resurser.
Mer information om hur du skapar resursfiler finns i Skapa resursfiler. Information om hur du skapar och distribuerar satellitsammansättningar finns i Skapa satellitsammansättningar och Paketera och Distribuera resurser.
Söka efter och jämföra strängar
När det är möjligt bör du hantera strängar som hela strängar i stället för att hantera dem som en serie enskilda tecken. Detta är särskilt viktigt när du sorterar eller söker efter delsträngar för att förhindra problem som är associerade med parsning av kombinerade tecken.
Dricks
Du kan använda StringInfo klassen för att arbeta med textelementen i stället för de enskilda tecknen i en sträng.
I strängsökningar och jämförelser är ett vanligt misstag att behandla strängen som en samling tecken, som var och en representeras av ett Char objekt. I själva verket kan ett enskilt tecken bildas av ett, två eller flera Char objekt. Sådana tecken finns oftast i strängar från kulturer vars alfabet består av tecken utanför Unicode Basic Latin-teckenintervallet (U+0021 till U+007E). I följande exempel försöker du hitta indexet för latinsk VERSAL BOKSTAV A MED GRAVE-tecknet (U+00C0) i en sträng. Det här tecknet kan dock representeras på två olika sätt: som en enda kodenhet (U+00C0) eller som ett sammansatt tecken (två kodenheter: U+0041 och U+0300). I det här fallet representeras tecknet i stränginstansen av två Char objekt, U+0041 och U+0300. Exempelkoden anropar String.IndexOf(Char) överlagringarna och String.IndexOf(String) för att hitta positionen för det här tecknet i stränginstansen, men dessa returnerar olika resultat. Det första metodanropet har ett Char argument. Det utför en ordningstalsjämförelse och kan därför inte hitta en matchning. Det andra anropet har ett String argument. Det utför en kulturkänslig jämförelse och hittar därför en matchning.
using System;
using System.Globalization;
using System.Threading;
public class Example17
{
public static void Main17()
{
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("pl-PL");
string composite = "\u0041\u0300";
Console.WriteLine("Comparing using Char: {0}", composite.IndexOf('\u00C0'));
Console.WriteLine("Comparing using String: {0}", composite.IndexOf("\u00C0"));
}
}
// The example displays the following output:
// Comparing using Char: -1
// Comparing using String: 0
Imports System.Globalization
Imports System.Threading
Module Example17
Public Sub Main17()
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("pl-PL")
Dim composite As String = ChrW(&H41) + ChrW(&H300)
Console.WriteLine("Comparing using Char: {0}", composite.IndexOf(ChrW(&HC0)))
Console.WriteLine("Comparing using String: {0}", composite.IndexOf(ChrW(&HC0).ToString()))
End Sub
End Module
' The example displays the following output:
' Comparing using Char: -1
' Comparing using String: 0
Du kan undvika vissa tvetydigheter i det här exemplet (anrop till två liknande överlagringar av en metod som returnerar olika resultat) genom att anropa en överlagring som innehåller en StringComparison parameter, till exempel String.IndexOf(String, StringComparison) metoden eller String.LastIndexOf(String, StringComparison) .
Sökningar är dock inte alltid kulturkänsliga. Om syftet med sökningen är att fatta ett säkerhetsbeslut eller tillåta eller neka åtkomst till någon resurs, bör jämförelsen vara ordningstal, enligt beskrivningen i nästa avsnitt.
Testa strängar för likhet
Om du vill testa två strängar för likhet i stället för att bestämma hur de ska jämföras i sorteringsordningen String.Equals använder du metoden i stället för en strängjämförelsemetod som String.Compare eller CompareInfo.Compare.
Jämförelser för likhet utförs vanligtvis för att få åtkomst till vissa resurser villkorligt. Du kan till exempel göra en jämförelse för likhet för att verifiera ett lösenord eller bekräfta att en fil finns. Sådana icke-språkliga jämförelser bör alltid vara ordningstal snarare än kulturkänsliga. I allmänhet bör du anropa instansmetoden String.Equals(String, StringComparison) eller den statiska String.Equals(String, String, StringComparison) metoden med värdet StringComparison.Ordinal för för strängar som lösenord och värdet StringComparison.OrdinalIgnoreCase för för strängar som filnamn eller URI:er.
Jämförelser för likhet omfattar ibland sökningar eller delsträngsjämförelser i stället för anrop till String.Equals metoden. I vissa fall kan du använda en delsträngssökning för att avgöra om delsträngen är lika med en annan sträng. Om syftet med denna jämförelse är icke-språklig bör sökningen också vara ordningstal snarare än kulturkänslig.
I följande exempel visas risken för en kulturkänslig sökning på icke-språkliga data. Metoden AccessesFileSystem är utformad för att förbjuda filsystemåtkomst för URI:er som börjar med delsträngen "FILE". För att göra detta utför den en kulturkänslig, skiftlägeskänslig jämförelse av början av URI:n med strängen "FILE". Eftersom en URI som kommer åt filsystemet kan börja med antingen "FILE:" eller "file:", är det implicita antagandet att "i" (U+0069) alltid är den gemena motsvarigheten till "I" (U+0049). Men på turkiska och azerbajdzjanska är den versala versionen av "i" "İ" (U+0130). På grund av den här avvikelsen tillåter den kulturkänsliga jämförelsen åtkomst till filsystem när det bör förbjudas.
using System;
using System.Globalization;
using System.Threading;
public class Example10
{
public static void Main10()
{
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");
string uri = @"file:\\c:\users\username\Documents\bio.txt";
if (!AccessesFileSystem(uri))
// Permit access to resource specified by URI
Console.WriteLine("Access is allowed.");
else
// Prohibit access.
Console.WriteLine("Access is not allowed.");
}
private static bool AccessesFileSystem(string uri)
{
return uri.StartsWith("FILE", true, CultureInfo.CurrentCulture);
}
}
// The example displays the following output:
// Access is allowed.
Imports System.Globalization
Imports System.Threading
Module Example10
Public Sub Main10()
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR")
Dim uri As String = "file:\\c:\users\username\Documents\bio.txt"
If Not AccessesFileSystem(uri) Then
' Permit access to resource specified by URI
Console.WriteLine("Access is allowed.")
Else
' Prohibit access.
Console.WriteLine("Access is not allowed.")
End If
End Sub
Private Function AccessesFileSystem(uri As String) As Boolean
Return uri.StartsWith("FILE", True, CultureInfo.CurrentCulture)
End Function
End Module
' The example displays the following output:
' Access is allowed.
Du kan undvika det här problemet genom att utföra en ordningstalsjämförelse som ignorerar fall, vilket visas i följande exempel.
using System;
using System.Globalization;
using System.Threading;
public class Example11
{
public static void Main11()
{
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");
string uri = @"file:\\c:\users\username\Documents\bio.txt";
if (!AccessesFileSystem(uri))
// Permit access to resource specified by URI
Console.WriteLine("Access is allowed.");
else
// Prohibit access.
Console.WriteLine("Access is not allowed.");
}
private static bool AccessesFileSystem(string uri)
{
return uri.StartsWith("FILE", StringComparison.OrdinalIgnoreCase);
}
}
// The example displays the following output:
// Access is not allowed.
Imports System.Globalization
Imports System.Threading
Module Example11
Public Sub Main11()
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR")
Dim uri As String = "file:\\c:\users\username\Documents\bio.txt"
If Not AccessesFileSystem(uri) Then
' Permit access to resource specified by URI
Console.WriteLine("Access is allowed.")
Else
' Prohibit access.
Console.WriteLine("Access is not allowed.")
End If
End Sub
Private Function AccessesFileSystem(uri As String) As Boolean
Return uri.StartsWith("FILE", StringComparison.OrdinalIgnoreCase)
End Function
End Module
' The example displays the following output:
' Access is not allowed.
Ordna och sortera strängar
Vanligtvis ska ordnade strängar som ska visas i användargränssnittet sorteras baserat på kultur. För det mesta hanteras sådana strängjämförelser implicit av .NET när du anropar en metod som sorterar strängar, till exempel Array.Sort eller List<T>.Sort. Som standard sorteras strängarna med hjälp av sorteringskonventionerna i den aktuella kulturen. I följande exempel visas skillnaden när en matris med strängar sorteras med hjälp av konventionerna i den engelska (USA) kulturen och den svenska (Sverige) kulturen.
using System;
using System.Globalization;
using System.Threading;
public class Example18
{
public static void Main18()
{
string[] values = { "able", "ångström", "apple", "Æble",
"Windows", "Visual Studio" };
// Change thread to en-US.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
// Sort the array and copy it to a new array to preserve the order.
Array.Sort(values);
string[] enValues = (String[])values.Clone();
// Change culture to Swedish (Sweden).
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("sv-SE");
Array.Sort(values);
string[] svValues = (String[])values.Clone();
// Compare the sorted arrays.
Console.WriteLine("{0,-8} {1,-15} {2,-15}\n", "Position", "en-US", "sv-SE");
for (int ctr = 0; ctr <= values.GetUpperBound(0); ctr++)
Console.WriteLine("{0,-8} {1,-15} {2,-15}", ctr, enValues[ctr], svValues[ctr]);
}
}
// The example displays the following output:
// Position en-US sv-SE
//
// 0 able able
// 1 Æble Æble
// 2 ångström apple
// 3 apple Windows
// 4 Visual Studio Visual Studio
// 5 Windows ångström
Imports System.Globalization
Imports System.Threading
Module Example18
Public Sub Main18()
Dim values() As String = {"able", "ångström", "apple",
"Æble", "Windows", "Visual Studio"}
' Change thread to en-US.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
' Sort the array and copy it to a new array to preserve the order.
Array.Sort(values)
Dim enValues() As String = CType(values.Clone(), String())
' Change culture to Swedish (Sweden).
Thread.CurrentThread.CurrentCulture = New CultureInfo("sv-SE")
Array.Sort(values)
Dim svValues() As String = CType(values.Clone(), String())
' Compare the sorted arrays.
Console.WriteLine("{0,-8} {1,-15} {2,-15}", "Position", "en-US", "sv-SE")
Console.WriteLine()
For ctr As Integer = 0 To values.GetUpperBound(0)
Console.WriteLine("{0,-8} {1,-15} {2,-15}", ctr, enValues(ctr), svValues(ctr))
Next
End Sub
End Module
' The example displays the following output:
' Position en-US sv-SE
'
' 0 able able
' 1 Æble Æble
' 2 ångström apple
' 3 apple Windows
' 4 Visual Studio Visual Studio
' 5 Windows ångström
Kulturkänslig strängjämförelse definieras av CompareInfo objektet, som returneras av varje kulturs CultureInfo.CompareInfo egenskap. Kulturkänsliga strängjämförelser som använder String.Compare metoden överlagrar använder CompareInfo också objektet.
.NET använder tabeller för att utföra kulturkänsliga sorteringar på strängdata. Innehållet i dessa tabeller, som innehåller data om sorteringsvikter och strängnormalisering, bestäms av den version av Unicode-standarden som implementeras av en viss version av .NET. I följande tabell visas de versioner av Unicode som implementerats av de angivna versionerna av .NET. Den här listan över Unicode-versioner som stöds gäller endast för teckenjämförelse och sortering. Det gäller inte för klassificering av Unicode-tecken efter kategori. Mer information finns i avsnittet "Strängar och Unicode Standard" i String artikeln.
| .NET Framework-version | Operativsystem | Unicode-version |
|---|---|---|
| .NET Framework 2.0 | Alla operativsystem | Unicode 4.1 |
| .NET Framework 3.0 | Alla operativsystem | Unicode 4.1 |
| .NET Framework 3.5 | Alla operativsystem | Unicode 4.1 |
| .NET Framework 4 | Alla operativsystem | Unicode 5.0 |
| .NET Framework 4.5 och senare | Windows 7 | Unicode 5.0 |
| .NET Framework 4.5 och senare | Windows 8 och senare operativsystem | Unicode 6.3.0 |
| .NET Core och .NET 5+ | Beror på vilken version av Unicode Standard som stöds av det underliggande operativsystemet. |
Från och med .NET Framework 4.5 och i alla versioner av .NET Core och .NET 5+, beror strängjämförelse och sortering på operativsystemet. .NET Framework 4.5 och senare som körs på Windows 7 hämtar data från sina egna tabeller som implementerar Unicode 5.0. .NET Framework 4.5 och senare körs på Windows 8 och hämtar senare data från operativsystemtabeller som implementerar Unicode 6.3. På .NET Core och .NET 5+ beror den version av Unicode som stöds på det underliggande operativsystemet. Om du serialiserar kulturkänsliga sorterade data kan du använda SortVersion klassen för att avgöra när dina serialiserade data behöver sorteras så att de överensstämmer med .NET och operativsystemets sorteringsordning. Ett exempel finns i klassavsnittet SortVersion .
Om din app utför omfattande kulturspecifika typer av strängdata kan du arbeta med SortKey klassen för att jämföra strängar. En sorteringsnyckel återspeglar de kulturspecifika sorteringsvikterna, inklusive alfabetiska vikter, skiftläges- och diakritiska vikter för en viss sträng. Eftersom jämförelser med sorteringsnycklar är binära är de snabbare än jämförelser som använder ett CompareInfo objekt antingen implicit eller explicit. Du skapar en kulturspecifik sorteringsnyckel för en viss sträng genom att skicka strängen till CompareInfo.GetSortKey metoden.
Följande exempel liknar föregående exempel. Men i stället för att anropa Array.Sort(Array) metoden, som implicit anropar CompareInfo.Compare metoden, definierar den en System.Collections.Generic.IComparer<T> implementering som jämför sorteringsnycklar, som den instansierar och skickar till Array.Sort<T>(T[], IComparer<T>) metoden.
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Threading;
public class SortKeyComparer : IComparer<String>
{
public int Compare(string? str1, string? str2)
{
return (str1, str2) switch
{
(null, null) => 0,
(null, _) => -1,
(_, null) => 1,
(var s1, var s2) => SortKey.Compare(
CultureInfo.CurrentCulture.CompareInfo.GetSortKey(s1),
CultureInfo.CurrentCulture.CompareInfo.GetSortKey(s1))
};
}
}
public class Example19
{
public static void Main19()
{
string[] values = { "able", "ångström", "apple", "Æble",
"Windows", "Visual Studio" };
SortKeyComparer comparer = new SortKeyComparer();
// Change thread to en-US.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
// Sort the array and copy it to a new array to preserve the order.
Array.Sort(values, comparer);
string[] enValues = (String[])values.Clone();
// Change culture to Swedish (Sweden).
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("sv-SE");
Array.Sort(values, comparer);
string[] svValues = (String[])values.Clone();
// Compare the sorted arrays.
Console.WriteLine("{0,-8} {1,-15} {2,-15}\n", "Position", "en-US", "sv-SE");
for (int ctr = 0; ctr <= values.GetUpperBound(0); ctr++)
Console.WriteLine("{0,-8} {1,-15} {2,-15}", ctr, enValues[ctr], svValues[ctr]);
}
}
// The example displays the following output:
// Position en-US sv-SE
//
// 0 able able
// 1 Æble Æble
// 2 ångström apple
// 3 apple Windows
// 4 Visual Studio Visual Studio
// 5 Windows ångström
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Threading
Public Class SortKeyComparer : Implements IComparer(Of String)
Public Function Compare(str1 As String, str2 As String) As Integer _
Implements IComparer(Of String).Compare
Dim sk1, sk2 As SortKey
sk1 = CultureInfo.CurrentCulture.CompareInfo.GetSortKey(str1)
sk2 = CultureInfo.CurrentCulture.CompareInfo.GetSortKey(str2)
Return SortKey.Compare(sk1, sk2)
End Function
End Class
Module Example19
Public Sub Main19()
Dim values() As String = {"able", "ångström", "apple",
"Æble", "Windows", "Visual Studio"}
Dim comparer As New SortKeyComparer()
' Change thread to en-US.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
' Sort the array and copy it to a new array to preserve the order.
Array.Sort(values, comparer)
Dim enValues() As String = CType(values.Clone(), String())
' Change culture to Swedish (Sweden).
Thread.CurrentThread.CurrentCulture = New CultureInfo("sv-SE")
Array.Sort(values, comparer)
Dim svValues() As String = CType(values.Clone(), String())
' Compare the sorted arrays.
Console.WriteLine("{0,-8} {1,-15} {2,-15}", "Position", "en-US", "sv-SE")
Console.WriteLine()
For ctr As Integer = 0 To values.GetUpperBound(0)
Console.WriteLine("{0,-8} {1,-15} {2,-15}", ctr, enValues(ctr), svValues(ctr))
Next
End Sub
End Module
' The example displays the following output:
' Position en-US sv-SE
'
' 0 able able
' 1 Æble Æble
' 2 ångström apple
' 3 apple Windows
' 4 Visual Studio Visual Studio
' 5 Windows ångström
Undvik strängsammanfogning
Undvik om möjligt att använda sammansatta strängar som skapas vid körning från sammanfogade fraser. Sammansatta strängar är svåra att lokalisera, eftersom de ofta förutsätter en grammatisk ordning i appens ursprungliga språk som inte gäller för andra lokaliserade språk.
Hantera datum och tider
Hur du hanterar datum- och tidsvärden beror på om de visas i användargränssnittet eller behålls. Det här avsnittet undersöker båda användningarna. Den beskriver också hur du kan hantera tidszonsskillnader och aritmetiska åtgärder när du arbetar med datum och tider.
Visa datum och tider
När datum och tider visas i användargränssnittet bör du vanligtvis använda formateringskonventionerna för användarens kultur, som definieras av CultureInfo.CurrentCulture egenskapen och av objektet DateTimeFormatInfo som returneras av CultureInfo.CurrentCulture.DateTimeFormat egenskapen. Formateringskonventionerna i den aktuella kulturen används automatiskt när du formaterar ett datum med någon av följande metoder:
Den parameterlösa DateTime.ToString() metoden
Metoden DateTime.ToString(String) , som innehåller en formatsträng
Den parameterlösa DateTimeOffset.ToString() metoden
, DateTimeOffset.ToString(String)som innehåller en formatsträng
Den sammansatta formateringsfunktionen , när den används med datum
I följande exempel visas data om soluppgång och solnedgång två gånger för den 11 oktober 2012. Den sätter först den nuvarande kulturen till kroatiska (Kroatien), och sedan till engelska (Storbritannien). I varje fall visas datum och tider i det format som är lämpligt för den kulturen.
using System;
using System.Globalization;
using System.Threading;
public class Example3
{
static DateTime[] dates = { new DateTime(2012, 10, 11, 7, 06, 0),
new DateTime(2012, 10, 11, 18, 19, 0) };
public static void Main3()
{
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("hr-HR");
ShowDayInfo();
Console.WriteLine();
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
ShowDayInfo();
}
private static void ShowDayInfo()
{
Console.WriteLine("Date: {0:D}", dates[0]);
Console.WriteLine(" Sunrise: {0:T}", dates[0]);
Console.WriteLine(" Sunset: {0:T}", dates[1]);
}
}
// The example displays the following output:
// Date: 11. listopada 2012.
// Sunrise: 7:06:00
// Sunset: 18:19:00
//
// Date: 11 October 2012
// Sunrise: 07:06:00
// Sunset: 18:19:00
Imports System.Globalization
Imports System.Threading
Module Example3
Dim dates() As Date = {New Date(2012, 10, 11, 7, 6, 0),
New Date(2012, 10, 11, 18, 19, 0)}
Public Sub Main3()
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("hr-HR")
ShowDayInfo()
Console.WriteLine()
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
ShowDayInfo()
End Sub
Private Sub ShowDayInfo()
Console.WriteLine("Date: {0:D}", dates(0))
Console.WriteLine(" Sunrise: {0:T}", dates(0))
Console.WriteLine(" Sunset: {0:T}", dates(1))
End Sub
End Module
' The example displays the following output:
' Date: 11. listopada 2012.
' Sunrise: 7:06:00
' Sunset: 18:19:00
'
' Date: 11 October 2012
' Sunrise: 07:06:00
' Sunset: 18:19:00
Spara datum och tider
Du bör aldrig spara datum- och tidsdata i ett format som kan variera beroende på kultur. Det här är ett vanligt programmeringsfel som resulterar i skadade data eller ett körningsfel. I följande exempel serialiseras två datum, 9 januari 2013 och 18 augusti 2013, som strängar med hjälp av formateringskonventionerna i den engelska kulturen (USA). När data hämtas och parsas med hjälp av konventionerna i den engelska kulturen (USA) återställs de. Men när det hämtas och parsas med hjälp av konventionerna i den engelska kulturen (Storbritannien) tolkas det första datumet felaktigt som 1 september, och det andra misslyckas med att parsa eftersom den gregorianska kalendern inte har någon artonde månad.
using System;
using System.IO;
using System.Globalization;
using System.Threading;
public class Example4
{
public static void Main4()
{
// Persist two dates as strings.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
DateTime[] dates = { new DateTime(2013, 1, 9),
new DateTime(2013, 8, 18) };
StreamWriter sw = new StreamWriter("dateData.dat");
sw.Write("{0:d}|{1:d}", dates[0], dates[1]);
sw.Close();
// Read the persisted data.
StreamReader sr = new StreamReader("dateData.dat");
string dateData = sr.ReadToEnd();
sr.Close();
string[] dateStrings = dateData.Split('|');
// Restore and display the data using the conventions of the en-US culture.
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName);
foreach (var dateStr in dateStrings)
{
DateTime restoredDate;
if (DateTime.TryParse(dateStr, out restoredDate))
Console.WriteLine("The date is {0:D}", restoredDate);
else
Console.WriteLine("ERROR: Unable to parse {0}", dateStr);
}
Console.WriteLine();
// Restore and display the data using the conventions of the en-GB culture.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName);
foreach (var dateStr in dateStrings)
{
DateTime restoredDate;
if (DateTime.TryParse(dateStr, out restoredDate))
Console.WriteLine("The date is {0:D}", restoredDate);
else
Console.WriteLine("ERROR: Unable to parse {0}", dateStr);
}
}
}
// The example displays the following output:
// Current Culture: English (United States)
// The date is Wednesday, January 09, 2013
// The date is Sunday, August 18, 2013
//
// Current Culture: English (United Kingdom)
// The date is 01 September 2013
// ERROR: Unable to parse 8/18/2013
Imports System.Globalization
Imports System.IO
Imports System.Threading
Module Example4
Public Sub Main4()
' Persist two dates as strings.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
Dim dates() As DateTime = {New DateTime(2013, 1, 9),
New DateTime(2013, 8, 18)}
Dim sw As New StreamWriter("dateData.dat")
sw.Write("{0:d}|{1:d}", dates(0), dates(1))
sw.Close()
' Read the persisted data.
Dim sr As New StreamReader("dateData.dat")
Dim dateData As String = sr.ReadToEnd()
sr.Close()
Dim dateStrings() As String = dateData.Split("|"c)
' Restore and display the data using the conventions of the en-US culture.
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName)
For Each dateStr In dateStrings
Dim restoredDate As Date
If Date.TryParse(dateStr, restoredDate) Then
Console.WriteLine("The date is {0:D}", restoredDate)
Else
Console.WriteLine("ERROR: Unable to parse {0}", dateStr)
End If
Next
Console.WriteLine()
' Restore and display the data using the conventions of the en-GB culture.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName)
For Each dateStr In dateStrings
Dim restoredDate As Date
If Date.TryParse(dateStr, restoredDate) Then
Console.WriteLine("The date is {0:D}", restoredDate)
Else
Console.WriteLine("ERROR: Unable to parse {0}", dateStr)
End If
Next
End Sub
End Module
' The example displays the following output:
' Current Culture: English (United States)
' The date is Wednesday, January 09, 2013
' The date is Sunday, August 18, 2013
'
' Current Culture: English (United Kingdom)
' The date is 01 September 2013
' ERROR: Unable to parse 8/18/2013
Du kan undvika det här problemet på något av tre sätt:
- Serialisera datum och tid i binärt format i stället för som en sträng.
- Spara och parsa strängrepresentationen av datum och tid med hjälp av en anpassad formatsträng som är densamma oavsett användarens kultur.
- Spara strängen med formateringskonventionerna i den invarianta kulturen.
I följande exempel visas den sista metoden. Den använder formateringskonventionerna för den invarianta kultur som returneras av den statiska CultureInfo.InvariantCulture egenskapen.
using System;
using System.IO;
using System.Globalization;
using System.Threading;
public class Example5
{
public static void Main5()
{
// Persist two dates as strings.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
DateTime[] dates = { new DateTime(2013, 1, 9),
new DateTime(2013, 8, 18) };
StreamWriter sw = new StreamWriter("dateData.dat");
sw.Write(String.Format(CultureInfo.InvariantCulture,
"{0:d}|{1:d}", dates[0], dates[1]));
sw.Close();
// Read the persisted data.
StreamReader sr = new StreamReader("dateData.dat");
string dateData = sr.ReadToEnd();
sr.Close();
string[] dateStrings = dateData.Split('|');
// Restore and display the data using the conventions of the en-US culture.
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName);
foreach (var dateStr in dateStrings)
{
DateTime restoredDate;
if (DateTime.TryParse(dateStr, CultureInfo.InvariantCulture,
DateTimeStyles.None, out restoredDate))
Console.WriteLine("The date is {0:D}", restoredDate);
else
Console.WriteLine("ERROR: Unable to parse {0}", dateStr);
}
Console.WriteLine();
// Restore and display the data using the conventions of the en-GB culture.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName);
foreach (var dateStr in dateStrings)
{
DateTime restoredDate;
if (DateTime.TryParse(dateStr, CultureInfo.InvariantCulture,
DateTimeStyles.None, out restoredDate))
Console.WriteLine("The date is {0:D}", restoredDate);
else
Console.WriteLine("ERROR: Unable to parse {0}", dateStr);
}
}
}
// The example displays the following output:
// Current Culture: English (United States)
// The date is Wednesday, January 09, 2013
// The date is Sunday, August 18, 2013
//
// Current Culture: English (United Kingdom)
// The date is 09 January 2013
// The date is 18 August 2013
Imports System.Globalization
Imports System.IO
Imports System.Threading
Module Example5
Public Sub Main5()
' Persist two dates as strings.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
Dim dates() As DateTime = {New DateTime(2013, 1, 9),
New DateTime(2013, 8, 18)}
Dim sw As New StreamWriter("dateData.dat")
sw.Write(String.Format(CultureInfo.InvariantCulture,
"{0:d}|{1:d}", dates(0), dates(1)))
sw.Close()
' Read the persisted data.
Dim sr As New StreamReader("dateData.dat")
Dim dateData As String = sr.ReadToEnd()
sr.Close()
Dim dateStrings() As String = dateData.Split("|"c)
' Restore and display the data using the conventions of the en-US culture.
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName)
For Each dateStr In dateStrings
Dim restoredDate As Date
If Date.TryParse(dateStr, CultureInfo.InvariantCulture,
DateTimeStyles.None, restoredDate) Then
Console.WriteLine("The date is {0:D}", restoredDate)
Else
Console.WriteLine("ERROR: Unable to parse {0}", dateStr)
End If
Next
Console.WriteLine()
' Restore and display the data using the conventions of the en-GB culture.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName)
For Each dateStr In dateStrings
Dim restoredDate As Date
If Date.TryParse(dateStr, CultureInfo.InvariantCulture,
DateTimeStyles.None, restoredDate) Then
Console.WriteLine("The date is {0:D}", restoredDate)
Else
Console.WriteLine("ERROR: Unable to parse {0}", dateStr)
End If
Next
End Sub
End Module
' The example displays the following output:
' Current Culture: English (United States)
' The date is Wednesday, January 09, 2013
' The date is Sunday, August 18, 2013
'
' Current Culture: English (United Kingdom)
' The date is 09 January 2013
' The date is 18 August 2013
Serialisering och tidszonsmedvetenhet
Ett datum- och tidsvärde kan ha flera tolkningar, allt från en allmän tid ("Butikerna öppnar den 2 januari 2013, kl. 09:00.") till ett visst ögonblick ("Födelsedatum: 2 januari 2013 06:32:00 A.M."). När ett tidsvärde representerar ett specifikt ögonblick i tiden och du återställer det från ett serialiserat värde bör du se till att det representerar samma tidpunkt oavsett användarens geografiska plats eller tidszon.
I följande exempel visas det här problemet. Det sparar ett enda lokalt datum- och tidsvärde som en sträng i tre standardformat:
- "G" för allmänt datum lång tid.
- "s" för sorterbart datum/tid.
- "o" för returdatum/tid.
using System;
using System.IO;
public class Example6
{
public static void Main6()
{
DateTime dateOriginal = new DateTime(2023, 3, 30, 18, 0, 0);
dateOriginal = DateTime.SpecifyKind(dateOriginal, DateTimeKind.Local);
// Serialize a date.
if (!File.Exists("DateInfo.dat"))
{
StreamWriter sw = new StreamWriter("DateInfo.dat");
sw.Write("{0:G}|{0:s}|{0:o}", dateOriginal);
sw.Close();
Console.WriteLine("Serialized dates to DateInfo.dat");
}
Console.WriteLine();
// Restore the date from string values.
StreamReader sr = new StreamReader("DateInfo.dat");
string datesToSplit = sr.ReadToEnd();
string[] dateStrings = datesToSplit.Split('|');
foreach (var dateStr in dateStrings)
{
DateTime newDate = DateTime.Parse(dateStr);
Console.WriteLine("'{0}' --> {1} {2}",
dateStr, newDate, newDate.Kind);
}
}
}
Imports System.IO
Module Example6
Public Sub Main6()
' Serialize a date.
Dim dateOriginal As Date = #03/30/2023 6:00PM#
dateOriginal = DateTime.SpecifyKind(dateOriginal, DateTimeKind.Local)
' Serialize the date in string form.
If Not File.Exists("DateInfo.dat") Then
Dim sw As New StreamWriter("DateInfo.dat")
sw.Write("{0:G}|{0:s}|{0:o}", dateOriginal)
sw.Close()
End If
' Restore the date from string values.
Dim sr As New StreamReader("DateInfo.dat")
Dim datesToSplit As String = sr.ReadToEnd()
Dim dateStrings() As String = datesToSplit.Split("|"c)
For Each dateStr In dateStrings
Dim newDate As DateTime = DateTime.Parse(dateStr)
Console.WriteLine("'{0}' --> {1} {2}",
dateStr, newDate, newDate.Kind)
Next
End Sub
End Module
När data återställs i ett system i samma tidszon som systemet där de serialiserades, återspeglar de deserialiserade datum- och tidsvärdena korrekt det ursprungliga värdet, som utdata visar:
'3/30/2013 6:00:00 PM' --> 3/30/2013 6:00:00 PM Unspecified
'2013-03-30T18:00:00' --> 3/30/2013 6:00:00 PM Unspecified
'2013-03-30T18:00:00.0000000-07:00' --> 3/30/2013 6:00:00 PM Local
Men om du återställer data i ett system i en annan tidszon bevarar endast det datum- och tidsvärde som formaterats med standardformatsträngen "o" (tur och retur) tidszonsinformation och representerar därför samma ögonblick i tiden. Här är utdata när datum- och tidsdata återställs i ett system i Romance Standard-tidszonen:
'3/30/2023 6:00:00 PM' --> 3/30/2023 6:00:00 PM Unspecified
'2023-03-30T18:00:00' --> 3/30/2023 6:00:00 PM Unspecified
'2023-03-30T18:00:00.0000000-07:00' --> 3/31/2023 3:00:00 AM Local
Du kan göra något av följande för att korrekt återspegla ett datum- och tidsvärde som representerar en enda tidpunkt oavsett tidszonen i systemet där data deserialiseras:
- Spara värdet som en sträng med standardformatsträngen "o" (tur och retur). Deserialisera den sedan på målsystemet.
- Konvertera den till UTC och spara den som en sträng med standardformatsträngen "r" (RFC1123). Deserialisera den sedan på målsystemet och konvertera den till lokal tid.
- Konvertera den till UTC och spara den som en sträng med standardformatsträngen "u" (universell sorterbar). Deserialisera den sedan på målsystemet och konvertera den till lokal tid.
I följande exempel visas varje teknik.
using System;
using System.IO;
public class Example9
{
public static void Main9()
{
// Serialize a date.
DateTime dateOriginal = new DateTime(2023, 3, 30, 18, 0, 0);
dateOriginal = DateTime.SpecifyKind(dateOriginal, DateTimeKind.Local);
// Serialize the date in string form.
if (!File.Exists("DateInfo2.dat"))
{
StreamWriter sw = new StreamWriter("DateInfo2.dat");
sw.Write("{0:o}|{1:r}|{1:u}", dateOriginal,
dateOriginal.ToUniversalTime());
sw.Close();
}
// Restore the date from string values.
StreamReader sr = new StreamReader("DateInfo2.dat");
string datesToSplit = sr.ReadToEnd();
string[] dateStrings = datesToSplit.Split('|');
for (int ctr = 0; ctr < dateStrings.Length; ctr++)
{
DateTime newDate = DateTime.Parse(dateStrings[ctr]);
if (ctr == 1)
{
Console.WriteLine($"'{dateStrings[ctr]}' --> {newDate} {newDate.Kind}");
}
else
{
DateTime newLocalDate = newDate.ToLocalTime();
Console.WriteLine($"'{dateStrings[ctr]}' --> {newLocalDate} {newLocalDate.Kind}");
}
}
}
}
Imports System.IO
Module Example9
Public Sub Main9()
' Serialize a date.
Dim dateOriginal As Date = #03/30/2023 6:00PM#
dateOriginal = DateTime.SpecifyKind(dateOriginal, DateTimeKind.Local)
' Serialize the date in string form.
If Not File.Exists("DateInfo2.dat") Then
Dim sw As New StreamWriter("DateInfo2.dat")
sw.Write("{0:o}|{1:r}|{1:u}", dateOriginal,
dateOriginal.ToUniversalTime())
sw.Close()
End If
' Restore the date from string values.
Dim sr As New StreamReader("DateInfo2.dat")
Dim datesToSplit As String = sr.ReadToEnd()
Dim dateStrings() As String = datesToSplit.Split("|"c)
For ctr As Integer = 0 To dateStrings.Length - 1
Dim newDate As DateTime = DateTime.Parse(dateStrings(ctr))
If ctr = 1 Then
Console.WriteLine("'{0}' --> {1} {2}",
dateStrings(ctr), newDate, newDate.Kind)
Else
Dim newLocalDate As DateTime = newDate.ToLocalTime()
Console.WriteLine("'{0}' --> {1} {2}",
dateStrings(ctr), newLocalDate, newLocalDate.Kind)
End If
Next
End Sub
End Module
När data serialiseras på ett system i Pacific Standard Time-zonen och deserialiseras på ett system i zonen Romance Standard Time visas följande utdata i exemplet:
'2023-03-30T18:00:00.0000000-07:00' --> 3/31/2023 3:00:00 AM Local
'Sun, 31 Mar 2023 01:00:00 GMT' --> 3/31/2023 3:00:00 AM Local
'2023-03-31 01:00:00Z' --> 3/31/2023 3:00:00 AM Local
Mer information finns i Konvertera tider mellan tidszoner.
Utföra aritmetik för datum och tid
Både typerna DateTime och DateTimeOffset stöder aritmetiska åtgärder. Du kan beräkna skillnaden mellan två datumvärden eller lägga till eller subtrahera vissa tidsintervall till eller från ett datumvärde. Aritmetiska åtgärder för datum- och tidsvärden tar dock inte hänsyn till tidszoner och tidszonsjusteringsregler. På grund av detta kan datum- och tidsaritmetik för värden som representerar ögonblick i tiden returnera felaktiga resultat.
Övergången från Pacific Standard Time till Pacific Daylight Time sker till exempel den andra söndagen i mars, som är den 10 mars för året 2013. Som följande exempel visar, om du beräknar datum och tid som är 48 timmar efter den 9 mars 2013 kl. 10:30 på ett system i Pacific Standard Time-zonen, tar resultatet, 11 mars 2013 kl. 10:30, inte hänsyn till den mellanliggande tidsjusteringen.
using System;
public class Example7
{
public static void Main7()
{
DateTime date1 = DateTime.SpecifyKind(new DateTime(2013, 3, 9, 10, 30, 0),
DateTimeKind.Local);
TimeSpan interval = new TimeSpan(48, 0, 0);
DateTime date2 = date1 + interval;
Console.WriteLine("{0:g} + {1:N1} hours = {2:g}",
date1, interval.TotalHours, date2);
}
}
// The example displays the following output:
// 3/9/2013 10:30 AM + 48.0 hours = 3/11/2013 10:30 AM
Module Example7
Public Sub Main7()
Dim date1 As Date = DateTime.SpecifyKind(#3/9/2013 10:30AM#,
DateTimeKind.Local)
Dim interval As New TimeSpan(48, 0, 0)
Dim date2 As Date = date1 + interval
Console.WriteLine("{0:g} + {1:N1} hours = {2:g}",
date1, interval.TotalHours, date2)
End Sub
End Module
' The example displays the following output:
' 3/9/2013 10:30 AM + 48.0 hours = 3/11/2013 10:30 AM
Följ dessa steg för att säkerställa att en aritmetikåtgärd på datum- och tidsvärden ger korrekta resultat:
- Konvertera tiden i källtidszonen till UTC.
- Utför den aritmetiska åtgärden.
- Om resultatet är ett datum- och tidsvärde konverterar du det från UTC till tiden i källtidszonen.
Följande exempel liknar föregående exempel, förutom att det följer dessa tre steg för att lägga till 48 timmar till 9 mars 2013 kl. 10:30.
using System;
public class Example8
{
public static void Main8()
{
TimeZoneInfo pst = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
DateTime date1 = DateTime.SpecifyKind(new DateTime(2013, 3, 9, 10, 30, 0),
DateTimeKind.Local);
DateTime utc1 = date1.ToUniversalTime();
TimeSpan interval = new TimeSpan(48, 0, 0);
DateTime utc2 = utc1 + interval;
DateTime date2 = TimeZoneInfo.ConvertTimeFromUtc(utc2, pst);
Console.WriteLine("{0:g} + {1:N1} hours = {2:g}",
date1, interval.TotalHours, date2);
}
}
// The example displays the following output:
// 3/9/2013 10:30 AM + 48.0 hours = 3/11/2013 11:30 AM
Module Example8
Public Sub Main8()
Dim pst As TimeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time")
Dim date1 As Date = DateTime.SpecifyKind(#3/9/2013 10:30AM#,
DateTimeKind.Local)
Dim utc1 As Date = date1.ToUniversalTime()
Dim interval As New TimeSpan(48, 0, 0)
Dim utc2 As Date = utc1 + interval
Dim date2 As Date = TimeZoneInfo.ConvertTimeFromUtc(utc2, pst)
Console.WriteLine("{0:g} + {1:N1} hours = {2:g}",
date1, interval.TotalHours, date2)
End Sub
End Module
' The example displays the following output:
' 3/9/2013 10:30 AM + 48.0 hours = 3/11/2013 11:30 AM
Mer information finns i Utföra aritmetiska åtgärder med datum och tider.
Använda kulturkänsliga namn för datumelement
Din app kan behöva visa namnet på månaden eller veckodagen. För att göra detta är kod som följande vanlig.
using System;
public class Example12
{
public static void Main12()
{
DateTime midYear = new DateTime(2013, 7, 1);
Console.WriteLine("{0:d} is a {1}.", midYear, GetDayName(midYear));
}
private static string GetDayName(DateTime date)
{
return date.DayOfWeek.ToString("G");
}
}
// The example displays the following output:
// 7/1/2013 is a Monday.
Module Example12
Public Sub Main12()
Dim midYear As Date = #07/01/2013#
Console.WriteLine("{0:d} is a {1}.", midYear, GetDayName(midYear))
End Sub
Private Function GetDayName(dat As Date) As String
Return dat.DayOfWeek.ToString("G")
End Function
End Module
' The example displays the following output:
' 7/1/2013 is a Monday.
Den här koden returnerar dock alltid namnen på veckodagarna på engelska. Kod som extraherar namnet på månaden är ofta ännu mer oflexibel. Det förutsätter ofta en tolv månaders kalender med namn på månader på ett visst språk.
Genom att använda anpassade datum- och tidsformatsträngar eller objektets egenskaper DateTimeFormatInfo är det enkelt att extrahera strängar som återspeglar namnen på veckodagar eller månader i användarens kultur, vilket visas i följande exempel. Den ändrar den nuvarande kulturen till franska (Frankrike) och visar namnet på veckodagen och namnet på månaden för 1 juli 2013.
using System;
using System.Globalization;
public class Example13
{
public static void Main13()
{
// Set the current culture to French (France).
CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
DateTime midYear = new DateTime(2013, 7, 1);
Console.WriteLine("{0:d} is a {1}.", midYear, DateUtilities.GetDayName(midYear));
Console.WriteLine("{0:d} is a {1}.", midYear, DateUtilities.GetDayName((int)midYear.DayOfWeek));
Console.WriteLine("{0:d} is in {1}.", midYear, DateUtilities.GetMonthName(midYear));
Console.WriteLine("{0:d} is in {1}.", midYear, DateUtilities.GetMonthName(midYear.Month));
}
}
public static class DateUtilities
{
public static string GetDayName(int dayOfWeek)
{
if (dayOfWeek < 0 | dayOfWeek > DateTimeFormatInfo.CurrentInfo.DayNames.Length)
return String.Empty;
else
return DateTimeFormatInfo.CurrentInfo.DayNames[dayOfWeek];
}
public static string GetDayName(DateTime date)
{
return date.ToString("dddd");
}
public static string GetMonthName(int month)
{
if (month < 1 | month > DateTimeFormatInfo.CurrentInfo.MonthNames.Length - 1)
return String.Empty;
else
return DateTimeFormatInfo.CurrentInfo.MonthNames[month - 1];
}
public static string GetMonthName(DateTime date)
{
return date.ToString("MMMM");
}
}
// The example displays the following output:
// 01/07/2013 is a lundi.
// 01/07/2013 is a lundi.
// 01/07/2013 is in juillet.
// 01/07/2013 is in juillet.
Imports System.Globalization
Imports System.Threading
Module Example13
Public Sub Main13()
' Set the current culture to French (France).
CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR")
Dim midYear As Date = #07/01/2013#
Console.WriteLine("{0:d} is a {1}.", midYear, DateUtilities.GetDayName(midYear))
Console.WriteLine("{0:d} is a {1}.", midYear, DateUtilities.GetDayName(midYear.DayOfWeek))
Console.WriteLine("{0:d} is in {1}.", midYear, DateUtilities.GetMonthName(midYear))
Console.WriteLine("{0:d} is in {1}.", midYear, DateUtilities.GetMonthName(midYear.Month))
End Sub
End Module
Public Class DateUtilities
Public Shared Function GetDayName(dayOfWeek As Integer) As String
If dayOfWeek < 0 Or dayOfWeek > DateTimeFormatInfo.CurrentInfo.DayNames.Length Then
Return String.Empty
Else
Return DateTimeFormatInfo.CurrentInfo.DayNames(dayOfWeek)
End If
End Function
Public Shared Function GetDayName(dat As Date) As String
Return dat.ToString("dddd")
End Function
Public Shared Function GetMonthName(month As Integer) As String
If month < 1 Or month > DateTimeFormatInfo.CurrentInfo.MonthNames.Length - 1 Then
Return String.Empty
Else
Return DateTimeFormatInfo.CurrentInfo.MonthNames(month - 1)
End If
End Function
Public Shared Function GetMonthName(dat As Date) As String
Return dat.ToString("MMMM")
End Function
End Class
' The example displays the following output:
' 01/07/2013 is a lundi.
' 01/07/2013 is a lundi.
' 01/07/2013 is in juillet.
' 01/07/2013 is in juillet.
Numeriska värden
Hanteringen av tal beror på om de visas i användargränssnittet eller behålls. Det här avsnittet undersöker båda användningarna.
Kommentar
I parsnings- och formateringsåtgärder identifierar .NET endast de latinska grundtecken 0 till och med 9 (U+0030 till U+0039) som numeriska siffror.
Visa numeriska värden
När tal visas i användargränssnittet bör du vanligtvis använda formateringskonventionerna för användarens kultur, som definieras av CultureInfo.CurrentCulture egenskapen och av objektet NumberFormatInfo som returneras av CultureInfo.CurrentCulture.NumberFormat egenskapen. Formateringskonventionerna i den aktuella kulturen används automatiskt när du formaterar ett datum på följande sätt:
- Använd den parameterlösa
ToStringmetoden av valfri numerisk typ. ToString(String)Använd metoden för valfri numerisk typ, som innehåller en formatsträng som argument.- Använda sammansatt formatering med numeriska värden.
I följande exempel visas den genomsnittliga temperaturen per månad i Paris, Frankrike. Den ställer först in den aktuella kulturen på franska (Frankrike) innan data visas och ställer sedan in den på engelska (USA). I varje fall visas månadsnamnen och temperaturerna i det format som är lämpligt för den kulturen. Observera att de två kulturerna använder olika decimalavgränsare i temperaturvärdet. Observera också att exemplet använder den anpassade datum- och tidsformatsträngen "MMMM" för att visa det fullständiga månadsnamnet och att det allokerar lämplig mängd utrymme för månadsnamnet i resultatsträngen genom att bestämma längden på det längsta månadsnamnet i matrisen DateTimeFormatInfo.MonthNames .
using System;
using System.Globalization;
using System.Threading;
public class Example14
{
public static void Main14()
{
DateTime dateForMonth = new DateTime(2013, 1, 1);
double[] temperatures = { 3.4, 3.5, 7.6, 10.4, 14.5, 17.2,
19.9, 18.2, 15.9, 11.3, 6.9, 5.3 };
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
// Build the format string dynamically so we allocate enough space for the month name.
string fmtString = "{0,-" + GetLongestMonthNameLength().ToString() + ":MMMM} {1,4}";
for (int ctr = 0; ctr < temperatures.Length; ctr++)
Console.WriteLine(fmtString,
dateForMonth.AddMonths(ctr),
temperatures[ctr]);
Console.WriteLine();
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
fmtString = "{0,-" + GetLongestMonthNameLength().ToString() + ":MMMM} {1,4}";
for (int ctr = 0; ctr < temperatures.Length; ctr++)
Console.WriteLine(fmtString,
dateForMonth.AddMonths(ctr),
temperatures[ctr]);
}
private static int GetLongestMonthNameLength()
{
int length = 0;
foreach (var nameOfMonth in DateTimeFormatInfo.CurrentInfo.MonthNames)
if (nameOfMonth.Length > length) length = nameOfMonth.Length;
return length;
}
}
// The example displays the following output:
// Current Culture: French (France)
// janvier 3,4
// février 3,5
// mars 7,6
// avril 10,4
// mai 14,5
// juin 17,2
// juillet 19,9
// août 18,2
// septembre 15,9
// octobre 11,3
// novembre 6,9
// décembre 5,3
//
// Current Culture: English (United States)
// January 3.4
// February 3.5
// March 7.6
// April 10.4
// May 14.5
// June 17.2
// July 19.9
// August 18.2
// September 15.9
// October 11.3
// November 6.9
// December 5.3
Imports System.Globalization
Imports System.Threading
Module Example14
Public Sub Main14()
Dim dateForMonth As Date = #1/1/2013#
Dim temperatures() As Double = {3.4, 3.5, 7.6, 10.4, 14.5, 17.2,
19.9, 18.2, 15.9, 11.3, 6.9, 5.3}
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR")
Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
Dim fmtString As String = "{0,-" + GetLongestMonthNameLength().ToString() + ":MMMM} {1,4}"
For ctr = 0 To temperatures.Length - 1
Console.WriteLine(fmtString,
dateForMonth.AddMonths(ctr),
temperatures(ctr))
Next
Console.WriteLine()
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
' Build the format string dynamically so we allocate enough space for the month name.
fmtString = "{0,-" + GetLongestMonthNameLength().ToString() + ":MMMM} {1,4}"
For ctr = 0 To temperatures.Length - 1
Console.WriteLine(fmtString,
dateForMonth.AddMonths(ctr),
temperatures(ctr))
Next
End Sub
Private Function GetLongestMonthNameLength() As Integer
Dim length As Integer
For Each nameOfMonth In DateTimeFormatInfo.CurrentInfo.MonthNames
If nameOfMonth.Length > length Then length = nameOfMonth.Length
Next
Return length
End Function
End Module
' The example displays the following output:
' Current Culture: French (France)
' janvier 3,4
' février 3,5
' mars 7,6
' avril 10,4
' mai 14,5
' juin 17,2
' juillet 19,9
' août 18,2
' septembre 15,9
' octobre 11,3
' novembre 6,9
' décembre 5,3
'
' Current Culture: English (United States)
' January 3.4
' February 3.5
' March 7.6
' April 10.4
' May 14.5
' June 17.2
' July 19.9
' August 18.2
' September 15.9
' October 11.3
' November 6.9
' December 5.3
Spara numeriska värden
Du bör aldrig spara numeriska data i ett kulturspecifikt format. Det här är ett vanligt programmeringsfel som resulterar i skadade data eller ett körningsfel. Följande exempel genererar tio slumpmässiga flyttalsnummer och serialiserar dem sedan som strängar med hjälp av formateringskonventionerna i den engelska kulturen (USA). När data hämtas och parsas med hjälp av konventionerna i den engelska kulturen (USA) återställs de. Men när det hämtas och parsas med hjälp av konventionerna i den franska kulturen (Frankrike) kan inget av talen parsas eftersom kulturerna använder olika decimalavgränsare.
using System;
using System.Globalization;
using System.IO;
using System.Threading;
public class Example15
{
public static void Main15()
{
// Create ten random doubles.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
double[] numbers = GetRandomNumbers(10);
DisplayRandomNumbers(numbers);
// Persist the numbers as strings.
StreamWriter sw = new StreamWriter("randoms.dat");
for (int ctr = 0; ctr < numbers.Length; ctr++)
sw.Write("{0:R}{1}", numbers[ctr], ctr < numbers.Length - 1 ? "|" : "");
sw.Close();
// Read the persisted data.
StreamReader sr = new StreamReader("randoms.dat");
string numericData = sr.ReadToEnd();
sr.Close();
string[] numberStrings = numericData.Split('|');
// Restore and display the data using the conventions of the en-US culture.
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName);
foreach (var numberStr in numberStrings)
{
double restoredNumber;
if (Double.TryParse(numberStr, out restoredNumber))
Console.WriteLine(restoredNumber.ToString("R"));
else
Console.WriteLine("ERROR: Unable to parse '{0}'", numberStr);
}
Console.WriteLine();
// Restore and display the data using the conventions of the fr-FR culture.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR");
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName);
foreach (var numberStr in numberStrings)
{
double restoredNumber;
if (Double.TryParse(numberStr, out restoredNumber))
Console.WriteLine(restoredNumber.ToString("R"));
else
Console.WriteLine("ERROR: Unable to parse '{0}'", numberStr);
}
}
private static double[] GetRandomNumbers(int n)
{
Random rnd = new Random();
double[] numbers = new double[n];
for (int ctr = 0; ctr < n; ctr++)
numbers[ctr] = rnd.NextDouble() * 1000;
return numbers;
}
private static void DisplayRandomNumbers(double[] numbers)
{
for (int ctr = 0; ctr < numbers.Length; ctr++)
Console.WriteLine(numbers[ctr].ToString("R"));
Console.WriteLine();
}
}
// The example displays output like the following:
// 487.0313743534644
// 674.12000879371533
// 498.72077885024288
// 42.3034229512808
// 970.57311049223563
// 531.33717716268131
// 587.82905693530529
// 562.25210175023039
// 600.7711019370571
// 299.46113717717174
//
// Current Culture: English (United States)
// 487.0313743534644
// 674.12000879371533
// 498.72077885024288
// 42.3034229512808
// 970.57311049223563
// 531.33717716268131
// 587.82905693530529
// 562.25210175023039
// 600.7711019370571
// 299.46113717717174
//
// Current Culture: French (France)
// ERROR: Unable to parse '487.0313743534644'
// ERROR: Unable to parse '674.12000879371533'
// ERROR: Unable to parse '498.72077885024288'
// ERROR: Unable to parse '42.3034229512808'
// ERROR: Unable to parse '970.57311049223563'
// ERROR: Unable to parse '531.33717716268131'
// ERROR: Unable to parse '587.82905693530529'
// ERROR: Unable to parse '562.25210175023039'
// ERROR: Unable to parse '600.7711019370571'
// ERROR: Unable to parse '299.46113717717174'
Imports System.Globalization
Imports System.IO
Imports System.Threading
Module Example15
Public Sub Main15()
' Create ten random doubles.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
Dim numbers() As Double = GetRandomNumbers(10)
DisplayRandomNumbers(numbers)
' Persist the numbers as strings.
Dim sw As New StreamWriter("randoms.dat")
For ctr As Integer = 0 To numbers.Length - 1
sw.Write("{0:R}{1}", numbers(ctr), If(ctr < numbers.Length - 1, "|", ""))
Next
sw.Close()
' Read the persisted data.
Dim sr As New StreamReader("randoms.dat")
Dim numericData As String = sr.ReadToEnd()
sr.Close()
Dim numberStrings() As String = numericData.Split("|"c)
' Restore and display the data using the conventions of the en-US culture.
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName)
For Each numberStr In numberStrings
Dim restoredNumber As Double
If Double.TryParse(numberStr, restoredNumber) Then
Console.WriteLine(restoredNumber.ToString("R"))
Else
Console.WriteLine("ERROR: Unable to parse '{0}'", numberStr)
End If
Next
Console.WriteLine()
' Restore and display the data using the conventions of the fr-FR culture.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("fr-FR")
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName)
For Each numberStr In numberStrings
Dim restoredNumber As Double
If Double.TryParse(numberStr, restoredNumber) Then
Console.WriteLine(restoredNumber.ToString("R"))
Else
Console.WriteLine("ERROR: Unable to parse '{0}'", numberStr)
End If
Next
End Sub
Private Function GetRandomNumbers(n As Integer) As Double()
Dim rnd As New Random()
Dim numbers(n - 1) As Double
For ctr As Integer = 0 To n - 1
numbers(ctr) = rnd.NextDouble * 1000
Next
Return numbers
End Function
Private Sub DisplayRandomNumbers(numbers As Double())
For ctr As Integer = 0 To numbers.Length - 1
Console.WriteLine(numbers(ctr).ToString("R"))
Next
Console.WriteLine()
End Sub
End Module
' The example displays output like the following:
' 487.0313743534644
' 674.12000879371533
' 498.72077885024288
' 42.3034229512808
' 970.57311049223563
' 531.33717716268131
' 587.82905693530529
' 562.25210175023039
' 600.7711019370571
' 299.46113717717174
'
' Current Culture: English (United States)
' 487.0313743534644
' 674.12000879371533
' 498.72077885024288
' 42.3034229512808
' 970.57311049223563
' 531.33717716268131
' 587.82905693530529
' 562.25210175023039
' 600.7711019370571
' 299.46113717717174
'
' Current Culture: French (France)
' ERROR: Unable to parse '487.0313743534644'
' ERROR: Unable to parse '674.12000879371533'
' ERROR: Unable to parse '498.72077885024288'
' ERROR: Unable to parse '42.3034229512808'
' ERROR: Unable to parse '970.57311049223563'
' ERROR: Unable to parse '531.33717716268131'
' ERROR: Unable to parse '587.82905693530529'
' ERROR: Unable to parse '562.25210175023039'
' ERROR: Unable to parse '600.7711019370571'
' ERROR: Unable to parse '299.46113717717174'
För att undvika det här problemet kan du använda någon av följande tekniker:
- Spara och parsa strängrepresentationen av talet med hjälp av en anpassad formatsträng som är densamma oavsett användarens kultur.
- Spara talet som en sträng med hjälp av formateringskonventionerna i den invarianta kulturen, som returneras av CultureInfo.InvariantCulture egenskapen.
Serialisering av valutavärden är ett specialfall. Eftersom ett valutavärde är beroende av den valutaenhet som det uttrycks i är det föga meningsfullt att behandla det som ett oberoende numeriskt värde. Men om du sparar ett valutavärde som en formaterad sträng som innehåller en valutasymbol kan det inte deserialiseras i ett system vars standardkultur använder en annan valutasymbol, som i följande exempel visas.
using System;
using System.Globalization;
using System.IO;
using System.Threading;
public class Example1
{
public static void Main1()
{
// Display the currency value.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
Decimal value = 16039.47m;
Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
Console.WriteLine("Currency Value: {0:C2}", value);
// Persist the currency value as a string.
StreamWriter sw = new StreamWriter("currency.dat");
sw.Write(value.ToString("C2"));
sw.Close();
// Read the persisted data using the current culture.
StreamReader sr = new StreamReader("currency.dat");
string currencyData = sr.ReadToEnd();
sr.Close();
// Restore and display the data using the conventions of the current culture.
Decimal restoredValue;
if (Decimal.TryParse(currencyData, out restoredValue))
Console.WriteLine(restoredValue.ToString("C2"));
else
Console.WriteLine("ERROR: Unable to parse '{0}'", currencyData);
Console.WriteLine();
// Restore and display the data using the conventions of the en-GB culture.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName);
if (Decimal.TryParse(currencyData, NumberStyles.Currency, null, out restoredValue))
Console.WriteLine(restoredValue.ToString("C2"));
else
Console.WriteLine("ERROR: Unable to parse '{0}'", currencyData);
Console.WriteLine();
}
}
// The example displays output like the following:
// Current Culture: English (United States)
// Currency Value: $16,039.47
// ERROR: Unable to parse '$16,039.47'
//
// Current Culture: English (United Kingdom)
// ERROR: Unable to parse '$16,039.47'
Imports System.Globalization
Imports System.IO
Imports System.Threading
Module Example1
Public Sub Main1()
' Display the currency value.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
Dim value As Decimal = 16039.47D
Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
Console.WriteLine("Currency Value: {0:C2}", value)
' Persist the currency value as a string.
Dim sw As New StreamWriter("currency.dat")
sw.Write(value.ToString("C2"))
sw.Close()
' Read the persisted data using the current culture.
Dim sr As New StreamReader("currency.dat")
Dim currencyData As String = sr.ReadToEnd()
sr.Close()
' Restore and display the data using the conventions of the current culture.
Dim restoredValue As Decimal
If Decimal.TryParse(currencyData, restoredValue) Then
Console.WriteLine(restoredValue.ToString("C2"))
Else
Console.WriteLine("ERROR: Unable to parse '{0}'", currencyData)
End If
Console.WriteLine()
' Restore and display the data using the conventions of the en-GB culture.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
Console.WriteLine("Current Culture: {0}",
Thread.CurrentThread.CurrentCulture.DisplayName)
If Decimal.TryParse(currencyData, NumberStyles.Currency, Nothing, restoredValue) Then
Console.WriteLine(restoredValue.ToString("C2"))
Else
Console.WriteLine("ERROR: Unable to parse '{0}'", currencyData)
End If
Console.WriteLine()
End Sub
End Module
' The example displays output like the following:
' Current Culture: English (United States)
' Currency Value: $16,039.47
' ERROR: Unable to parse '$16,039.47'
'
' Current Culture: English (United Kingdom)
' ERROR: Unable to parse '$16,039.47'
I stället bör du serialisera det numeriska värdet tillsammans med viss kulturell information, till exempel namnet på kulturen, så att värdet och dess valutasymbol kan deserialiseras oberoende av den aktuella kulturen. Följande exempel gör det genom att definiera en CurrencyValue struktur med två medlemmar: Decimal värdet och namnet på den kultur som värdet tillhör.
using System;
using System.Globalization;
using System.Text.Json;
using System.Threading;
public class Example2
{
public static void Main2()
{
// Display the currency value.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
Decimal value = 16039.47m;
Console.WriteLine($"Current Culture: {CultureInfo.CurrentCulture.DisplayName}");
Console.WriteLine($"Currency Value: {value:C2}");
// Serialize the currency data.
CurrencyValue data = new()
{
Amount = value,
CultureName = CultureInfo.CurrentCulture.Name
};
string serialized = JsonSerializer.Serialize(data);
Console.WriteLine();
// Change the current culture.
CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
Console.WriteLine($"Current Culture: {CultureInfo.CurrentCulture.DisplayName}");
// Deserialize the data.
CurrencyValue restoredData = JsonSerializer.Deserialize<CurrencyValue>(serialized);
// Display the round-tripped value.
CultureInfo culture = CultureInfo.CreateSpecificCulture(restoredData.CultureName);
Console.WriteLine($"Currency Value: {restoredData.Amount.ToString("C2", culture)}");
}
}
internal struct CurrencyValue
{
public decimal Amount { get; set; }
public string CultureName { get; set; }
}
// The example displays the following output:
// Current Culture: English (United States)
// Currency Value: $16,039.47
//
// Current Culture: English (United Kingdom)
// Currency Value: $16,039.47
Imports System.Globalization
Imports System.Text.Json
Imports System.Threading
Friend Structure CurrencyValue
Public Property Amount As Decimal
Public Property CultureName As String
End Structure
Module Example2
Public Sub Main2()
' Display the currency value.
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
Dim value As Decimal = 16039.47D
Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
Console.WriteLine("Currency Value: {0:C2}", value)
' Serialize the currency data.
Dim data As New CurrencyValue With {
.Amount = value,
.CultureName = CultureInfo.CurrentCulture.Name
}
Dim serialized As String = JsonSerializer.Serialize(data)
Console.WriteLine()
' Change the current culture.
CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
' Deserialize the data.
Dim restoredData As CurrencyValue = JsonSerializer.Deserialize(Of CurrencyValue)(serialized)
' Display the round-tripped value.
Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(restoredData.CultureName)
Console.WriteLine("Currency Value: {0}", restoredData.Amount.ToString("C2", culture))
End Sub
End Module
' The example displays the following output:
' Current Culture: English (United States)
' Currency Value: $16,039.47
'
' Current Culture: English (United Kingdom)
' Currency Value: $16,039.47
Arbeta med kulturspecifika inställningar
I .NET CultureInfo representerar klassen en viss kultur eller region. Några av dess egenskaper returnerar objekt som ger specifik information om någon aspekt av en kultur:
Egenskapen CultureInfo.CompareInfo returnerar ett CompareInfo objekt som innehåller information om hur kulturen jämför och beställer strängar.
Egenskapen CultureInfo.DateTimeFormat returnerar ett DateTimeFormatInfo objekt som tillhandahåller kulturspecifik information som används för att formatera datum- och tidsdata.
Egenskapen CultureInfo.NumberFormat returnerar ett NumberFormatInfo objekt som tillhandahåller kulturspecifik information som används för att formatera numeriska data.
Egenskapen CultureInfo.TextInfo returnerar ett TextInfo objekt som innehåller information om kulturens skrivsystem.
I allmänhet ska du inte göra några antaganden om värdena för specifika CultureInfo egenskaper och deras relaterade objekt. I stället bör du visa kulturspecifika data som kan komma att ändras av följande skäl:
Enskilda egenskapsvärden kan komma att ändras och revideras över tid, eftersom data korrigeras, bättre data blir tillgängliga eller kulturspecifika konventioner ändras.
Enskilda egenskapsvärden kan variera mellan versioner av .NET eller operativsystemversioner.
.NET stöder ersättningskulturer. Detta gör det möjligt att definiera en ny anpassad kultur som antingen kompletterar befintliga standardkulturer eller helt ersätter en befintlig standardkultur.
I Windows-system kan användaren anpassa kulturspecifika inställningar med hjälp av appen Region och Språk i Kontrollpanelen. När du instansierar ett CultureInfo objekt kan du avgöra om det återspeglar dessa användaranpassningar genom att anropa CultureInfo(String, Boolean) konstruktorn. För slutanvändarappar bör du vanligtvis respektera användarinställningar så att användaren får data i ett format som de förväntar sig.
Se även
Feedback
Kommer snart: Under hela 2024 kommer vi att fasa ut GitHub-problem som feedbackmekanism för innehåll och ersätta det med ett nytt feedbacksystem. Mer information finns i: https://aka.ms/ContentUserFeedback.
Skicka och visa feedback för