/// <summary> /// Agregar a una fecha la cantidad de meses ingresados como parámetro y devuelve una nueva instancia de la fecha resultante. /// </summary> /// <param name="pCantidadMeses">Cantidad de meses que se quieran agregar</param> /// <returns>Devuelve una nueva instancia de agregar <paramref name="pCantidadMeses"/>.</returns> public Fechas AgregarMeses(int pCantidadMeses) { int mCantidadDias = 0; int mMesActual = this.iMes; int mAñoActual = this.iAño; for (int bIndice = 1; bIndice <= pCantidadMeses; bIndice++) { // En la próxima iteración luego de diciembre, vuelvo a enero e // incremento el año. if (mMesActual == 12) { mMesActual = 1; mAñoActual++; } else { mMesActual++; } mCantidadDias += Fechas.CalcularCantidadDiasMes(mMesActual, mAñoActual); } return(new Fechas((this.iCantidadDias + mCantidadDias))); }
static void Main(string[] args) { Fechas fecha = new Fechas(1, 1, 2000); Console.Write(fecha.DiaDeLaSemana); Console.ReadKey(); }
/// <summary> /// Agregar a una fecha la cantidad de años ingresados como parámetro y devuelve una nueva instancia de la fecha resultante. /// </summary> /// <param name="pAños">Cantidad de meses que se quieran agregar</param> /// <returns> Devuelve una nueva instancia de agregar <paramref name="pAños"/>. </returns> public Fechas AgregarAños(int pAños) { int mCantidadDias = 0; for (int bIndice = 1; bIndice <= pAños; bIndice++) { mCantidadDias += Fechas.CalcularCantidadDiasAño(this.iAño + bIndice); } return(new Fechas((this.iCantidadDias + mCantidadDias))); }
/// <summary> /// Calcula la cantidad de dias que hay en un año /// </summary> /// <param name="pAño"> Año ingresado para el cual se desean obtener la cantidad de dias</param> /// <returns> Devuelve la cantidad de dias teniendo en cuenta si el año ingresado es bisiesto o no. </returns> private static int CalcularCantidadDiasAño(int pAño) { int mCantidadDias = 365; if (Fechas.EsBisiesto(pAño)) { mCantidadDias++; } return(mCantidadDias); }
/// <summary> /// Calcula la cantidad de dias tomando como parámetro un mes y un año /// </summary> /// <param name="pMes"> Mes para el que se desea calcular la cantidad de dias</param> /// <param name="pAño"> Año para el que se desea calcular la cantidad de dias</param> /// <returns>Devuelve en mCantidadDias la cantidad de dias a partir del mes y año. </returns> private static int CalcularCantidadDiasMes(int pMes, int pAño) { int mCantidadDias = CANTIDAD_DIAS_MES[pMes - 1]; // Si el mes es febrero y el año es bisiesto entonces debo sumarle // una unidad al número recuperado. if (pMes == 2 && Fechas.EsBisiesto(pAño)) { mCantidadDias += 1; } return(mCantidadDias); }
/// <summary> /// Constructor interno al que se le pasan la cantidad de día. /// </summary> /// <<param name="pCantidadDias">Cantidad de días.</param> /// <exception cref="ArgumentException">Si <paramref name="pCantidadDias"/> no está comprendido entre 1 y 219.146.</exception> public Fechas(long pCantidadDias) { if ((pCantidadDias >= 1) && (pCantidadDias <= 219146)) { this.iCantidadDias = pCantidadDias; int mAñoActual = AÑO_BASE; int mCantidadDiasAñoActual = Fechas.CalcularCantidadDiasAño(mAñoActual); // Se van sumando años al año base siempre y cuando la cantidad de días // sea suficiente para el año que se quiera sumar. while (pCantidadDias > mCantidadDiasAñoActual) { mAñoActual++; pCantidadDias -= mCantidadDiasAñoActual; mCantidadDiasAñoActual = Fechas.CalcularCantidadDiasAño(mAñoActual); } this.iAño = mAñoActual; int mMesActual = 1; int mCantidadDiasMesActual = Fechas.CalcularCantidadDiasMes(mMesActual, this.iAño); // Se van sumando meses siempre y cuando haya suficientes días para // el mes que se esté tratando. while (pCantidadDias > mCantidadDiasMesActual) { mMesActual++; pCantidadDias -= mCantidadDiasMesActual; mCantidadDiasMesActual = Fechas.CalcularCantidadDiasMes(mMesActual, this.iAño); } this.iMes = mMesActual; // El componente día es lo que quedó de quitar los días transcurridos // en los años y en los meses. this.iDia = (int)pCantidadDias; } else { this.iDia = 1; this.iMes = 1; this.iAño = AÑO_BASE; this.iCantidadDias = 1; } }
/// <summary> /// /// </summary> /// <param name="pDia">Componente dia. </param> /// <param name="pMes">Componente mes. </param> /// <param name="pAño">Componente año. </param> /// <exception cref="ArgumentException">Si <paramref name="pDia"/> no está comprendido entre 1 y la cantidad de días máximos del <paramref name="pMes"/> y <paramref name="pAño"/>. </exception> /// <exception cref="ArgumentException">Si <paramref name="pMes"/> no está comprendido entre 1 y 12. </exception> /// <exception cref="ArgumentException">Si <paramref name="PAño"/> no está comprendido entre 1900 y 2499. </exception> public Fechas(int pDia, int pMes, int pAño) { /*if (!(pAño < AÑO_BASE || pAño > AÑO_MAXIMO) && (pMes < 1 || pMes > 12) && (pDia < 1 || pDia > Fechas.CalcularCantidadDiasMes(pMes, pAño)))*/ if (((pAño >= AÑO_BASE) && (pAño <= AÑO_MAXIMO) && (pMes >= 1) && (pMes <= 12) && (pDia >= 1) && (pDia <= Fechas.CalcularCantidadDiasMes(pMes, pAño)))) { this.iDia = pDia; this.iMes = pMes; this.iAño = pAño; // Por lo menos, desde la fecha base han pasado la cantidad de días // del componente día de la fecha. long mCantidadDias = pDia; // Se calculan la cantidad de días de los meses transcurridos desde enero hasta // el mes anterior al componente mes provisto, ya que dicho mes no está // completo y sus días ya fueron considerados. for (int bMes = 1; bMes < pMes; bMes++) { mCantidadDias += Fechas.CalcularCantidadDiasMes(bMes, pAño); } // Se calculan la cantidad de días transcurridos desde el año base // hasta el año anterior al del componente año, ya que se han sumado // los días y meses de dicho año. for (int bAño = AÑO_BASE; bAño < pAño; bAño++) { mCantidadDias += Fechas.CalcularCantidadDiasAño(bAño); } this.iCantidadDias = mCantidadDias; } else { throw new ArgumentNullException("La fecha proporcionada está fuera de los límites."); } }
/// <summary> /// Compara la fecha con la provista como parámetro. /// </summary> /// <param name="pFecha">Fecha ingresada con la que se quiere comparar.</param> /// <returns>-1 si la fecha es menor que la fecha provista, 0 si son iguales, y 1 si la fecha es mayor a la fecha proporcionada como parámetro.</returns> /// <exception cref="ArgumentNullException">Si <paramref name="pFecha"/> es nula.</exception> public int CompararFecha(Fechas pFecha) { if (pFecha == null) { throw new ArgumentNullException("La fecha proporcionada es nula."); } int mResultado; if (this.iCantidadDias < pFecha.iCantidadDias) { mResultado = -1; } else if (this.iCantidadDias == pFecha.iCantidadDias) { mResultado = 0; } else { mResultado = 1; } return(mResultado); }
/// <summary> /// Indica si la fecha pertenece a un año bisiesto. /// </summary> /// <returns>true si la fecha pertenece a un año bisiesto, false en caso contrario.</returns> public bool EsBisiesto() { return(Fechas.EsBisiesto(this.iAño)); }
/// <summary> /// Agregar a una fecha la cantidad de dias ingresados como parámetro y devuelve una nueva instancia de la fecha resultante. /// </summary> /// <param name="pCantidadDias">Cantidad de dias que se quiere agregar</param> /// <returns> Devuelve una nueva instancia de agregar <param name="pCantidadDias">. </returns> public Fechas AgregarDias(int pCantidadDias) { Fechas mNuevaFecha = new Fechas(this.iCantidadDias + pCantidadDias); return(mNuevaFecha); }