Llenar el TreeVew de ASP.NET con tabla Base de Datos

La tabla en SQL Server  consta de 3 columnas principales
idNodo es la PK
Nodo  es el  texto o  descripción del nodo
idNodoPadre es el  nodo  del que se desprende el nodo hijo.

 protected void Page_Load(object sender, EventArgs e)
        {
            if (!Page.IsPostBack)
            {
                int total = Convert.ToInt32(u.ObtenValor("Select MAX(idNodo) from TreeView"));
                for (int i = 0; i < total; i++)
                {
                    string sql = "Select idNodo,Nodo from TablaTreeviews where idNodoPadre=" + i + " order by idNodo";
                    SqlDataReader r;
                    r = con.Reg(sql);
                    while (r.Read())
                    {
                        if (i == 0)
                        {
                            TreeView.Nodes.Add(new TreeNode(r["Nodo"].ToString().Trim(), r["idNodo"].ToString().Trim()));
                        }
                        else
                        {
                            TreeNode nodo = BuscarNodo(TreeView.Nodes, i.ToString());
                            nodo.ChildNodes.Add(new TreeNode(r["Nodo"].ToString().Trim(), r["idNodo"].ToString().Trim()));
                        }
                    }
                }
            }
        }

        TreeNode BuscarNodo(TreeNodeCollection collec, string value)
        {
            TreeNode nodo = new TreeNode();
            for (int i = 0; i < collec.Count; i++)
            {
                if (collec[i].Value.Equals(value))
                    return nodo = collec[i];
                else
                {
                    if (collec[i].ChildNodes.Count>0)
                    nodo = BuscarNodo(collec[i].ChildNodes, value);
                    if (nodo.Value.Equals(value)) return nodo;
                }
            }
            return nodo;
        }

Encuentra la clase conexión aquí

Clase Conexion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.SqlClient;
using System.Runtime.InteropServices;
using System.Collections;
using System.IO;
using System.Data;
using System.Web.UI.WebControls;
using System.Configuration;

namespace SistemaExpediente.Clases
{
    public class Conexion
    {
        public SqlConnection CON;
        private SqlCommand Comando = new SqlCommand();

        public Conexion()
        {


//string cnx = "Data Source=NOMBRESERVIDOR;Initial Catalog=NOMBREDEMIBASEDEDATOS;Persist Security Info=True;User ID=sa;Password=MICONTRASENA";

ConnectionStringSettings settings = ConfigurationManager.ConnectionStrings["DB_CHSJConnectionString"];

string cnx =settings.ConnectionString;

CON = new SqlConnection(cnx);        }

        ~Conexion()
        {
            try { CON.Close(); }
            catch (Exception e) { Console.WriteLine(e.Message); }
            CON.Dispose();
        }

        public void cerrar()
        { CON.Close(); }

        public int Accion(string Cad)
        {
            int x;
            try
            {
                CON.Open();
                Comando.Connection = CON;
                Comando.CommandText = Cad;
                x = Comando.ExecuteNonQuery();
                cerrar();
                return x;
            }
            catch
            {
                cerrar();
                CON.Open();
                Comando.Connection = CON;
                Comando.CommandText = Cad;
                x = Comando.ExecuteNonQuery();
                cerrar();
                return x;
            }
        }

     
        public DataTable GetSelect(string commandText)
        {
            DataTable TABLA = new DataTable("Tmp");
            try
            {
                int i;
                CON.Close();//movi
                CON.Open();
                SqlCommand CMD = new SqlCommand(commandText, CON);
                SqlDataReader REG = CMD.ExecuteReader();
                for (i = 0; i < REG.FieldCount; i++)
                {
                    TABLA.Columns.Add(REG.GetName(i), REG.GetFieldType(i));
                }
                while (REG.Read())
                {
                    DataRow ROWS = TABLA.NewRow();
                    for (i = 0; i < REG.FieldCount; i++)
                    {
                        ROWS.SetField(i, REG[i]);
                    }
                    TABLA.Rows.Add(ROWS);
                }
                REG.Close();
                CON.Close();
                return TABLA;
            }
            catch (SqlException Ex)
            {

            }
            return TABLA;
        }

     

