c# - parse - Convertir un año de dos dígitos en un año de cuatro dígitos

parse string to date c#

Question

Esta es una cuestión de mejores prácticas. Tengo una utilidad que toma un año de dos dígitos como una cadena y necesito convertirla en un año de cuatro dígitos como una cadena. ahora mismo lo hago

//DOB''s format is "MMM (D)D YY" that first digit of the day is not there for numbers 1-9
string tmpYear = rowIn.DOB.Substring(rowIn.DOB.Length - 3, 2); //-3 because it is 0 indexed
if (Convert.ToInt16(tmpYear) > 50)
tmpYear = String.Format("19{0}", tmpYear);
else
tmpYear = String.Format("20{0}", tmpYear);

Estoy seguro de que lo estoy haciendo horriblemente mal, ¿alguna sugerencia?

Answer 1

Creo que Java tiene una buena implementación de esto:

http://java.sun.com/javase/6/docs/api/java/text/SimpleDateFormat.html#year

Las personas rara vez especifican años muy lejanos en el futuro utilizando un código de dos dígitos. La implementación de Java maneja esto asumiendo un rango de 80 años atrás y 20 años antes del año en curso. Así que ahora, 30 sería 2030, mientras que 31 sería 1931. Además, esta implementación es flexible, modificando sus rangos a medida que pasa el tiempo, para que no tenga que cambiar el código cada década aproximadamente.

Acabo de realizar la prueba, y Excel también usa estas mismas reglas para la conversión anual de 2 dígitos. 1/1/29 se convierte en 1/1/2029. 1/1/30 se convierte en 1/1/1930.

Answer 2

Dado que hay personas vivas ahora nacidas antes de 1950, pero ninguna nacida después de 2010, su uso de 50 como punto de inflexión parece roto.

Para la fecha de nacimiento, ¿no puede establecer el punto de cambio al "año de ahora" (es decir, 10) en su aplicación? Incluso entonces tendrás problemas con los nacidos antes de 1911 ...

No hay una manera perfecta de hacer esto: estás creando información de la nada.

He asumido DOB ​​= fecha de nacimiento. Para otros datos (por ejemplo, vencimiento de un instrumento financiero), la elección puede ser diferente, pero igual de imperfecta.

Answer 3

El .NET Framework tiene un método que hace exactamente lo que quieres:

int fourDigitYear = CultureInfo.CurrentCulture.Calendar.ToFourDigitYear(twoDigitYear)

De esa manera, se adherirá correctamente a la configuración regional actual como se define en el Panel de control (o política de grupo):

Answer 4

Esta solución que utilizamos para las fechas de vencimiento, el usuario ingresa MM e YY en campos separados. Esto resulta en fechas que son el 31 o 30 y 28 o 29 también para febrero.

/// <summary>
/// Creates datetime for current century and sets days to end of month
/// </summary>
/// <param name="MM"></param>
/// <param name="YY"></param>
/// <returns></returns>
public static DateTime GetEndOfMonth(string MM, string YY)
{
// YY -> YYYY #RipVanWinkle
// Gets Current century and adds YY to it.
// Minus 5 to allow dates that may be expired to be entered.
// eg. today is 2017, 12 = 2012 and 11 = 2111
int currentYear = DateTime.Now.Year;
string thisYear = currentYear.ToString().Substring(0, 2) + YY;
int month = Int32.Parse(MM);
int year = Int32.Parse(thisYear);
if ((currentYear - 5) > year)
year += 100;
return new DateTime(year, month, DateTime.DaysInMonth(year, month));
}

Answer 5

Este método puede convertir los dígitos de los últimos dos años de la tarjeta de crédito en cuatro años.

private static int ToFourDigitYear(int year) { string stringYear = year.ToString("00"); if (stringYear.Length == 2) { int currentYear = DateTime.Now.Year; string firstTwoDigitsOfCurrentYear = currentYear.ToString().Substring(0, 2); year = Convert.ToInt32(firstTwoDigitsOfCurrentYear + stringYear); if (year < currentYear) year = year + 100; } return year; }

Answer 6

La implementación de

System.Globalization.CultureInfo.CurrentCulture.Calendar.ToFourDigitYear

es

