public void RemoveComponente(IComponente Componente)
{
if (Componentes.Contains(Componente))
{
Componentes.Remove(Componente);
}
}
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);
}
}
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();
}
public void AddComponente(IComponente Componente)
{
if (!Componentes.Contains(Componente))
{
Componentes.Add(Componente);
}
}
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);
}
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));
}
}
}
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);
}
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;
}
}
public void RemoveComponente(IComponente Componente)
{
if (Componente == null)
{
return;
}
if (Componentes.Contains(Componente))
{
Componentes.Remove(Componente);
}
}
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
}
public void AddComponente(IComponente Componente)
{
if (Componente == null)
{
return;
}
if (!Componentes.Contains(Componente))
{
Componentes.Add(Componente);
kmPercorridos += (float)Componente.Valor;
}
}
public void RemoveComponente(IComponente Componente)
{
if (Componente == null)
return;
Aresta aresta = (Aresta)Componente;
if (Componentes.Contains(Componente))
{
DistanciaTotal = DistanciaTotal - aresta.Distancia;
Componentes.Remove(aresta);
}
}
public void AddComponente(IComponente Componente)
{
if (Componente == null)
return;
Aresta aresta = (Aresta)Componente;
if (!Componentes.Contains(Componente))
{
DistanciaTotal = DistanciaTotal + aresta.Distancia;
Componentes.Add(aresta);
}
}
public void AddComponente(IComponente Componente)
{
if (Componente == null)
{
return;
}
Acesso aresta = (Acesso)Componente;
if (!destPossiveis.Contains(Componente))
{
destPossiveis.Add(aresta);
}
}
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);
}
//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;
}
}
}
public void AddComponente(IComponente Componente)
{
if (Componente == null)
{
return;
}
Aresta aresta = (Aresta)Componente;
if (!Componentes.Contains(Componente))
{
DistanciaTotal = DistanciaTotal + aresta.Distancia;
Componentes.Add(aresta);
}
}
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);
}
}
public void RemoveComponente(IComponente Componente)
{
if (Componente == null)
{
return;
}
Aresta aresta = (Aresta)Componente;
if (Componentes.Contains(Componente))
{
DistanciaTotal = DistanciaTotal - aresta.Distancia;
Componentes.Remove(aresta);
}
}
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);
}
}
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);
}
}
//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);
}
}
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);
}
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();
}
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);
}
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);
}
}
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);
}
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();
}
public void Remover(IComponente _IComponente)
{
this.lstHijos.Remove(_IComponente);
}
public void Agregar(IComponente _IComponente)
{
this.lstHijos.Add(_IComponente);
}
public void RemoveComponente(IComponente Componente)
{
throw new NotImplementedException();
}