        public SqlDataReader Reg(string Cad)
        {
            try
            {
                cerrar();
            }
            finally
            {
                try
                {
                    CON.Open();
                    Comando.CommandText = Cad;
                    Comando.Connection = CON;
                }
                catch (Exception Er)
                {

                }
            }
            try { return Comando.ExecuteReader(); }
            catch { return null; }
        }

    }
}

Guardar Tablas en Memoria caché y utilizarlas en todas las páginas

A menudo, una aplicación puede aumentar el rendimiento si almacena en memoria los datos a los que se tiene acceso con más frecuencia y cuya creación requiere un tiempo de procesamiento significativo. Por ejemplo, si su aplicación procesa grandes cantidades de datos utilizando una lógica compleja y, a continuación, los devuelve en un formato de informe que es consultado frecuentemente por los usuarios, resulta eficiente evitar la creación de dicho informe cada vez que un usuario lo solicita. De manera similar, si su aplicación incluye una página que procesa datos complejos pero que no se actualiza frecuentemente, no resulta eficiente que el servidor vuelva a crear dicha página en cada solicitud.
Cita de Microsoft
Este es un ejemplo de cómo  guardo  la configuración de mi  sitio web,  en  este caso  se trata de una tabla de  mi base de datos que  guarda los campos que son obligatorios por cada página. Existe una interfaz donde el usuario  puede cambiar esta configuración y se actualiza la base de datos y la tabla en la cache. La tabla de cargará una sola vez cuando se inicie la aplicación, se actualizará cuando  haya cambios en la base de datos (Desde la aplicación,  aun NO sé como  hacerlo con  dependencia de SQL). y se destruirá cuando de la memoria cuando  pase cierto  tiempo, o  se cierre o  reinicie la aplicación.

Expiración

Además de utilizar el barrido, ASP.NET quita automáticamente los elementos de la memoria caché cuando expiran. Al agregar un elemento a la memoria caché se puede establecer su expiración de acuerdo con la tabla siguiente.

Tipo de expiración	Descripción
Fecha de expiración variable	Especifica el intervalo de tiempo que debe transcurrir desde el último acceso al elemento para que éste expire. Por ejemplo, puede establecer que un elemento expire 20 minutos después del último acceso en caché.
Expiración absoluta	Especifica que un elemento expira en un momento determinado, sin tener en cuenta la frecuencia con que se ha tenido acceso al mismo. Por ejemplo, puede establecer que un elemento expire a las 6:00 p.m. o al cabo de cuatro horas.

Ejemplos de código de los dos tipos de expiración

Cache.Insert("Cache_ConfiguracionPorPagina", tablaAE, null, System.Web.Caching.Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(1)); //Sólamente se borra si  pasó el tiempo indicado y no  se accedió a ella

 Cache.Insert("Cache_ConfiguracionPorPaginaSE", tablaSE, null,DateTime.Now.AddMinutes(1),System.Web.Caching.Cache.NoSlidingExpiration); // Se estingue en el tiempo indicado,  se acceda o no a la tabla en cache

Creé la clase Utilidades.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using SistemaExpediente.Clases;
using System.Data.SqlClient;
using System.Collections;
using System.IO;
using System.Data;
using System.Web.UI.WebControls;
using System.Web.Caching;

namespace SistemaExpediente.Clases
{
    //Agregue  la herencia de : System.Web.UI.Page línea para usar la cache
    public class Utilidades //: System.Web.UI.Page
    {
        Conexion con = new Conexion();
        string error = "", sql = "", a = "";
        SqlDataReader r;

