/// <summary>
        /// Crea  una relación entre los nodos origen y destino de acuerdo al arco mandado como parámetro.
        ///
        /// </summary>
        /// <param name="arco">El arco que representa la relación, si el arco es nulo entonces es una relación
        /// no especificada entre 2 nodos, por ejemplo, entre el nodo raíz y el primer hijo</param>
        /// <param name="nodoOrigen">Origen de la relación</param>
        /// <param name="nodoDestino">Destino de la relación</param>
        /// <param name="rol">Rol destino del arco, en caso de que sea importado de otro linkbase rol (caso dimensional)</param>
        private void AgregarArco(Arco arco, NodoLinkbase nodoOrigen, NodoLinkbase nodoDestino, string rol = "")
        {
            //Relación entrante del destino
            var conectorEntrante = new ConectorLinkbase(arco, nodoOrigen);

            nodoDestino.ConectoresEntrantes.Add(conectorEntrante);
            //Relación saliente del origen
            var conectorSaliente = new ConectorLinkbase(arco, nodoDestino);

            if (!String.IsNullOrEmpty(rol))
            {
                conectorSaliente.RolOrigen = rol;
            }
            nodoOrigen.ConectoresSalientes.Add(conectorSaliente);
        }
        /// <summary>
        /// Importa los arcos que han sido recuperado de otro role y los agrega a las relaciones del árbol únicamente a partir
        /// del conector inicial enviado como parámetro.
        /// Todos los arcos generan nuevos nodos para no interferir con las relaciones ya existentes
        /// </summary>
        /// <param name="conector">Conector inicial</param>
        /// <param name="arcosConsecutivos">Arcos a crear</param>
        public void ImportarArcos(ConectorLinkbase conector, IDictionary <Arco, String> arcosConsecutivos)
        {
            var nodosCreados = new List <NodoLinkbase>();

            nodosCreados.Add(conector.NodoSiguiente);
            //Si el nodo siguiente del conector no está en el inventario, agregar
            if (!IndicePorId.Values.Contains(conector.NodoSiguiente))
            {
                if (IndicePorId.ContainsKey(conector.NodoSiguiente.Elemento.Id))
                {
                    String id = "E" + Guid.NewGuid().ToString();
                    IndicePorId.Add(conector.NodoSiguiente.Elemento.Id + "_" + id, conector.NodoSiguiente);
                }
            }
            var arcosPendientes = arcosConsecutivos.ToDictionary(keyVal => keyVal.Key, keyVal => keyVal.Value);

            while (arcosPendientes.Count > 0)
            {
                Arco arcoUsado = null;
                //buscar en los arcos pendientes el enlace entre el nodo siguiente y el arco
                foreach (var arcoActual in arcosPendientes)
                {
                    //para este arco, buscar que nodo le corresponde
                    foreach (var elementoDesde in arcoActual.Key.ElementoDesde)
                    {
                        var nodoOrigenArco = nodosCreados.FirstOrDefault(x => x.Elemento == elementoDesde.Destino);
                        if (nodoOrigenArco != null)
                        {
                            //Nodo localizado, crear arco
                            foreach (var elementoHacia in arcoActual.Key.ElementoHacia)
                            {
                                NodoLinkbase nodoSiguiente = new NodoLinkbase();
                                nodosCreados.Add(nodoSiguiente);
                                nodoSiguiente.Elemento            = elementoHacia.Destino;
                                nodoSiguiente.ConectoresEntrantes = new List <ConectorLinkbase>();
                                nodoSiguiente.ConectoresSalientes = new List <ConectorLinkbase>();
                                //Si el nodo creado corresponde a un concepto entonces agregarlo al índice con su ID, de lo contrario, generar uno temporal
                                if (elementoHacia.Destino is ConceptTuple || elementoHacia.Destino is ConceptItem)
                                {
                                    if (IndicePorId.ContainsKey(elementoHacia.Destino.Id))
                                    {
                                        String id = "E" + Guid.NewGuid().ToString();
                                        IndicePorId.Add(elementoHacia.Destino.Id + "_" + id, nodoSiguiente);
                                    }
                                    else
                                    {
                                        IndicePorId.Add(elementoHacia.Destino.Id, nodoSiguiente);
                                    }
                                }
                                else
                                {
                                    String id = "E" + Guid.NewGuid().ToString();
                                    nodoSiguiente.Elemento.Id = id;
                                    IndicePorId.Add(id, nodoSiguiente);
                                }
                                AgregarArco(arcoActual.Key, nodoOrigenArco, nodoSiguiente, arcoActual.Value);
                                arcoUsado = arcoActual.Key;
                            }
                        }
                    }
                    if (arcoUsado != null)
                    {
                        break;
                    }
                }
                if (arcoUsado != null)
                {
                    arcosPendientes.Remove(arcoUsado);
                }
            }
            //Verificar los nodos que no tienen elementos entrantes, apuntarlos al raíz
            VerificarElementosHuerfanos();
        }