Pro C#: Módulo 02: Laboratorio: Código Fuente

Código Fuente de Ejemplo

Contador.cs

public class Contador

    {

        //Campos Privados

        //Valor del Contador

        private int Valor = 0;

        //Valor a decrementar

        private int Paso = 1;

        //Valor Máximo del Contador

        private int Max = 99;

        //Valor Mínimo del Contador

        private int Min = 0;

        //Desfase Superior e Inferior al Valor Máximo

        private int DesfaseSuperior = 0;

        private int DesfaseInferior = 0;

        //Método Constructor por Omisión

        public Contador()

        {

            Valor = 0;

        }

        //Método Constructor Sobrecargado (Overloaded)

        public Contador(int Valor)

        {

            setValor(Valor);

        }

        //Método Asigna o Inicializa el Valor del Contador

        public void setValor(int Valor)

        {

            if (Valor > Min)

            {

                this.Valor = Valor;

                if (this.Valor > Max)

                {

                    DesfaseSuperior = (this.Valor - Max) / 2;

                    if (DesfaseSuperior < Min) DesfaseSuperior = Min;

                    DesfaseInferior = this.Valor - Max - DesfaseSuperior;

                    DesfaseInferior = (DesfaseInferior < Min) ? Min : DesfaseInferior;

                    this.Valor = this.Valor - DesfaseSuperior - DesfaseInferior;

                }

            }

            else

                this.Valor = Min;

        }

     

        //Tag para agregar comentarios generados por el compilador

        /// <summary>

        /// Retorna Valores entre Max y Min

        /// Repite Max y Min varias veces para

        /// representar el valor completo

        /// </summary>

        /// <returns>int</returns>

        public int decrementar()

        {

            int ValorRetorno = Min;

            if ( (Valor + DesfaseSuperior) > Max)

            {

                ValorRetorno = Max;

                //Si el DesfaseSuperior es Mayor que Paso solo resta

                if (DesfaseSuperior > Paso)

                    DesfaseSuperior -= Paso;

                else

                {   //Sino la diferencia la aplica a Valor

                    //Variable Diferencai declarada dentro de un bloque

                    int Diferencia = DesfaseSuperior - Paso;

                    DesfaseSuperior = 0;

                    //Operador Terciario

                    Valor = (Valor > Diferencia) ? Valor - Diferencia

                        : Min;

                }

            }

            else if (Valor + DesfaseInferior > Paso)

            {

                if (Valor > Paso)

                {

                    Valor = Valor - Paso;

                    ValorRetorno = Valor;

                }

                else

                {

                    int Diferencia = Valor - Paso;

                    // TODO : Validar si es 0 o Min

                    Valor = 0;

                    if (DesfaseInferior > Diferencia)

                    {

                        // TODO : Validar si esta es la mejor forma

                        ValorRetorno = Min + 1;

                        DesfaseInferior = DesfaseInferior + Diferencia;

                    }

                    else

                    {  

                        // TODO : Validar si es 0 o Min

                        Valor = 0;

                        DesfaseInferior = 0;

                        ValorRetorno = Min;

                    }

                }

            }

                            

            return ValorRetorno;

        }

    }

Program.cs

class Program

    {

        static void Main(string[] args)

        {

            int Segundos = 120, Despliegue = 0, i = Segundos;

            //Declaración de un Objeto e Instancia

            Contador xCont = new Contador(Segundos);

            //Invoca al Método del Objeto y Presenta Resultados

            do

            {

                //Invoca el método de la Clase

                Despliegue = xCont.decrementar();

                //Muestra Datos, la ventana de la consola

                //Debe tener 120 columnas.

                Console.Write("{0,3}) {1:d2} ",

                    i, Despliegue);

                //Decrementa i

                i--;

            } while (Despliegue > 0);

            //Espera por una tecla presionada

            Console.ReadKey();

        }

    }

Pro C#: Módulo 04: Laboratorio: Código Fuente

Código Fuente de Ejemplo

Contador.cs

Se agrega el método getValor() a la clase Contador.

        //Método que Retorna el Valor actual del Contador

        //Incluyendo el Desfase Superior e Inferior.

        public int getValor()

        {

            return (Valor + DesfaseInferior + DesfaseSuperior);

        }

Semaforo.cs