        /*********CACHE***********/
        //Si no  existe la tabla la crea, si  existe la reemplaza
        /// <summary>
        /// Inicializa las tablas que se guardarán en  la memoria caché
        /// </summary>
        public void CreateAllTablesCache()
        {
            DataTable tablaAE = new DataTable(); //Absolute Expiration
            DataTable tSN = new DataTable();
            tablaAE = con.GetSelect("SELECT *  FROM dbo.View_TablaValidaciones");
            tSN = con.GetSelect("Select * from ConfiguracionSiNo");
            System.Web.HttpContext.Current.Cache.Insert("Cache_ConfiguracionPorPagina", tablaAE, null, Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(1)); //Sólamente se borra si  pasó el tiempo indicado y no  se accedió a ella
            System.Web.HttpContext.Current.Cache.Insert("Cache_ConfiguracionSiNo", tSN, null, Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(1));  //Sólamente se borra si  pasó el tiempo indicado y no  se accedió a ella
            //Cache.Insert("Cache_ConfiguracionPorPaginaSE", tablaSE, null, DateTime.Now.AddMinutes(20), Cache.NoSlidingExpiration); // Se estingue en el tiempo indicado,  se acceda o no a la tabla en cache
        }
        /// <summary>
        /// Si  una tabla caducó  de la memoria caché,  se vuelve a crear con  este método
        /// </summary>
        /// <param name="key">El nombre de la tabla a crear</param>
        /// <returns>Regresa un objeto  DataTable</returns>
        public DataTable CreateTableCache(string key)
        {
            DataTable table = new DataTable(); //Absolute Expiration
            if (key != "")
            {
                if (key == "Cache_ConfiguracionPorPagina") table = con.GetSelect("SELECT *  FROM dbo.View_TablaValidaciones");
                if (key == "Cache_ConfiguracionSiNo") table = con.GetSelect("Select * from ConfiguracionSiNo");
            }
            if(table.Rows.Count>0)
            System.Web.HttpContext.Current.Cache.Insert(key, table, null, Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(1)); //Sólamente se borra si  pasó el tiempo indicado y no  se accedió a ella    
            return table;
        }

        public void RemoveALLTablesCache()
        {
            if (System.Web.HttpContext.Current != null)
            {
                System.Web.HttpContext.Current.Cache.Remove("Cache_ConfiguracionPorPagina");
                System.Web.HttpContext.Current.Cache.Remove("Cache_ConfiguracionSiNo");
            }
        }
        /// <summary>
        /// Para obtener valores escalares de una DataTable en la memoria cache
        /// </summary>
        /// <param name="table">Nombre de la tabla</param>
        /// <param name="filtro">Parámetros utilizados en el 'where' del select al DataTable para obtener  el  valor</param>
        /// <param name="valor">El valor a regresar, de la fila obtenida </param>
        /// <returns>Un string con el  valor</returns>
        public string TableValue(DataTable table,string [] filtro,string valor)
        {
            string f = "";
            for (int i = 0; i < filtro.Length; i++) f += filtro[i] + " AND "; 
            f=f.Substring(0,f.Length-5);
            return table.Select(f)[0][valor].ToString();
        }
        
        /// <summary>
        /// Validación de campos que son iguales en todo el sistema 
        /// </summary>
        /// <param name="t">DataTable a buscar</param>
        /// <param name="c">Valor de la columna campo</param>
        /// <param name="ctrol">Regresa el control que contiene el error</param>
        /// <param name="conte">Regresa el id del  Div HTML  que contiene el error</param>
        /// <param name="msjVal">Regresa un mensaje de validación a mostrar en una ventana de mensajes para el usuario</param>
        /// <returns>Regresa true si el campo es obligatorio y false si no lo es</returns>
        public bool VlGn(DataTable t, string c, ref string ctrol,ref string conte,ref string msjVal)
        {
            ctrol = TableValue(t, new string[] { "Pagina='TODAS'", "Campo='" + c + "'" }, "idValidacion").ToString().Trim();
            conte = TableValue(t, new string[] { "Pagina='TODAS'", "Campo='" + c + "'" }, "Contenedor").ToString().Trim();
            msjVal = TableValue(t, new string[] { "Pagina='TODAS'", "Campo='" + c + "'" }, "Mensaje").ToString().Trim();
            return Convert.ToBoolean(TableValue(t, new string[] { "Pagina='TODAS'", "Campo='" + c + "'" }, "Caracter"));
        }
       /// <summary>
        /// Regresa id de el  control de la validación
       /// </summary>
       /// <param name="t">DataTable a buscar</param>
       /// <param name="c">Valor de la columna campo</param>
       /// <param name="ctrol">Regresa el control que contiene el error</param>
        /// <returns>Regresa id de el  control de la validación</returns>
        public string idVlGn(DataTable t, string c,ref bool ctrol)
        {
            return TableValue(t, new string[] { "Pagina='TODAS'", "Campo='" + c + "'" },c).ToString().Trim();
        }