public virtual int ToFourDigitYear(int year)
{
if (year < 0)
throw new ArgumentOutOfRangeException("year", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
if (year < 100)
return (this.TwoDigitYearMax / 100 - (year > this.TwoDigitYearMax % 100 ? 1 : 0)) * 100 + year;
else
return year;
}

¡Espero que esto ayude!

Answer 7

Mi respuesta no coincidirá con su pregunta, pero para las tarjetas de crédito solo agrego 2 dígitos del año actual

 private int UpconvertTwoDigitYearToFour(int yearTwoOrFour)
{
try
{
if (yearTwoOrFour.ToString().Length <= 2)
{
DateTime yearOnly = DateTime.ParseExact(yearTwoOrFour.ToString("D2"), "yy", null);
return yearOnly.Year;
}
}
catch
{
}
return yearTwoOrFour;
}

Answer 8

Mis dos centavos,

Dado un rango de edad = [18, 100+], dos dígitos año = 90, puedo hacerlo

current year - twoDigitsYear = 2018 - 90 = 1928 , tengo 19, 28

por lo tanto, 19 son los dos primeros dígitos del año de nacimiento, y 28 es la edad, que es
año = 1990, edad = 28

Pero no funcionará cuando la edad de 0 y 100 se incluyan en el rango, al igual que algunas de las otras respuestas aquí.

Answer 9

Para cambiar un año de 2 dígitos a 4 dígitos actual o anterior:

year = year + (DateTime.Today.Year - DateTime.Today.Year%100);
if (year > DateTime.Today.Year)
year = year - 100;

Answer 10

Podría ser más inteligente revisar tmpYear> currentYear% 100. Si lo es, entonces es 19XX, de lo contrario 20XX.

Answer 11

Por curiosidad, ¿de dónde sacas estos datos? De una forma? En ese caso; Simplemente le pediría al usuario que complete (o de alguna manera seleccione) el año con cuatro dígitos o que obtenga la edad y el mes / día de nacimiento del usuario, y que use esos datos para determinar en qué año nacieron. De esa manera, no tendría que preocuparse por este problema en absoluto :)

Edición: Use DateTime para trabajar con este tipo de datos.

Answer 12

Prueba este código simple

// Invoque el método TextBoxDateFormat con fecha como parámetro.

Método

public void TextBoxDateFormat(string str1)
{
// Takes the current date format if MM/DD/YY or MM/DD/YYYY
DateTime dt = Convert.ToDateTime(str1);
//Converts the requested date into MM/DD/YYYY and assign it to textbox field
TextBox = String.Format("{0:MM/dd/yyyy}", dt.ToShortDateString());
//include your validation code if required
}

Answer 13

Si calculas para una persona, probablemente no tendrá más de 100 años ...

Ej: 751212

var nr = "751212";
var century = DateTime.Now.AddYears(-100).Year.ToString().Substring(0, 2);
var days = (DateTime.Now - DateTime.Parse(century + nr)).Days;
decimal years = days / 365.25m;
if(years>=99)
century = DateTime.Now.Year.ToString().Substring(0, 2);
var fullnr = century+nr;

Answer 14

También puede usar el método DateTime.TryParse para convertir su fecha. Utiliza la configuración de la cultura actual para definir el año dinámico (en mi caso es 2029)

DateTime resultDate;
Console.WriteLine("CultureInfo.CurrentCulture.Calendar.TwoDigitYearMax : {0}", System.Globalization.CultureInfo.CurrentCulture.Calendar.TwoDigitYearMax);
DateTime.TryParse("01/01/28", out resultDate);
Console.WriteLine("Generated date with year=28 - {0}",resultDate);
DateTime.TryParse("01/02/29",out resultDate);
Console.WriteLine("Generated date with year=29 - {0}", resultDate);
DateTime.TryParse("01/03/30", out resultDate);
Console.WriteLine("Generated date with year=30 - {0}", resultDate);

La salida es:

CultureInfo.CurrentCulture.Calendar.TwoDigitYearMax: 2029

Fecha generada con año = 28 - 01/01/2028 00:00:00

Fecha generada con año = 29 - 01/02/2029 00:00:00

Fecha generada con año = 30 - 01/03/1930 00:00:00

Si desea cambiar el comportamiento, puede crear una cultura con el año que desea usar como pivote. Este hilo muestra un ejemplo.

DateTime.TryParse siglo control C #

Pero como dijo Martin, si desea administrar un período de tiempo que abarca más de 100 años, no hay forma de hacerlo con solo 2 dígitos.

Answer 15

Tuve un problema similar, y se me ocurrió esto ... ¡HTH!

value = this.GetDate()
if (value.Length >= 6)//ensure that the date is mmddyy
{
int year = 0;
if (int.TryParse(value.Substring(4, 2), out year))
{
int pastMillenium = int.Parse(DateTime.Now.ToString("yyyy").Substring(0, 2)) - 1;
if (year > int.Parse(DateTime.Now.ToString("yy")))//if its a future year it''s most likely 19XX
{
value = string.Format("{0}{1}{2}", value.Substring(0, 4), pastMillenium, year.ToString().PadLeft(2, ''0''));
}
else
{
value = string.Format("{0}{1}{2}", value.Substring(0, 4), pastMillenium + 1, year.ToString().PadLeft(2, ''0''));
}
}
else
{
value = string.Empty;
}
}
else
{
value = string.Empty;
}

Answer 16

Una vez que haya tomado las otras sugerencias sobre cuándo cambiar sus suposiciones del siglo 19 al 20, el mejor de todos los mundos posibles implica actualizar su fuente de datos de una vez por todas con años de 4 dígitos, para que pueda dejar de hacer suposiciones todo el tiempo. hora.