Exemplo n.º 1
0
        /// <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)));
        }
Exemplo n.º 2
0
        /// <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;
            }
        }
Exemplo n.º 3
0
        /// <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.");
            }
        }