Clase que representa los 3 colores del Semáforo y un contador en segundos para cada color.

    /// <summary>

    /// Representa los 3 colores del Semáforo

    /// </summary>

    public class Semaforo

    {

        /// <summary>

        /// Enumeración de los Colores

        /// </summary>

        public enum Color : int { Verde, Amarillo, Rojo }

        //Arreglo de los 3 Contadores

        Contador[] ContxColor;

        /// <summary>

        /// Constructor por omisión (sin argumentos)

        /// </summary>

        public Semaforo()

        {

            //Instancia el Arreglo

            ContxColor = new Contador[3];

            //Instancia cada Contador del Arreglo

            ContxColor[(int)Color.Verde] = new Contador(15);

            ContxColor[(int)Color.Amarillo] = new Contador(15);

            ContxColor[(int)Color.Rojo] = new Contador(15);

        }

        /// <summary>

        /// Constructor con Segundos para cada color especificados

        /// en los argumentos

        /// </summary>

        /// <param name="Verde">Cantidad de Segundos Verde</param>

        /// <param name="Amarillo">Cantidad de Segundos Amarillo</param>

        /// <param name="Rojo">Cantidad de Segundos Rojo</param>

        public Semaforo(int Verde, int Amarillo, int Rojo)

        {

            //Instancia el Arreglo

            ContxColor = new Contador[3];

            //Instancia cada Contador del Arreglo

            ContxColor[(int)Color.Verde] = new Contador(Verde);

            ContxColor[(int)Color.Amarillo] = new Contador(Amarillo);

            ContxColor[(int)Color.Rojo] = new Contador(Rojo);

        }

        /// <summary>

        /// Invoca al método decrementar de la clase Contador

        /// </summary>

        /// <param name="ColorSemaforo">El argumento específica que

        /// color del Semáforo va a decrementar

        /// </param>

        /// <returns></returns>

        private int decrementarColor(Color ColorSemaforo)

        {

            return ContxColor[(int)ColorSemaforo].decrementar();

        }

       

        /// <summary>

        /// Decrementa el contador del Color Verde

        /// </summary>

        /// <returns></returns>

        public int decrementarVerde()

        {

            return decrementarColor(Color.Verde);

        }

        /// <summary>

        /// Decrementa el contador del Color Amarillo

        /// </summary>

        /// <returns></returns>

        public int decrementarAmarillo()

        {

            return decrementarColor(Color.Amarillo);

        }

        /// <summary>

        /// Decrementa el Contador del Color Rojo

        /// </summary>

        /// <returns></returns>

        public int decrementarRojo()

        {

            return decrementarColor(Color.Rojo);

        }

        //Propiedades que Devuelven el Valor en Segundos

        //de Cada Color

        public int Verde

        {

            get { return ContxColor[(int)Color.Verde].getValor(); }

        }

        public int Amarillo

        {

            get { return ContxColor[(int)Color.Amarillo].getValor(); }

        }

        public int Rojo

        {

            get { return ContxColor[(int)Color.Rojo].getValor(); }

        }

    }

Program.cs

Se agrega el método para Probar la Clase Semaforo.

        /// <summary>

        /// Prueba un Semáforo específico

        /// a decrementar los contadores de los 3 colores

        /// </summary>

        /// <param name="mSemaforo"></param>

        static void TestSemaforo(Semaforo mSemaforo)

        {

            int i = 0, Despliegue = 0;

            //Verde

            Console.WriteLine("Verde");

            do

            {

                Despliegue = mSemaforo.decrementarVerde();

                i++;

                //Muestra Datos.

                Console.Write("{0,3}) {1:d2} ",

                    i, Despliegue);

            } while (Despliegue>0);

            Console.WriteLine();

            //Amarillo

            Console.WriteLine("Amarillo");

            do

            {

                Despliegue = mSemaforo.decrementarAmarillo();

                i++;

                //Muestra Datos.

                Console.Write("{0,3}) {1:d2} ",

                    i, Despliegue);

            } while (Despliegue > 0);

            Console.WriteLine();

            //Rojo

            Console.WriteLine("Rojo");

            do

            {

                Despliegue = mSemaforo.decrementarRojo();

                i++;

                //Muestra Datos.

                Console.Write("{0,3}) {1:d2} ",

                    i, Despliegue);

            } while (Despliegue > 0);

            Console.WriteLine();

        }

        /// <summary>

        /// Crea dos objetos en base a la Clase Semaforo

        /// y prueba funcionamiento.

        /// </summary>

        static void TestSemaforos()

        {

            //Dos Objetos Tipo Semaforo

            Semaforo S1, S2;

            //Semáforo con constructor por omisión

            S1 = new Semaforo();

            //Semáforo con constructor

            S2 = new Semaforo(45, 5, 50);

            Console.WriteLine();

            Console.WriteLine("Prueba Semáforo 1");

            TestSemaforo(S1);

            Console.WriteLine();

            Console.WriteLine("Prueba Semáforo 2");

            TestSemaforo(S2);

        }

        static void Main(string[] args)

        {

            //TestContador();

            TestSemaforos();

            //TestSerializarJSON();

            //Espera por una tecla presionada

            Console.ReadKey();

        }