        //Campos necesarios para la validación
        /// <summary>
        /// Metodo para realizar la validación de campos.Recibe parámetros referenciados con el control, el DIV contenedor y el mensaje de validación
        /// </summary>
        /// <param name="t">DataTable a buscar</param>
        /// <param name="pagina"></param>
        /// <param name="c">Valor de la columna campo</param>
        /// <param name="ctrol">Regresa el control que contiene el error</param>
        /// <param name="conte">Regresa el id del  Div HTML  que contiene el error</param>
        /// <param name="msjVal">Regresa un mensaje de validación a mostrar en una ventana de mensajes para el usuario</param>
        /// <returns>Regresa true si el campo es obligatorio y  false si no lo es</returns>
        public bool Vl(DataTable t, string pagina, string c, ref string ctrol, ref string conte,ref string msjVal)
        {
            ctrol = TableValue(t, new string[] { "Pagina='" + pagina + "'", "Campo='" + c + "'" }, "idValidacion").ToString().Trim();
            conte = TableValue(t, new string[] { "Pagina='" + pagina + "'", "Campo='" + c + "'" }, "Contenedor").ToString().Trim();
            msjVal = TableValue(t, new string[] { "Pagina='" + pagina + "'", "Campo='" + c + "'" }, "Mensaje").ToString().Trim();
            return Convert.ToBoolean(TableValue(t, new string[] { "Pagina='"+pagina+"'", "Campo='" + c + "'" }, "Caracter"));
        }


        //Regresa la tabla obtenida de la cache 
        /// <summary>
        /// Regresa la tabla obtenida de la cache, si la tabla no existe la agrega a la cache llamando al submétodo CreateTableCache
        /// </summary>
        /// <param name="key">Nombre de la tabla</param>
        /// <returns>Tabla de la memoria caché</returns>
        public DataTable GetTableCache(string key)
        {
            DataTable tabla = new DataTable();
            tabla = (DataTable)System.Web.HttpContext.Current.Cache.Get(key);
            if (tabla == null)  tabla = CreateTableCache(key);
            return tabla;
        }

    }
}

Además inicializo las tablas al comenzar la aplicación en mi  archivo  Global.asax

        void Application_Start(object sender, EventArgs e)
        {
            u.CreateAllTablesCache();
        }

        void Application_End(object sender, EventArgs e)
        {
            u.RemoveALLTablesCache();
        }
Y la utilizo en todas las páginas de este modo.

/************VALIDACION***************/

        string ctrlVal = "", conte = "",msjVal="", p = "NotaIngresoHospital";
 DataTable t =u.GetTableCache("Cache_ConfiguracionPorPagina");
else if (u.Vl(t, p, "ExploracionFisica", ref ctrlVal, ref conte, ref msjVal) && txtExplFisi.Text.Equals("")) return msjVal;

Si  el campo 'ExploracionFisica' de la página 'NotaIngresoHospital' es positivo Y el  textbox  txtExplFisi  se encuentra en  blanco, regresa el mensaje de error y los valores de los controles, que vienen por referencia  y con  estos valores hago mis procedimientos con JavaScript.

Puedes buscar la clase conexión en este mismo blog

Ver dependencia de Objetos en SQL

Si  cambiaste el nombre de una tabla procedimiento almaceno, vista etc, puedes ver la dependencia de objetos con la siguiente query.


Select SO.object_id,referenced_id,referencing_id,referenced_entity_name,name,type_desc
from sys.sql_expression_dependencies  sqldep
INNER JOIN sys.objects SO on SO.object_id=sqldep.referencing_id
where sqldep.referenced_entity_name ='ExpNotaIngresoHospital'


Si la columa referenced_id aparece NULL  la referencia está rota, osea debes ir a el script a cambiar el nombre del objeto


Por ejemplo:
Eliminé la tabla
ExpExpedienteGeneral que se encuentra en el script  de la vista  view_ExpedienteGeneral.
Si  ejecuto el script para buscar referencias rotas:

Select SO.object_id,referenced_id,referencing_id,referenced_entity_name,name,type_desc
from sys.sql_expression_dependencies  sqldep
INNER JOIN sys.objects SO on SO.object_id=sqldep.referencing_id
where  referenced_id is null

Aparece en una de las referencias la tabla ExpExpedienteGeneral. Esto  también puede pasar si  cambié el  nombre de un objeto o una columna.