Example #1
0
 public void RemoveComponente(IComponente Componente)
 {
     if (Componentes.Contains(Componente))
     {
         Componentes.Remove(Componente);
     }
 }
Example #2
0
        private static void Main(string[] args)
        {
            string Ruta_madre;

            Ruta_madre = "D:\\Proyectos Santiago";

            CDirectorio Carpeta_madre = new CDirectorio(Ruta_madre);

            IComponente <CDirectorio> Raiz       = new Compuesto <CDirectorio>(Carpeta_madre);
            IComponente <CDirectorio> Directorio = Raiz;

            Console.WriteLine("Estoy en {0}", Directorio.Nombre);
            Console.WriteLine("1-Adicionar Compuesto 2-Adicionar Componente 3-Borrar 4-Buscar 5-Mostrar 6-Salir");

            foreach (string dirs in Carpeta_madre.Child_item)
            {
                CDirectorio temp            = new CDirectorio(dirs);
                IComponente <CDirectorio> c = new Compuesto <CDirectorio>(temp);

                Directorio.Adicionar(c);
            }



            Console.WriteLine(Raiz.Mostrar(0));
            Console.Read();
        }
 public void RemoveComponente(IComponente Componente)
 {
     if (Componente == null)
         return;
     if (Componentes.Contains(Componente))
         Componentes.Remove(Componente);
 }
 public void AddComponente(IComponente Componente)
 {
     if (!Componentes.Contains(Componente))
     {
         Componentes.Add(Componente);
     }
 }
 public void RemoveComponente(IComponente Componente)
 {
     if (Componentes.Contains(Componente))
     {
         Componentes.Remove(Componente);
     }
 }
Example #6
0
        public void Main()
        {
            int    iMontoTotal = 0;
            string cMensaje    = string.Empty;
            //UAX
            ClaseComposicion claseComposicionX = new ClaseComposicion(AgregarImporteUnidad("UAX", 0, 0, 0));
            //1
            ClaseComposicion claseComposicion1 = new ClaseComposicion(AgregarImporteUnidad("UA1", 0, 0, 0));
            //1.1
            ClaseComposicion claseComposicion1_1 = new ClaseComposicion(AgregarImporteUnidad("UA1.1", 0, 0, 0));
            //1.1.1
            IComponente iComponenteUnidad1_1_1 = new Unidad(AgregarImporteUnidad("UA1.1.1", 1, 1, 1));

            claseComposicion1_1.Agregar(iComponenteUnidad1_1_1);

            IComponente iComponenteUnidad1_1 = claseComposicion1_1;

            claseComposicion1.Agregar(iComponenteUnidad1_1);

            IComponente iComponenteUnidad1 = claseComposicion1;

            claseComposicionX.Agregar(iComponenteUnidad1);

            //2
            ClaseComposicion claseComposicion2 = new ClaseComposicion(AgregarImporteUnidad("UA2", 0, 0, 0));
            //2.1
            ClaseComposicion claseComposicion2_1 = new ClaseComposicion(AgregarImporteUnidad("UA2.1", 0, 0, 0));
            //2.1.1
            IComponente iComponenteUnidad2_1_1 = new Unidad(AgregarImporteUnidad("UA2.1.1", 2, 2, 2));

            claseComposicion2_1.Agregar(iComponenteUnidad2_1_1);

            IComponente iComponenteUnidad2_1 = claseComposicion2_1;

            claseComposicion2.Agregar(iComponenteUnidad2_1);

            IComponente iComponenteUnidad2 = claseComposicion2;

            claseComposicionX.Agregar(iComponenteUnidad2);

            //3
            ClaseComposicion claseComposicion3 = new ClaseComposicion(AgregarImporteUnidad("UA3", 0, 0, 0));
            //3.1
            IComponente iComponenteUnidad3_1 = new Unidad(AgregarImporteUnidad("UA3.1", 3, 3, 3));

            claseComposicion3.Agregar(iComponenteUnidad3_1);

            IComponente iComponenteUnidad3 = claseComposicion3;

            claseComposicionX.Agregar(iComponenteUnidad3);

            //3.1
            IComponente iComponenteUnidad4 = new Unidad(AgregarImporteUnidad("UA4", 4, 4, 4));

            claseComposicionX.Agregar(iComponenteUnidad3);

            iMontoTotal = claseComposicionX.ObtenerImporteUnidad();
            Console.WriteLine(string.Format("Impote Total: {0}", iMontoTotal));
            Console.ReadLine();
        }
Example #7
0
 public void AddComponente(IComponente Componente)
 {
     if (!Componentes.Contains(Componente))
     {
         Componentes.Add(Componente);
     }
 }
