/// <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);
}
