/// <summary>
        /// Obtiene la configuración desde el archivo XML.
        /// </summary>
        /// <remarks>
        ///     Registro de versiones:
        ///
        ///         1.0 08/10/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
        /// </remarks>
        /// <param name="claseDAO">Tipo de la clase de un DAO.</param>
        /// <returns></returns>
        public static DynamicQueryRoot ObtenerConfiguracion(Type claseDAO)
        {
            IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();
            string          DynamicQueryConfigPath = FrameworkConfigurationManager.ObtenerRutaArchivoConfiguracion(CARPETA_DYNAMIC_QUERIES);

            string ruta  = monitor.ObtenerRutaArchivo(DynamicQueryConfigPath, claseDAO.FullName + ".dbq.xml");
            string clave = null;

            if (monitor.Existe(ruta))
            {
                DynamicQueryConfigPath = ruta;
                clave = claseDAO.FullName;
            }
            else
            {
                DynamicQueryConfigPath = monitor.ObtenerRutaArchivoExistente(DynamicQueryConfigPath, claseDAO.Name + ".dbq.xml");
                clave = claseDAO.Name;
            }

            if ((!ArchivosConsultas.ContainsKey(clave)) || (monitor.FueModificado(ArchivosConsultas[clave].FechaUltimaModificacion, DynamicQueryConfigPath)))
            {
                XmlSerializer    serializer = new XmlSerializer(typeof(DynamicQueryRoot));
                FileStream       file       = null;
                DynamicQueryRoot retorno    = null;

                try
                {
                    file    = new FileStream(DynamicQueryConfigPath, FileMode.Open);
                    retorno = serializer.Deserialize(file) as DynamicQueryRoot;
                }
                catch (Exception e)
                {
                    throw e;
                }
                finally
                {
                    if (file != null)
                    {
                        file.Close();
                    }
                }

                if (retorno != null)
                {
                    Configuracion = retorno;
                }

                if (!ArchivosConsultas.ContainsKey(clave))
                {
                    ArchivosConsultas.Add(clave, retorno);
                }

                ArchivosConsultas[clave].FechaUltimaModificacion = monitor.ObtenerFechaUltimaModificacion(DynamicQueryConfigPath);
            }

            return(Configuracion);
        }
        /// <summary>
        /// Carga la configuración desde el archivo XML a memoria. De paso lo valida.
        /// </summary>
        /// <remarks>
        ///     Registro de versiones:
        ///
        ///         1.0 02/03/2015 Marcos Abraham Hernández Bravo (Ada Ltda.): versión inicial.
        /// </remarks>
        /// <exception cref="Ada.Framework.Util.FileMonitor.Exceptions.ArchivoNoEncontradoException">Lanzado al no encontrar el archivo XML o su esquema.</exception>
        /// <exception cref="Ada.Framework.Data.DBConnector.Connections.Exceptions.ConfiguracionBaseDatosException">Lanzado al encontrar al archivo de configuración inválido.</exception>
        public void CargarConfiguracion(bool comprobarFechaModificacion = false)
        {
            IMonitorArchivo monitor = MonitorArchivoFactory.ObtenerArchivo();

            if (monitor.Existe(DataBaseConnectionsPath))
            {
                if (!fechaUltimaModificacionArchivo.HasValue)
                {
                    fechaUltimaModificacionArchivo = new DateTime(1, 1, 1);
                }

                if (!comprobarFechaModificacion || (Conexiones == null || Conexiones.Count == 0 || monitor.FueModificado(fechaUltimaModificacionArchivo.Value, DataBaseConnectionsPath)))
                {
                    Conexiones = new List <ConexionTO>();
                    Conectores = new List <ConectorTO>();

                    XmlDocument doc;
                    XmlReader   reader = null;
                    try
                    {
                        CargarXML(out doc, out reader);

                        foreach (XmlNode appender in doc.DocumentElement.ChildNodes[1].ChildNodes)
                        {
                            if (appender is XmlElement)
                            {
                                XmlElement element = (appender as XmlElement);

                                Conectores.Add(new ConectorTO()
                                {
                                    Name         = element.GetAttribute("Name"),
                                    Instance     = element.GetAttribute("Instance"),
                                    AssemblyName = element.GetAttribute("AssemblyName"),
                                    AssemblyPath = element.GetAttribute("AssemblyPath")
                                });
                            }
                        }

                        foreach (XmlNode elemento in doc.DocumentElement.ChildNodes[0].ChildNodes)
                        {
                            if (elemento is XmlElement)
                            {
                                XmlElement element = (elemento as XmlElement);

                                ConectorTO conector = Conectores.Where(c => c.Name == element.GetAttribute("Type")).First();

                                Conexiones.Add(new ConexionTO()
                                {
                                    ConnectionString = element.GetAttribute("ConnectionString"),
                                    Name             = element.GetAttribute("Name"),
                                    Instance         = conector.Instance,
                                    Type             = element.GetAttribute("Type"),
                                    AssemblyName     = conector.AssemblyName,
                                    AssemblyPath     = conector.AssemblyPath
                                });
                            }
                        }
                    }
                    finally
                    {
                        if (reader != null)
                        {
                            reader.Close();
                        }
                    }
                }

                fechaUltimaModificacionArchivo = monitor.ObtenerFechaUltimaModificacion(DataBaseConnectionsPath);
            }
            else
            {
                throw new ArchivoNoEncontradoException("¡No se ha encontrado el archivo de conexiones a bases de datos!", DataBaseConnectionsPath);
            }
        }