Example #8
0
 public Usuario(string nombreUsuario, string contraseña, string nombre, string apellido, IComponente rol)
 {
     NombreUsuario = nombreUsuario;
     Contraseña    = contraseña;
     Nombre        = nombre;
     Apellido      = apellido;
     Rol           = rol;
 }
        public void AddComponente(IComponente Componente)
        {
            if (Componente == null)
                return;
            Acesso aresta = (Acesso)Componente;

            if (!destPossiveis.Contains(Componente))
                destPossiveis.Add(aresta);
        }
Example #10
0
        private static void Main(string[] args)
        {
            IComponente <string> arbol   = new Compuesto <string>("root");
            IComponente <string> trabajo = arbol; //Referenciador

            string opcion = "";
            string dato   = "";

            while (opcion != "6")
            {
                Console.WriteLine("Estoy en {0}", trabajo.Nombre);
                Console.WriteLine("1-Adicionar Compuesto 2-Adicionar Componente 3-Borrar 4-Buscar 5-Mostrar 6-Salir");

                opcion = Console.ReadLine();
                Console.WriteLine("-------------------");

                if (opcion == "1")
                {
                    Console.WriteLine("Dame el nombre del compuesto: ");
                    dato = Console.ReadLine();

                    IComponente <string> c = new Compuesto <string>(dato);
                    trabajo.Adicionar(c);
                    trabajo = c;
                }

                if (opcion == "2")
                {
                    Console.WriteLine("Dame el nombre del componente: ");
                    dato = Console.ReadLine();

                    trabajo.Adicionar(new Componente <string>(dato));
                }

                if (opcion == "3")
                {
                    Console.WriteLine("Dame el elemento a borrar: ");
                    dato = Console.ReadLine();

                    trabajo.Borrar(dato);
                }

                if (opcion == "4")
                {
                    Console.WriteLine("Dame el elemento a buscar: ");
                    dato = Console.ReadLine();

                    trabajo = arbol.Buscar(dato);
                }

                if (opcion == "5")
                {
                    Console.WriteLine(arbol.Mostrar(0));
                }
            }
        }
Example #11
0
        static void Main(string[] args)
        {
            IComponente <string> arbol   = new Compuesto <string>("root");
            IComponente <string> trabajo = arbol;

            string opcion = string.Empty;
            string dato   = string.Empty;

            while (opcion != "6")
            {
                Console.WriteLine($"Estoy en {trabajo.Nombre}");
                Console.WriteLine("1-Adicionar Compuesto; 2-Adicionar Componente; 3-Borrar; 4-Buscar; 5-Mostrar; 6-Salir");
                opcion = Console.ReadLine();
                Console.WriteLine("----------");

                if (opcion == "1")
                {
                    Console.WriteLine("Dame el nombre del Compuesto: ");
                    dato = Console.ReadLine();

                    IComponente <string> c = new Compuesto <string>(dato);
                    trabajo.Adicionar(c);
                    trabajo = c;
                }

                if (opcion == "2")
                {
                    Console.WriteLine("Dame el nombre del Componente: ");
                    dato = Console.ReadLine();

                    IComponente <string> c = new Componente <string>(dato);
                    trabajo.Adicionar(c);
                }

                if (opcion == "3")
                {
                    Console.WriteLine("Dame el elemento a borrar: ");
                    dato = Console.ReadLine();

                    trabajo = trabajo.Borrar(dato);
                }

                if (opcion == "4")
                {
                    Console.WriteLine("Dame el elemento a buscar: ");
                    dato = Console.ReadLine();

                    trabajo = arbol.Buscar(dato);
                }

                if (opcion == "5")
                {
                    Console.WriteLine(arbol.Mostrar(0));
                }
            }
        }
        public static void _Main()
        {
            //arbol contendra todos los elementos, siempre es Compuesto
            IComponente <string> arbol = new CCompuesto <string>("root"); //instanciamos un compuesto(CCompuesto) es la raiz del arbol a crear
            //incializamos al varaible trabajo a arbol, para q inicialmente este referenciado
            IComponente <string> trabajo = arbol;                         //la variable trabajo sera la referencia hacia el nodo o al elemento ya sea compuesto o componente con el cual estamos trabajando
            string opcion = "";
            string dato   = "";

            while (opcion != "6")
            {
                Console.WriteLine("Estoy en {0} ", trabajo.Nombre);//
                Console.WriteLine("1-AdicionarCompuesto  2-AdicionarComponente  3-Borrar  4-Buscar  5-Mostrar  6-Salir");
                opcion = Console.ReadLine();
                Console.WriteLine("----------------");
                if (opcion == "1")//AdicionarCompuesto
                {
                    Console.WriteLine("Dame el nombre del compuesto: ");
                    dato = Console.ReadLine();                              //Nombre del compuesto
                    //creamos un compuesto nuevo, el ctor inicializa la lista
                    IComponente <string> c = new CCompuesto <string>(dato); //usamos la interfaz IComponente para q se adicione detro de la jerarquia
                    trabajo.Adicionar(c);                                   //Añadimos el compuesto al arbol, ya q trabajo = arbol
                    trabajo = c;                                            //ahora la variable trabajo  apuntara al nuevo elemento (c) tipo Compuesto, simpre nos posiciones a este tipo porque si le podemos añadir elementos
                }
                if (opcion == "2")                                          //AdicionarComponente
                {
                    Console.WriteLine("Dame el nombre del componente: ");
                    dato = Console.ReadLine();
                    //aqui no se actualiza la varibale trabajo ya que estamos añadiendo un componente y los componenetes no c pueden contener a si mismos
                    trabajo.Adicionar(new CComponente <string>(dato)); //Añadimos la nueva instancia tipo componente, como es componente solo añadimos
                }
                if (opcion == "3")                                     //Borrar, el elemento a borrar tiene q ser hijo o formar parte de la seccion en la q estamos trabajando
                {
                    //Aqui solamente c pueden borrar elementos del compuesto con el cual estoy trabajando
                    //tenemos movernos a otros compuestos para borrar su pertenencias
                    Console.WriteLine("Dame el nombre del componente: ");
                    dato = Console.ReadLine();

                    trabajo = trabajo.Borrar(dato);
                }
                if (opcion == "4")//Buscar
                {
                    Console.WriteLine("Dame el elemento a encontrar: ");
                    dato = Console.ReadLine();

                    trabajo = arbol.Buscar(dato);
                }
                if (opcion == "5")                       //Mostrar
                {
                    Console.WriteLine(arbol.Mostrar(0)); //arbol.Mostrar(0) le mandamos la prfundidad en este caso mostamos desde la raiz(0)
                }
                if (opcion == "6")
                {
                }
            }
        }
        public IComponente <T> Borrar(T pElemento)
        {
            IComponente <T> elemento = this.Buscar(pElemento);

            if (elemento != null)
            {
                (this as Compuesto <T>).elementos.Remove(elemento);
            }
            return(this);
        }
