Esempio n. 1
0
 /// <summary>
 /// Constructor: inicializa los atributos
 /// <param name="Id">int</param>
 /// <param name="tipo">ETipoPc</param>
 /// <param name="gama">EGama</param>
 /// <param name="precio">float</param>
 /// </summary>
 public Computadora(int Id, ETipoPc tipo, EGama gama, float precio)
     : this()
 {
     this.idComputadora = Id;
     this.tipo          = tipo;
     this.gama          = gama;
     this.precio        = precio;
 }
Esempio n. 2
0
        /// <summary>
        /// Toma los datos de la fila y los devuelve como una Computadora
        /// </summary>
        /// <param name="fila">DataRow</param>
        /// <returns> Devuelve una Computadora con los datos de la fila</returns>
        private Computadora TomarDatosDeFila(DataRow fila)
        {
            int   id   = Int32.Parse(fila["id"].ToString());
            EGama gama = default;

            switch (fila["gama"])
            {
            case "Baja":
                gama = EGama.Baja;
                break;

            case "Media":
                gama = EGama.Media;
                break;

            case "Alta":
                gama = EGama.Alta;
                break;
            }

            ETipoPc tipo = default;

            switch (fila["tipo"])
            {
            case "Desktop":
                tipo = ETipoPc.Desktop;
                break;

            case "Laptop":
                tipo = ETipoPc.Laptop;
                break;
            }
            float       precio = float.Parse(fila["precio"].ToString());
            Computadora compu  = default;

            if (tipo == ETipoPc.Desktop)
            {
                bool perisfericos = bool.Parse(fila["perisfericos"].ToString());
                compu = new Desktop(id, tipo, gama, precio, perisfericos);
            }
            else if (tipo == ETipoPc.Laptop)
            {
                bool bluetooth = bool.Parse(fila["bluetooth"].ToString());
                compu = new Laptop(id, tipo, gama, precio, bluetooth);
            }
            return(compu);
        }
Esempio n. 3
0
        /// <summary>
        /// Se acepta la operacion y se devuelve un DialogResult.OK
        /// </summary>
        /// <param name="sender">object</param>
        /// <param name="e">EventArgs</param>
        private void btnAceptar_Click(object sender, EventArgs e)
        {
            int id;

            Int32.TryParse(this.txtId.Text, out id);
            EGama gama = EGama.Baja;

            switch (this.cmbGama.SelectedIndex)
            {
            case 0:
                gama = EGama.Baja;
                break;

            case 1:
                gama = EGama.Media;
                break;

            case 2:
                gama = EGama.Alta;
                break;
            }
            float precio = 0;

            float.TryParse(this.txtPrecio.Text, out precio);
            bool bluetooth    = this.cbBluetooth.Checked;
            bool perisfericos = this.cbPerisfericos.Checked;

            if (this.rbDesktop.Checked == true)
            {
                this.c = new Desktop(id, ETipoPc.Desktop, gama, precio, perisfericos);
            }
            else if (this.rbLaptop.Checked == true)
            {
                this.c = new Laptop(id, ETipoPc.Laptop, gama, precio, bluetooth);
            }

            evento.Invoke();
            this.DialogResult = DialogResult.OK;
        }
Esempio n. 4
0
 public Celular(string modelo, Fabricante fabricante, EGama gama) : base(modelo, fabricante)
 {
     this.Gama = gama;
 }
Esempio n. 5
0
 /// <summary>
 /// Constructor que genere una notebook con los datos recibidos como parametro
 /// </summary>
 /// <param name="modelo"></param>
 /// <param name="micropocesador"></param>
 /// <param name="memoriaRam"></param>
 /// <param name="almacenamiento"></param>
 /// <param name="placaMadre"></param>
 /// <param name="gama"></param>
 public Notebook(string modelo, int micropocesador, int memoriaRam, int almacenamiento, int placaMadre, EGama gama)
     : base(modelo, gama)
 {
     this.Microprocesador = micropocesador;
     this.MemoriaRam      = memoriaRam;
     this.Almacenamiento  = almacenamiento;
     this.PlacaMadre      = placaMadre;
 }
Esempio n. 6
0
 /// <summary>
 /// Constructor que instancia un producto segun lo pasado por parametro
 /// </summary>
 /// <param name="modelo"></param>
 /// <param name="gama"></param>
 public Producto(string modelo, EGama gama)
 {
     this.modelo = modelo;
     this.gama   = gama;
 }
Esempio n. 7
0
        /// <summary>
        /// Constructor parametrizado de la clase Accesorio
        /// </summary>
        /// <param name="id">id Accesorio</param>
        /// <param name="nombre">nombre de Accesorio</param>
        /// <param name="precio">Precio de Accesorio</param>
        /// <param name="cantidad">Cantidad con respecto al stock del Accesesorio</param>
        /// <param name="gama">Gama del accesorio</param>
        /// <param name="tipo">Tipo del accesorio</param>

        public Accesorio(int id, string nombre, float precio, int cantidad, EGama gama, ETipo tipo) : base(id, nombre, precio, cantidad)
        {
            this.gama = gama;
            this.tipo = tipo;
        }
Esempio n. 8
0
 /// <summary>
 /// Constructor: inicializa los atributos
 /// <param name="Id">int</param>
 /// <param name="tipo">ETipoPc</param>
 /// <param name="gama">EGama</param>
 /// <param name="precio">float</param>
 /// <param name="perisfericos">bool</param>
 /// </summary>
 public Desktop(int Id, ETipoPc tipo, EGama gama, float precio, bool perisfericos)
     : base(Id, tipo, gama, precio)
 {
     this.perisfericos = perisfericos;
 }
Esempio n. 9
0
 /// <summary>
 /// Constructor: inicializa los atributos
 /// <param name="Id">int</param>
 /// <param name="tipo">ETipoPc</param>
 /// <param name="gama">EGama</param>
 /// <param name="precio">float</param>
 /// <param name="bluetooth">bool</param>
 /// </summary>
 public Laptop(int Id, ETipoPc tipo, EGama gama, float precio, bool bluetooth)
     : base(Id, tipo, gama, precio)
 {
     this.bluetooth = bluetooth;
 }