Globalización
La globalización implica diseñar y desarrollar una aplicación de uso internacional que admita interfaces localizadas y datos regionales para usuarios de varias referencias culturales. Antes de comenzar la fase de diseño, debe determinar qué referencias culturales admitirá la aplicación. Aunque una aplicación se dirige a una sola referencia cultural o región de forma predeterminada, puede diseñarla y escribirla de tal forma que se pueda ampliar fácilmente a los usuarios de otras referencias culturales o regiones.
Como desarrolladores, todos tenemos suposiciones sobre interfaces de usuario y datos que están formados por nuestras referencias culturales. Por ejemplo, para un desarrollador angloparlante de Estados Unidos, serializar datos de fecha y hora como una cadena en el formato MM/dd/yyyy hh:mm:ss parece perfectamente razonable. En cambio, si se deserializa esa cadena en un sistema de una referencia cultural diferente, es probable que se inicie una excepción FormatException o que se produzcan datos inexactos. La globalización nos permite identificar esas suposiciones específicas de la referencia cultural y asegurarnos de que no afecten al diseño ni al código de nuestra aplicación.
En este artículo se describen algunos de los problemas más importantes que debe tener en cuenta y los procedimientos recomendados que puede seguir al manipular cadenas, valores de fecha y hora, y valores numéricos en una aplicación globalizada.
Cadenas
El control de cadenas y caracteres es un eje central de la globalización, porque cada referencia cultural o región puede usar caracteres y juegos de caracteres diferentes y ordenarlos de forma diferente. En esta sección se proporcionan recomendaciones para el uso de cadenas en aplicaciones globalizadas.
Uso interno de Unicode
De forma predeterminada, .NET usa cadenas Unicode. Una cadena Unicode está compuesta por cero, uno o más objetos Char, cada uno de los cuales representa una unidad de código UTF-16. Hay una representación Unicode para casi todos los caracteres en cada juego de caracteres en uso en todo el mundo.
Muchas aplicaciones y sistemas operativos, como el sistema operativo Windows, pueden usar también páginas de códigos para representar juegos de caracteres. Las páginas de códigos contienen normalmente los valores ASCII estándar de 0x00 a 0x7F y asignan otros caracteres a los valores restantes de 0x80 a 0xFF. La interpretación de valores de 0x80 a 0xFF depende de la página de códigos específica. Por este motivo, debe evitar usar páginas de códigos en una aplicación globalizada si es posible.
En el siguiente ejemplo, se muestran los peligros de interpretar los datos de la página de códigos cuando la página de códigos predeterminada de un sistema es diferente de la página de códigos en la que se han guardado los datos. (Para simular este escenario, en el ejemplo se especifican de forma explícita páginas de códigos diferentes). En primer lugar, en el ejemplo se define una matriz que consta de los caracteres en mayúsculas del alfabeto griego. Los codifica en una matriz de bytes mediante la página de códigos 737 (también conocida como MS-DOS griego) y guarda la matriz de bytes en un archivo. Si se recupera el archivo y su matriz de bytes se descodifica mediante la página de códigos 737, se restauran los caracteres originales. En cambio, si se recupera el archivo y su matriz de bytes se descodifica mediante la página de códigos 1252 (o Windows-1252, que representa los caracteres del alfabeto latino), se pierden los caracteres originales.
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:
' ΑΒΓΔΕΖΗΘΙΚΛΜΝΞΟΠΡΣΤΥΦΧΨΩ
' €‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’""•–—
El uso de Unicode garantiza que se asignen siempre las mismas unidades de código a los mismos caracteres y que se asignen siempre los mismos caracteres a las mismas matrices de bytes.
Uso de archivos de recursos
Incluso si está desarrollando una aplicación destinada a una sola referencia cultural o región, debe usar los archivos de recursos para almacenar cadenas y otros recursos que se muestran en la interfaz de usuario. Nunca debe agregarlos directamente al código. Usar archivos de recursos tiene una serie de ventajas:
- Todas las cadenas están en una sola ubicación. No tiene que buscar en todo el código fuente para identificar cadenas que tiene que modificar para un idioma o referencia cultural determinados.
- No es necesario duplicar las cadenas. Los desarrolladores que no usan archivos de recursos, definen frecuentemente la misma cadena en varios archivos de código fuente. Esta duplicación aumenta la probabilidad de que se pasen por alto una o más instancias al modificar una cadena.
- Puede incluir recursos que no sean de cadena, como imágenes o datos binarios, en el archivo de recursos en lugar de almacenarlos en un archivo independiente, para que se puedan recuperar fácilmente.
Usar archivos de recursos tiene algunas ventajas si está creando una aplicación localizada. Al implementar recursos en ensamblados satélite, Common Language Runtime selecciona automáticamente un recurso adecuado según la referencia cultural de la interfaz de usuario actual del usuario tal y como se define en la propiedad CultureInfo.CurrentUICulture. Siempre que proporcione un recurso específico de la referencia cultural adecuado y cree correctamente una instancia de un objeto ResourceManager o use una clase de recurso fuertemente tipada, runtime controla los detalles de recuperación de los recursos adecuados.
Para obtener más información sobre la creación de archivos de recursos, consulte Creación de archivos de recursos. Para obtener información sobre la creación y la implementación de ensamblados satélite, consulte Creación de ensamblados satélite y Empaquetar e implementar recursos.
Búsqueda y comparación de cadenas
Cuando sea posible, debe tratar las cadenas como cadenas enteras en lugar de tratarlas como una serie de caracteres individuales. Esto es especialmente importante al ordenar o buscar subcadenas, para evitar problemas asociados con el análisis de caracteres combinados.
Sugerencia
Puede usar la clase StringInfo para trabajar con los elementos de texto en lugar de los caracteres individuales de una cadena.
En búsquedas y comparaciones de cadenas, un error común es tratar la cadena como una colección de caracteres, cada uno de ellos se representa mediante un objeto Char. De hecho, un solo carácter puede estar formado por uno, dos o más objetos Char. Estos caracteres se encuentran con más frecuencia en cadenas de referencias culturales cuyos alfabetos constan de caracteres fuera del intervalo de caracteres de latín básico de Unicode (U+0021 a U+007E). En el ejemplo siguiente se intenta encontrar el índice del carácter LETRA LATINA A MAYÚSCULA CON ACENTO GRAVE (U+00C0) en una cadena. Pero este carácter se puede representar de dos formas diferentes: como una única unidad de código (U+00C0), o bien como un carácter compuesto (dos unidades de código: U+0041 y U+0300). En este caso, el carácter se representa en la instancia de cadena mediante dos objetos Char, U+0041 y U+0300. El código de ejemplo llama a las sobrecargas String.IndexOf(Char) y String.IndexOf(String) para buscar la posición de este carácter en la instancia de cadena, pero estas devuelven resultados diferentes. La primera llamada al método tiene un argumento Char; realiza una comparación ordinal y, por tanto, no se puede encontrar una coincidencia. La segunda llamada tiene un argumento String; realiza una comparación que tiene en cuenta la referencia cultural y, por tanto, se encuentra una coincidencia.
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
Puede evitar la ambigüedad de este ejemplo (llamadas a dos sobrecargas similares de un método que devuelve resultados diferentes) mediante una llamada a una sobrecarga que incluya un parámetro StringComparison, como el método String.IndexOf(String, StringComparison) o String.LastIndexOf(String, StringComparison).
En cambio, las búsquedas no se realizan siempre según la referencia cultural. Si el propósito de la búsqueda es tomar una decisión de seguridad o permitir o denegar el acceso a algún recurso, la comparación debe ser ordinal, como se describe en la sección siguiente.
Prueba de la igualdad de cadenas
Si quiere probar la igualdad de dos cadenas en lugar de determinar cómo se comparan en el criterio de ordenación, use el método String.Equals en lugar de un método de comparación de cadenas como String.Compare o CompareInfo.Compare.
Normalmente, se realizan las comparaciones de igualdad para acceder a algunos recursos de forma condicional. Por ejemplo, podría realizar una comparación de igualdad para comprobar una contraseña o para confirmar que existe un archivo. Estas comparaciones no lingüísticas siempre deben ser ordinales en lugar de según la referencia cultural. En general, debería llamar al método String.Equals(String, StringComparison) de la instancia o al método String.Equals(String, String, StringComparison) estático con un valor de StringComparison.Ordinal para cadenas como contraseñas y un valor de StringComparison.OrdinalIgnoreCase para cadenas como nombres de archivo o URI.
A veces, las comparaciones de igualdad implican búsquedas o comparaciones de subcadenas en lugar de llamadas al método String.Equals. En algunos casos, puede usar una búsqueda de subcadena para determinar si esa subcadena es igual a otra cadena. Si el propósito de esta comparación es no lingüístico, la búsqueda también debe ser ordinal en lugar de según la referencia cultural.
En el ejemplo siguiente, se muestra el peligro de una búsqueda según la referencia cultural en datos no lingüísticos. El método AccessesFileSystem está diseñado para prohibir el acceso al sistema de archivos a los URI que comienzan con la subcadena "FILE". Para ello, realiza una comparación según la referencia cultural que no diferencia mayúsculas de minúsculas del principio del URI con la cadena "FILE". Ya que un URI que accede al sistema de archivos puede comenzar con "FILE:" o "file:", la suposición implícita es que esa "i" (U+0069) es siempre el equivalente en minúsculas de "I" (U+0049). Sin embargo, en turco y azerbaiyano, la versión en mayúsculas de "i" es "İ" (0130). Debido a esta discrepancia, la comparación según la referencia cultural permite el acceso al sistema de archivos cuando debería estar prohibido.
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.
Para evitar este problema, realice una comparación ordinal que no distinga mayúsculas de minúsculas, como se muestra en el ejemplo siguiente.
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.
Ordenación de cadenas
Normalmente, las cadenas ordenadas que se muestran en la interfaz de usuario se deben ordenar en función de la referencia cultural. En su mayor parte, estas comparaciones de cadenas se tratan implícitamente mediante .NET al llamar a un método que ordena cadenas, como Array.Sort o List<T>.Sort. De manera predeterminada, las cadenas se ordenan mediante las convenciones de ordenación de la referencia cultural actual. En el ejemplo siguiente, se ilustra la diferencia cuando una matriz de cadenas se ordena mediante las convenciones de la referencia cultural del inglés (Estados Unidos) y la referencia cultural del sueco (Suecia).
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
La comparación de cadenas según la referencia cultural se define mediante el objeto CompareInfo, que devuelve la propiedad CultureInfo.CompareInfo de cada referencia cultural. Las comparaciones de cadenas según la referencia cultural que usan las sobrecargas del método String.Compare usan también el objeto CompareInfo.
.NET usa tablas para realizar ordenaciones según la referencia cultural de los datos de las cadenas. El contenido de estas tablas, que contienen datos en prioridades de ordenación y normalización de cadenas, viene determinado por la versión del estándar Unicode que se implementa mediante una versión concreta de .NET. En la tabla siguiente se enumeran las versiones de Unicode implementadas por las versiones de .NET especificadas. Esta lista de versiones de Unicode compatibles solo se aplica a la comparación y ordenación de caracteres; no se aplica a la clasificación de caracteres Unicode por categoría. Para obtener más información, consulte la sección "Las cadenas y el estándar Unicode" en el artículo String.
| Versión de .NET Framework | Sistema operativo | Versión de Unicode |
|---|---|---|
| .NET Framework 2.0 | Todos los sistemas operativos | Unicode 4.1 |
| .NET Framework 3.0 | Todos los sistemas operativos | Unicode 4.1 |
| .NET Framework 3,5 | Todos los sistemas operativos | Unicode 4.1 |
| .NET Framework 4 | Todos los sistemas operativos | Unicode 5.0 |
| .NET Framework 4.5 y posterior | Windows 7 | Unicode 5.0 |
| .NET Framework 4.5 y posterior | Windows 8 y los sistemas operativos posteriores | Unicode 6.3.0 |
| .NET Core, y .NET 5 y versiones posteriores | Depende de la versión del estándar Unicode compatible con el sistema operativo subyacente. |
A partir de .NET Framework 4.5 y en todas las versiones de .NET Core, .NET 5 y versiones posteriores, la ordenación y la comparación de cadenas dependen del sistema operativo. .NET Framework 4.5 y las versiones posteriores que se ejecutan en Windows 7 recuperan los datos de sus propias tablas que implementan Unicode 5.0. .NET Framework 4.5 y las versiones posteriores que se ejecutan en Windows 8 y versiones posteriores recuperan los datos de tablas del sistema operativo que implementan Unicode 6.3. En .NET Core, y .NET 5 y versiones posteriores, la versión admitida de Unicode depende del sistema operativo subyacente. Si serializa datos ordenados según la referencia cultural, puede usar la clase SortVersion para determinar cuándo se deben ordenar los datos serializados de forma que sea coherente con el criterio de ordenación del sistema operativo y de .NET. Para obtener un ejemplo, consulte el tema de la clase SortVersion.
Si la aplicación realiza ordenaciones extensas específicas de la referencia cultural de los datos de cadena, puede trabajar con la clase SortKey para comparar cadenas. Un criterio de ordenación refleja las prioridades de ordenación específicas de la referencia cultural, incluidas las prioridades alfabéticas, de mayúsculas y minúsculas, y diacríticas de una cadena determinada. Dado que las comparaciones que usan criterios de ordenación son binarias, son más rápidas que las comparaciones que usan un objeto CompareInfo de forma implícita o explícita. Para crear un criterio de ordenación específico de la referencia cultural para una cadena determinada, pase la cadena al método CompareInfo.GetSortKey.
El siguiente ejemplo es similar al ejemplo anterior. En cambio, en lugar de llamar al método Array.Sort(Array), que llama de forma implícita al método CompareInfo.Compare, define una implementación System.Collections.Generic.IComparer<T> que compara los criterios de ordenación, que crea en una instancia y pasa al método Array.Sort<T>(T[], IComparer<T>).
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
Evitación de la concatenación de cadenas
En lo posible, evite usar cadenas compuestas que se compilan en tiempo de ejecución a partir de frases concatenadas. La localización de las cadenas compuestas resulta difícil porque, a menudo, se da por supuesto un orden gramatical en el idioma original de la aplicación que no se aplica a otros idiomas localizados.
Control de las fechas y horas
El control de los valores de fecha y hora depende de si se muestran en la interfaz de usuario o si se conservan. En esta sección se examinan ambos usos. También se explica cómo puede controlar las diferencias de zona horaria y las operaciones aritméticas al trabajar con fechas y horas.
Visualización de las fechas y horas
Normalmente, cuando las fechas y horas se muestran en la interfaz de usuario, debe usar las convenciones de formato de la referencia cultural del usuario, que definen la propiedad CultureInfo.CurrentCulture y el objeto DateTimeFormatInfo que devuelve la propiedad CultureInfo.CurrentCulture.DateTimeFormat. Las convenciones de formato de la referencia cultural actual se usan de forma automática al dar formato a una fecha mediante cualquiera de estos métodos:
El método DateTime.ToString() sin parámetros
El método DateTime.ToString(String), que incluye una cadena de formato
El método DateTimeOffset.ToString() sin parámetros
DateTimeOffset.ToString(String), que incluye una cadena de formato
La característica formatos compuestos, cuando se usa con fechas
En el ejemplo siguiente, se muestran datos de amanecer y puesta de sol duplicados para el 11 de octubre de 2012. Primero, establece la referencia cultural actual a croata (Croacia) y, después, a inglés (Reino Unido). En cada caso, las fechas y horas se muestran en el formato adecuado para esa referencia cultural.
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
Conservación de las fechas y horas
Nunca debe conservar datos de fecha y hora en un formato que puede variar según la referencia cultural. Se trata de un error de programación común que produce datos dañados o una excepción en tiempo de ejecución. En el ejemplo siguiente se serializan dos fechas, 9 de enero de 2013 y 18 de agosto de 2013, como cadenas mediante las convenciones de formato de la referencia cultural del inglés (Estados Unidos). Cuando los datos se recuperan y analizan mediante las convenciones de la referencia cultural del inglés (Estados Unidos), se restauran correctamente. En cambio, cuando se recuperan y analizan mediante las convenciones de la referencia cultural del inglés (Reino Unido), la primera fecha se interpreta de forma errónea como el 1 de septiembre y la segunda no se puede analizar porque el calendario gregoriano no tiene un decimoctavo mes.
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
Puede evitar este problema de cualquiera de estas tres maneras:
- Serializar la fecha y hora en formato binario en lugar de como una cadena.
- Guardar y analizar la representación de la cadena de fecha y hora mediante una cadena de formato personalizado que sea el mismo independientemente de la referencia cultural del usuario.
- Guardar la cadena mediante las convenciones de formato de la referencia cultural invariable.
En el ejemplo siguiente se muestra el último enfoque. Usa las convenciones de formato de la referencia cultural invariable que devuelve la propiedad CultureInfo.InvariantCulture estática.
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
Reconocimiento de la serialización y la zona horaria
Un valor de fecha y hora puede tener varias interpretaciones, desde una hora general ("Las tiendas abren el 2 de enero de 2013 a las 9:00") hasta un momento específico en el tiempo ("Fecha de nacimiento: 2 de enero de 2013 a las 6:32:00"). Cuando un valor de tiempo representa un momento específico en el tiempo y lo restaura desde un valor serializado, debe asegurarse de que representa el mismo momento en el tiempo, independientemente de la ubicación geográfica o la zona horaria del usuario.
El siguiente ejemplo ilustra este problema. Guarda un único valor de fecha y hora local como cadena en tres formatos estándar:
- "G" para fecha general y hora larga.
- "s" para fecha y hora ordenables.
- "o" para fecha y hora de ida y vuelta.
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
Cuando se restauran los datos en un sistema en la misma zona horaria que el sistema en el que se han serializado, los valores de fecha y hora deserializados reflejan exactamente el valor original, como muestra el resultado:
'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
En cambio, si restaura los datos en un sistema en una zona horaria diferente, solo el valor de fecha y hora con el formato de la cadena de formato estándar "o" (ida y vuelta) conserva la información de zona horaria y, por tanto, representa la misma instantánea en el tiempo. Este es el resultado cuando se restauran datos de fecha y hora en un sistema en la zona horaria estándar romance:
'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
Para reflejar con exactitud el valor de fecha y hora que representa un único momento de tiempo, independientemente de la zona horaria del sistema en el que se deserializan los datos, puede realizar cualquiera de las siguientes acciones:
- Guarde el valor como una cadena mediante la cadena de formato estándar "o" (ida y vuelta). Después, deserialícelo en el sistema de destino.
- Conviértalo en UTC y guárdelo como una cadena mediante la cadena de formato estándar "r" (RFC1123). Luego, deserialícelo en el sistema de destino y conviértalo a la hora local.
- Conviértalo en UTC y guárdelo como una cadena mediante la cadena de formato estándar "u" (universal que se puede ordenar). Luego, deserialícelo en el sistema de destino y conviértalo a la hora local.
En el siguiente ejemplo se ilustra cada técnica.
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
Cuando los datos se serializan en un sistema en la zona horaria estándar del Pacífico y se deserializan en un sistema en la zona horaria estándar romance, el ejemplo muestra el siguiente resultado:
'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
Para obtener más información, consulte Convertir horas entre zonas horarias.
Realización de operaciones aritméticas con fechas y horas
Los tipos DateTime y DateTimeOffset admiten operaciones aritméticas. Puede calcular la diferencia entre dos valores de fecha, o puede agregar o restar intervalos de tiempo determinados a o de un valor de fecha. En cambio, las operaciones aritméticas en valores de fecha y hora no tienen en cuenta las zonas horarias ni las reglas de ajuste de zona horaria. Por este motivo, la fecha y hora aritméticas en valores que representan momentos en el tiempo pueden devolver resultados inexactos.
Por ejemplo, la transición de la hora estándar del Pacífico a la hora de verano del Pacífico tiene lugar el segundo domingo de marzo, que, en el año 2013, es el 10 de marzo. Como muestra el siguiente ejemplo, si calcula la fecha y hora de 48 horas después del 9 de marzo de 2013 a las 10:30 a. m. en un sistema en la zona horaria estándar del Pacífico, el resultado, 11 de marzo de 2013 a las 10:30 a. m., no tiene en cuenta el ajuste de la hora.
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
Para asegurarse de que una operación aritmética en valores de fecha y hora produce resultados precisos, siga estos pasos:
- Convierta la hora en la zona horaria de origen a UTC.
- Realice la operación aritmética.
- Si el resultado es un valor de fecha y hora, conviértalo de la hora UTC a la hora de la zona horaria de origen.
El ejemplo siguiente es similar al anterior, salvo que sigue estos tres pasos para agregar de forma correcta 48 horas al 9 de marzo de 2013 a las 10:30 a. m.
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
Para obtener más información, consulte Efectuar operaciones aritméticas con fechas y horas.
Uso de nombres que tienen en cuenta las referencias culturales para elementos de fecha
Puede que su aplicación tenga que mostrar el nombre del mes o el día de la semana. Para ello, es común código como el siguiente.
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.
En cambio, este código devuelve siempre los nombres de los días de la semana en inglés. El código que extrae el nombre del mes es, a menudo, aún más inflexible. Con frecuencia, asume un calendario de doce meses con nombres de meses en un idioma específico.
Mediante el uso de cadenas de formato de fecha y hora personalizadas o las propiedades del objeto DateTimeFormatInfo, es fácil extraer cadenas que muestran los nombres de días de la semana o meses en la referencia cultural del usuario, como se muestra en el ejemplo siguiente. Cambia la referencia cultural actual al francés (Francia) y muestra el nombre del día de la semana y el nombre del mes del 1 de julio de 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.
Valores numéricos
El control de los números depende de si se muestran en la interfaz de usuario o si se conservan. En esta sección se examinan ambos usos.
Nota:
En operaciones de formato y análisis, .NET reconoce solo los caracteres latinos básicos de 0 a 9 (U+0030 a U+0039) como dígitos numéricos.
Visualización de los valores numéricos
Normalmente, cuando los números se muestran en la interfaz de usuario, debe usar las convenciones de formato de la referencia cultural del usuario, que definen la propiedad CultureInfo.CurrentCulture y el objeto NumberFormatInfo que devuelve la propiedad CultureInfo.CurrentCulture.NumberFormat. Las convenciones de formato de la referencia cultural actual se usan de forma automática al dar formato a una fecha de las siguientes formas:
- Con el uso del método
ToStringsin parámetros de cualquier tipo numérico. - Con el uso del método
ToString(String)de cualquier tipo numérico, que incluye una cadena de formato como argumento. - Con el uso de formato compuesto con valores numéricos.
En el ejemplo siguiente se muestra el promedio de temperatura por mes en París, Francia. Primero, establece la referencia cultural actual al francés (Francia) antes de mostrar los datos y, después, la establece en inglés (Estados Unidos). En cada caso, los nombres de meses y las temperaturas se muestran en el formato adecuado para esa referencia cultural. Tenga en cuenta que las dos referencias culturales usan separadores decimales diferentes en el valor de temperatura. Tenga en cuenta también que en el ejemplo se usa la cadena de formato de fecha y hora "MMMM" personalizada para mostrar el nombre completo del mes y que asigna la cantidad de espacio adecuada para el nombre del mes en la cadena de resultado al determinar la longitud del nombre del mes más largo en la matriz 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
Conservación de los valores numéricos
Nunca debe conservar datos numéricos en un formato específico de la referencia cultural. Se trata de un error de programación común que produce datos dañados o una excepción en tiempo de ejecución. En el ejemplo siguiente, se generan diez números de punto flotante aleatorios y, después, se serializan como cadenas mediante las convenciones de formato de la referencia cultural de inglés (Estados Unidos). Cuando los datos se recuperan y analizan mediante las convenciones de la referencia cultural del inglés (Estados Unidos), se restauran correctamente. En cambio, cuando se recuperan y analizan mediante las convenciones de la referencia cultural de francés (Francia), no se puede analizar ninguno de los números porque las referencias culturales usan separadores decimales diferentes.
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'
Para evitar este problema, puede usar una de estas técnicas:
- Guardar y analizar la representación de la cadena del número mediante una cadena de formato personalizado que sea el mismo independientemente de la referencia cultural del usuario.
- Guardar el número como una cadena mediante las convenciones de formato de la referencia cultural, que devuelve la propiedad CultureInfo.InvariantCulture.
La serialización de valores de moneda es un caso especial. Dado que un valor de moneda depende de la unidad de moneda en la que se expresa, no tiene sentido tratarlo como un valor numérico independiente. En cambio, si guarda un valor de moneda como una cadena con formato que incluye un símbolo de moneda, no se puede deserializar en un sistema cuya referencia cultural predeterminada use otro símbolo de moneda, como se muestra en el ejemplo siguiente.
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'
En su lugar, debe serializar el valor numérico junto con alguna información de referencia cultural, como el nombre de la referencia cultural, para que se puedan deserializar el valor y el símbolo de moneda independientemente de la referencia cultural actual. En el ejemplo siguiente, se hace mediante la definición de una estructura CurrencyValue con dos miembros: el valor Decimal y el nombre de la referencia cultural a la que pertenece el valor.
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
Trabajo con configuraciones específicas de la referencia cultural
En .NET, la clase CultureInfo representa una referencia cultural o región determinada. Algunas de sus propiedades devuelven objetos que proporcionan información específica sobre algún aspecto de una referencia cultural:
La propiedad CultureInfo.CompareInfo devuelve un objeto CompareInfo que contiene información sobre cómo compara y ordena las cadenas la referencia cultural.
La propiedad CultureInfo.DateTimeFormat devuelve un objeto DateTimeFormatInfo que proporciona información específica de la referencia cultural usada en el formato de fecha y hora.
La propiedad CultureInfo.NumberFormat devuelve un objeto NumberFormatInfo que proporciona información específica de la referencia cultural usada en el formato de datos numéricos.
La propiedad CultureInfo.TextInfo devuelve un objeto TextInfo que proporciona información sobre el sistema de escritura de la referencia cultural.
En general, no realice ninguna suposición sobre los valores de propiedades CultureInfo específicas y sus objetos relacionados. En su lugar, debería ver datos específicos de la referencia cultural como sujetos a cambios, por estos motivos:
Los valores de propiedad individual están sujetos a cambios y revisión con el tiempo, ya que los datos se corrigen, hay mejores datos disponibles, o se cambian las convenciones específicas de la referencia cultural.
Los valores de propiedad individual pueden variar entre las versiones de .NET o del sistema operativo.
.NET es compatible con referencias culturales de reemplazo. Esto permite definir una nueva referencia cultural personalizada que complementa las referencias culturales estándares existentes o reemplaza por completo una referencia cultural estándar existente.
En sistemas Windows, el usuario puede personalizar la configuración específica de la referencia cultural mediante la aplicación Región e idioma del Panel de control. Al crear una instancia de un objeto CultureInfo, puede determinar si muestra estas personalizaciones de usuario mediante una llamada al constructor CultureInfo(String, Boolean). Normalmente, en las aplicaciones de usuario final hay que respetar las preferencias del usuario para que este pueda ver los datos en un formato que espera.