Example #14
0
 public void GerarSolucao()
 {
     Solucao = CriaSolucaoVazia();
     while (!VerificaSolucaoCompleta())
     {
         List <IComponente> Componentes = GerarComponentes();
         IComponente        Temp        = EscolheMelhorComponente(Componentes);
         Solucao.AddComponente(Temp);
     }
 }
 public void AddComponente(IComponente Componente)
 {
     if (Componente == null)
         return;
     if (!Componentes.Contains(Componente))
     {
         Componentes.Add(Componente);
         kmPercorridos += (float)Componente.Valor;
     }
 }
Example #16
0
 public void RemoveComponente(IComponente Componente)
 {
     if (Componente == null)
     {
         return;
     }
     if (Componentes.Contains(Componente))
     {
         Componentes.Remove(Componente);
     }
 }
Example #17
0
        public int ObtenerImporteUnidad()
        {
            int iMonto = 0;

            foreach (IComponente IComponente in this.lstHijos)
            {
                iMonto += IComponente.ObtenerImporteUnidad();
                Console.Write("{0} : {1}\n", IComponente.ImportesUnidad.cUnidad, iMonto);
            }
            return(iMonto);
        }
        public IComponente <T> Borrar(T _elemento)
        {
            //Buscamos el elemento a borrar
            IComponente <T> elemento = this.Buscar(_elemento);

            //si la encontramos, la eliminamos de la lista
            if (!(elemento is null))
            {
                (this as CCompuesto <T>).elementos.Remove(elemento);
            }
            return(this); //retornamos la instancia actual
        }
Example #19
0
 public void AddComponente(IComponente Componente)
 {
     if (Componente == null)
     {
         return;
     }
     if (!Componentes.Contains(Componente))
     {
         Componentes.Add(Componente);
         kmPercorridos += (float)Componente.Valor;
     }
 }
Example #20
0
        public void RemoveComponente(IComponente Componente)
        {
            if (Componente == null)
                return;

            Aresta aresta = (Aresta)Componente;

            if (Componentes.Contains(Componente))
            {
                DistanciaTotal = DistanciaTotal - aresta.Distancia;
                Componentes.Remove(aresta);
            }
        }
Example #21
0
        public void AddComponente(IComponente Componente)
        {
            if (Componente == null)
                return;

            Aresta aresta = (Aresta)Componente;

            if (!Componentes.Contains(Componente))
            {
                DistanciaTotal = DistanciaTotal + aresta.Distancia;
                Componentes.Add(aresta);
            }
        }
Example #22
0
        public void AddComponente(IComponente Componente)
        {
            if (Componente == null)
            {
                return;
            }
            Acesso aresta = (Acesso)Componente;

            if (!destPossiveis.Contains(Componente))
            {
                destPossiveis.Add(aresta);
            }
        }
Example #23
0
        public static ComponenteViewModel From(IComponente componente)
        {
            var viewModel = new ComponenteViewModel
            {
                Id                 = componente.Id,
                Nome               = componente.Nome,
                ComponentePaiId    = (componente.ComponentePai == null ? new int?() : componente.ComponentePai.Id),
                ComponentePaiNome  = (componente.ComponentePai == null ? null : componente.ComponentePai.Nome),
                UnidadePadraoSigla = componente.UnidadePadrao.Sigla,
            };

            return(viewModel);
        }
Example #24
0
        //Buscar datos de la lista dinamica
        public void Buscar(IComponente componente)
        {
            List <IComponente> quitaritem = new List <IComponente>();

            foreach (var c in factura)
            {
                if (c.Modelo == componente.Modelo)
                {
                    quitaritem.Add(c);
                    Console.WriteLine($"== {c.Elemento} \t {c.Marca} \t {c.Modelo} \t {c.Puerto} \t {c.Precio} ");
                    break;
                }
            }
        }
Example #25
0
        public void AddComponente(IComponente Componente)
        {
            if (Componente == null)
            {
                return;
            }

            Aresta aresta = (Aresta)Componente;

            if (!Componentes.Contains(Componente))
            {
                DistanciaTotal = DistanciaTotal + aresta.Distancia;
                Componentes.Add(aresta);
            }
        }
Example #26
0
        public void RemoveComponente(IComponente Componente)
        {
            if (Componente == null)
                return;

            Item item = (Item)Componente;

            if (Componentes.Contains(Componente))
            {
                CapacidadeAtual =  CapacidadeAtual - item.Peso;
                UtilidadeAtual = UtilidadeAtual - item.Utilidade;

                Componentes.Remove(item);
            }
        }
Example #27
0
        public void RemoveComponente(IComponente Componente)
        {
            if (Componente == null)
            {
                return;
            }

            Aresta aresta = (Aresta)Componente;

            if (Componentes.Contains(Componente))
            {
                DistanciaTotal = DistanciaTotal - aresta.Distancia;
                Componentes.Remove(aresta);
            }
        }
Example #28
0
        public void AddComponente(IComponente Componente)
        {
            if (Componente == null)
                return;

            Item item = (Item)Componente;
            if (item.Peso + CapacidadeAtual > CapacidadeMaxima)
                throw new Exception("Capacidade da mochila excedida");

            if (!Componentes.Contains(Componente))
            {
                CapacidadeAtual = CapacidadeAtual + item.Peso;
                UtilidadeAtual = UtilidadeAtual + item.Utilidade;
                Componentes.Add(item);
            }
        }
Example #29
0
        public void RemoveComponente(IComponente Componente)
        {
            if (Componente == null)
            {
                return;
            }

            Item item = (Item)Componente;

            if (Componentes.Contains(Componente))
            {
                CapacidadeAtual = CapacidadeAtual - item.Peso;
                UtilidadeAtual  = UtilidadeAtual - item.Utilidade;

                Componentes.Remove(item);
            }
        }
Example #30
0
        //Eliminar datos de la lista dinamica
        public void Eliminar(IComponente componente)
        {
            List <IComponente> quitaritem = new List <IComponente>();

            foreach (var c in factura)
            {
                if (c.Modelo == componente.Modelo)
                {
                    quitaritem.Add(c);
                    break;
                }
            }

            foreach (var item in quitaritem)
            {
                factura.Remove(item);
            }
        }
Example #31
0
        static void Main(string[] args)
        {
            IComponente <string> arbol   = new Compuesto <string>("root");
            IComponente <string> trabajo = arbol;

            //adicionar componente
            trabajo.Adicionar(new Componente <string>("root1"));
            trabajo.Adicionar(new Componente <string>("root2"));
            //adicionar compuesto
            IComponente <string> c = new Compuesto <string>("root1");

            trabajo.Adicionar(c);
            trabajo = c;
            //adicionar componente
            trabajo.Adicionar(new Componente <string>("root11"));
            trabajo.Adicionar(new Componente <string>("root12"));
            //mostrar

            Console.WriteLine(arbol.Mostrar(0));
        }
        public IComponente <T> Buscar(T _elemento)
        {
            //Si somos quien se busca nos regresamos
            if (Nombre.Equals(_elemento))
            {
                return(this);
            }
            IComponente <T> encontrado = null;

            //recorremos la lista y buscamos en nuestros elementos
            foreach (IComponente <T> elemento in elementos)
            {
                encontrado = elemento.Buscar(_elemento);
                if (!(encontrado is null))
                {
                    break;
                }
            }
            return(encontrado);
        }
Example #33
0
        public void Test1()
        {
            IComponente <string> arbol   = new Compuesto <string>("root");
            IComponente <string> trabajo = arbol;

            //adicionar componente
            trabajo.Adicionar(new Componente <string>("root1"));
            trabajo.Adicionar(new Componente <string>("root2"));
            //adicionar compuesto
            IComponente <string> c = new Compuesto <string>("root1");

            trabajo.Adicionar(c);
            trabajo = c;
            //adicionar componente
            trabajo.Adicionar(new Componente <string>("root11"));
            trabajo.Adicionar(new Componente <string>("root12"));
            //mostrar
            Console.WriteLine(arbol.Mostrar(0));
            Assert.Pass();
        }
Example #34
0
        public IComponente <T> Buscar(T pElemento)
        {
            if (Nombre.Equals(pElemento))
            {
                return(this);
            }

            IComponente <T> encontrado = null;

            foreach (IComponente <T> elemento in elementos)
            {
                encontrado = elemento.Buscar(pElemento);
                if (encontrado != null)
                {
                    break;
                }
            }

            return(encontrado);
        }
Example #35
0
        public void AddComponente(IComponente Componente)
        {
            if (Componente == null)
            {
                return;
            }

            Item item = (Item)Componente;

            if (item.Peso + CapacidadeAtual > CapacidadeMaxima)
            {
                throw new Exception("Capacidade da mochila excedida");
            }

            if (!Componentes.Contains(Componente))
            {
                CapacidadeAtual = CapacidadeAtual + item.Peso;
                UtilidadeAtual  = UtilidadeAtual + item.Utilidade;
                Componentes.Add(item);
            }
        }
Example #36
0
        public IObservable <IComponente[]> ObtemObservavelDeComponentes()
        {
            IObservable <IComponente[]> observable;

            var path = "cadastro/materiais/componentes";

            HttpResponseMessage response = client.GetAsync(path).Result;

            if (response.IsSuccessStatusCode)
            {
                var componentes = response.Content.ReadAsAsync <ComponenteDTO[]>();

                observable = componentes.ToObservable();
            }
            else
            {
                var empty = new IComponente[] { };

                observable = Observable.Return(empty);
            }

            return(observable);
        }
Example #37
0
        static void Main(string[] args)
        {
            //llamada al metodo MostarTodosLosDatos de la clase utilidades
            Utilidades.MostrarTodosLosDatos();
            //instancia de un objeto tipo string
            string resultado;

            //llamada al metodo EsperarParaTerminar de la clase Log
            Log.EsperarParaTerminar("1) Presione ENTER para crear un nuevo objeto remoto...");
            //Instancia e inicializacion de un objeto tipo ComponenteCAO
            IComponente miComponente = ObtenerComponente();

            //llamada al metodo Imprimir donde se muestra un mensaje, indica si es un objeto proxy real o transparente
            Log.Imprimir("Se creo miComponente. Es Proxy? {0}", (RemotingServices.IsTransparentProxy(miComponente) ? "SI" : "NO"));
            //llamada al metodo EsperarParaTerminar de la clase Log
            Log.EsperarParaTerminar("2) Presione ENTER para probar el objeto remoto...");
            //invocacion del metodo PrimeraLlamada() de la clase ComponenteCAO el cual se guarda en la variable resultado tipo string
            resultado = miComponente.LlamadaUno();
            Log.Imprimir("miComponente.LlamadaUno() retorno: {0}", resultado);
            //llamada al metodo EsperarParaTerminar de la clase Log
            Log.EsperarParaTerminar("Presione ENTER para terminar...");
            //Evita el cierre de la consola
            Console.ReadLine();
        }
Example #38
0
 public void Remover(IComponente _IComponente)
 {
     this.lstHijos.Remove(_IComponente);
 }
Example #39
0
 public void Agregar(IComponente _IComponente)
 {
     this.lstHijos.Add(_IComponente);
 }
Example #40
0
 public void RemoveComponente(IComponente Componente)
 {
     throw new NotImplementedException();
 }