Mostrando entradas con la etiqueta C#. Mostrar todas las entradas
Mostrando entradas con la etiqueta C#. Mostrar todas las entradas

martes, 11 de agosto de 2009

Cargar los elementos de un Control DropDownList concatenando los valores de varios Campos de una Tabla de una Base de Datos SQL Server en ASP.Net

Para que en cada elemento de un Control DropDownList (combo) aparezcan concatenados los valores de distintos Campos de una Tabla definida previamente en una Base de datos SQL Server, será necesario realizar una doble Consulta sobre dicha Base de Datos.

Una primera Consulta para cargar el Control tomando como referencia el Campo establecido en la propiedad "DataTextField". Posteriormente, se recorrerán todos los elementos del Combo ejecutando una segunda Consulta para cada uno de estos elementos, de manera que podamos obtener la fila correspondiente y guardar sólo los valores de los campos que necesitamos.

Para ilustrar el ejemplo creamos una Clase Cliente:


   1:  using System;
   2:  using System.Collections.Generic;
   3:  using System.Linq;
   4:  using System.Web;
   5:  using System.Data;
   6:  using System.Data.SqlClient;
   7:   
   8:  namespace BlogSalvatrosh
   9:  {
  10:      public class Cliente
  11:      {
  12:          public Cliente()
  13:          {
  14:          }
  15:   
  16:          private string campoCodigo = string.Empty;
  17:          private string campoNif = string.Empty;
  18:          private string campoNombre = string.Empty;
  19:   
  20:          public string Codigo
  21:          {
  22:              get { return campoCodigo; }
  23:              set { campoCodigo = value; }
  24:          }
  25:   
  26:          public string Nif
  27:          {
  28:              get { return campoNif; }
  29:              set { campoNif = value; }
  30:          }
  31:   
  32:          public string Nombre
  33:          {
  34:              get { return campoNombre; }
  35:              set { campoNombre = value; }
  36:          }
  37:   
  38:   
  39:          /// Ejecuta una consulta SQL (que recibe como parámetro) sobre la Base de Datos devolviendo el resultado de la consulta en un tipo "DataView"
  40:          public DataView CargarLista(string consulta)
  41:          {
  42:              SqlDataAdapter sqlDa = null;
  43:              DataTable dt = new DataTable();
  44:              SqlConnection conexion = new SqlConnection("CadenaDeConexion");
  45:              SqlCommand sqlCmd = new SqlCommand(consulta, conexion);   //Se crea un comando SQL con la consulta y el puente de conexión
  46:   
  47:              sqlDa = new SqlDataAdapter(sqlCmd);
  48:   
  49:              try
                   {
  50:                  conexion.Open();    //Se abre la conexión con la Base de Datos
  51:                  sqlDa.Fill(dt);   //Ejecuta la consulta y la adapta a un "DataTable" definido como "dt"
  52:                  return dt.DefaultView;  //Convierte la consulta en una vista (en un tipo "DataView")
  53:              }
  54:              catch (Exception)
  55:              {
  56:                  return null;
  57:              }
  58:              finally
  59:              {//Se cierra la conexión
  60:                  if (conexion.State == ConnectionState.Open)
  61:                      conexion.Close();
  62:              }
  63:          }
  64:   
  65:   
  66:          /// Construimos un Diccionario de datos con los campos y valores que necesitamos mostrar en el Combo
  67:          public Dictionary<string, string> CargarDiccionario(Dictionary<string, string> miDic)
  68:          {
  69:              //Supongamos que necesitamos guardar las propiedades "Nif" y "Nombre" del Objeto que estamos construyendo
  70:              miDic.Add("Nif", this.Nif);
  71:              miDic.Add("Nombre", this.Nombre);
  72:   
  73:              return miDic;
  74:          }
  75:      }
  76:  }


Y un Control de Usuario muy sencillo denominado "ComboCliente.ascx" que solo posee un Control DropDownList:


   1:  <%@ Control Language="C#" AutoEventWireup="true" CodeBehind="ComboCliente.ascx.cs" Inherits="BlogSalvatrosh.ComboCliente" %>
   2:  <asp:DropDownList ID="DropDownListClientes" runat="server"></asp:DropDownList>


En la Clase "ComboCliente.ascx.cs" asociada a este Control de Usuario insertamos el método que va cargando el Combo, al cual le podemos "llamar", para simplificar, desde el propio método Controlador del evento "Load()":


   1:  using System;
   2:  using System.Collections.Generic;
   3:  using System.Linq;
   4:  using System.Web;
   5:  using System.Web.UI;
   6:  using System.Web.UI.WebControls;
   7:  using System.Data;
   8:   
   9:  namespace BlogSalvatrosh
  10:  {
  11:      public partial class ComboCliente : System.Web.UI.UserControl
  12:      {
  13:   
  14:          protected void Page_Load(object sender, EventArgs e)
  15:          {
  16:              CargarComboConcatenandoCampos();
  17:          }
  18:   
  19:          /// Carga el DropDownList (Combo) concatenando varios campos de alguna tabla de la Base de Datos
  20:          public void CargarComboConcatenandoCampos()
  21:          {
  22:              Cliente clt = new Cliente();
  23:   
  24:              DataView dv = (DataView)clt.CargarLista("Select * from NombreTabla");//Se llama al método "CargarLista(string)" de la Clase Cliente para que realice la consulta especificada
  25:   
  26:              if (dv != null)  //Siempre que la resultado de la consulta no sea null:
  27:              {
  28:                  this.DropDownListClientes.DataSource = dv;  //Se indica que debe tomar como origen de datos el DataView "dv"
  29:                  this.DropDownListClientes.DataTextField = "Codigo"; //Se indica que debe tomar como referencia de contenido el campo "Codigo"
  30:                  this.DropDownListClientes.DataValueField = "Codigo";    //Se indica que debe tomar como valor el valor del campo "Codigo"
  31:   
  32:                  try
  33:                  {
  34:                      this.DropDownListClientes.DataBind();  //Se realiza el enlace con el origen de datos
  35:                  }
  36:                  catch (ArgumentOutOfRangeException)
  37:                  {
  38:                  }
  39:              }
  40:   
  41:              //A continuación recorremos los elementos del Combo anteriormente cargados y le vamos concatenando el valor de otros campos correspondientes al mismo registro:
  42:              foreach (ListItem elemItem in DropDownListClientes.Items)
  43:              {
  44:                  clt.CargarLista("Select * from NombreTabla where Codigo = " + elemItem.Text);    //Volvemos a llamar al método que realiza la consulta sobre la Base de Datos obtieniendo la fila que corresponde con el valor del elemento del Combo actual
  45:                  Dictionary<string, string> camposYvalores = new Dictionary<string, string>();  //Creamos un diccionario de datos 
  46:                  camposYvalores = clt.CargarDiccionario(camposYvalores); //Llamamos al método que carga el Diccionario con los campos y valores que queremos mostrar en el Combo
  47:                  elemItem.Text = string.Empty;   //Vaciamos el elemento del combo
  48:   
  49:                  //Y a continuación volvemos a llenarlo con los valores del registro deseados:
  50:                  foreach (KeyValuePair<string, string> kvp in camposYvalores)
  51:                  {
  52:                      elemItem.Text += kvp.Value + " *** ";   //Al elemento del Combo se le concatena el valor del campo y tres asteriscos para separar los campos
  53:                  }
  54:   
  55:                  elemItem.Text = elemItem.Text.Remove(elemItem.Text.Length - 4, 4);  //Se eliminan los 4 últimos caracteres del elemento del combo (los asteriscos mas un espacio)
  56:              }
  57:          }
  58:      }
  59:  }

lunes, 3 de agosto de 2009

Comprobar los valores nulos de cada Campo tras realizar una consulta a una Base de datos SQL Server con Visual C#.

Para comprobar los posibles valores nulos de los Campos de una Tabla obtenidos como resultado de una Consulta lanzada sobre una base de datos SQL Server, de manera que podamos analizar los valores antes de trabajar con ellos, guardaremos el resultado de la Consulta en un Objeto "DataView" y, posteriormente, realizaremos una simple comparación, Campo a Campo (utilizando la propiedad "Value" de la Clase "DBNull": DBNull.Value) de la fila ó filas obtenidas (en nuestro caso, una sola fila: Table.Rows[0]).

La consulta sobre la Base de datos SQL Server se ejecuta utilizando el método "Fill(DataTable)" de la Clase "SqlDataAdapter" (una Clase adaptadora) y, posteriormente, se almacena el resultado de la consulta en un objeto "DataView".

Para ilustrar fácilmente el ejemplo he utilizado una Clase Cliente (en la que inserto todo el código para facilitar la comprensión, aunque debería dividirse en distintas Clases y Capas) y una consulta SQL incrustada en el código (que tampoco es muy ortodoxo) para simplificarlo.

Veamos el código:


   1:  using System;
   2:  using System.Collections.Generic;
   3:  using System.Linq;
   4:  using System.Text;
   5:  using System.Data;
   6:  using System.Collections;
   7:  using System.Data.SqlClient;
   8:  using System.ComponentModel;
   9:   
  10:  namespace BlogSalvatrosh
  11:  {
  12:      public class Cliente
  13:      {
  14:          public Cliente()
  15:          {
  16:          }
  17:   
  18:          private string campoCodigo = string.Empty;
  19:          private string campoNif = string.Empty;
  20:          private string campoNombre = string.Empty;
  21:   
  22:          public string Codigo
  23:          {
  24:              get{return campoCodigo;}
  25:              set{campoCodigo = value;}
  26:          }
  27:   
  28:          public string Nif
  29:          {
  30:              get{return campoNif;}
  31:              set{campoNif = value;}
  32:          }
  33:   
  34:          public string Nombre
  35:          {
  36:              get{return campoNombre;}
  37:              set{campoNombre = value;}
  38:          }
  39:   
  40:   
  41:          /// Tras hacer una llamada al método que ejecuta la consulta sobre la Base de Datos, llama al método que crea un objeto Cliente asignando los valores obtenidos en la consulta a sus propiedades públicas, comprobando previamente los valores nulos de cada campo.
  42:          public Cliente ControlarValoresNulos()
  43:          {
  44:              string consulta = string.Empty;
  45:              Cliente cl = new Cliente();
  46:   
  47:              consulta = "SELECT * FROM NombreTabla WHERE codigo = '56'";   //Insertamos aquí una consulta para ilustrar el ejemplo
  48:   
  49:              //Se llama al método que realiza la Consulta sobre la Base de Datos pasándole como parámetro la consulta indicada anteriormente:
  50:              DataView vista = (DataView)CargarLista(consulta);
  51:   
  52:              if (vista.Count != 0)   //Si la consulta devuelve alguna fila
  53:                  cl = CrearObjetoCliente(vista.Table.Rows[0]); //Llamamos al método que asigna los valores obtenidos en la consulta a las propiedades del objeto Cliente
  54:   
  55:              return cl;  //Retornará el objeto creado
  56:          }
  57:   
  58:   
  59:          /// Este método creará un objeto Cliente a cuyas propiedades se le asignarán los valores de cada uno de los campos obtenidos en el "DataRow" que recibe como parámetro, comprobando si los valores de cada campo son valores null
  60:          private Cliente CrearObjetoCliente(DataRow dr)
  61:          {
  62:              if (dr["codigo"] != DBNull.Value)    //Si el campo "codigo" no es nulo
  63:                  this.Codigo = dr["codigo"].ToString();//Se le asigna su valor a la propiedad "Codigo" del objeto que estamos construyendo
  64:              else
  65:                  this.Codigo = string.Empty;//En caso contrario le asignamos una cadena vacía
  66:   
  67:              //Y repetimos la operación para el resto de los campos:
  68:              if (dr["NIF"] != DBNull.Value)
  69:                  this.Nif = dr["NIF"].ToString();
  70:              else
  71:                  this.Nif = string.Empty;
  72:   
  73:              if (dr["nombre"] != DBNull.Value)
  74:                  this.Nombre = dr["nombre"].ToString();
  75:              else
  76:                  this.Nombre = string.Empty;
  77:              
  78:              return this;    //Devuelve el objeto que estamos construyendo
  79:          }
  80:   
  81:   
  82:          /// Ejecuta una consulta SQL (que recibe como parámetro) sobre la Base de Datos devolviendo el resultado de la consulta en un tipo "DataView"
  83:          public static DataView CargarLista(string consulta)
  84:          {
  85:              SqlDataAdapter sqlDa = null;
  86:              DataTable dt = new DataTable();
  87:              SqlConnection conexion = new SqlConnection("CadenaDeConexion");
  88:              SqlCommand sqlCmd = new SqlCommand(consulta, conexion);   //Se crea un comando SQL con la consulta y el puente de conexión
  89:   
  90:              sqlDa = new SqlDataAdapter(sqlCmd);
  91:   
  92:              try
                   {
  93:                  conexion.Open();    //Se abre la conexión con la Base de Datos            
  94:                  sqlDa.Fill(dt);   //Ejecuta la consulta y la adapta a un "DataTable" definido como "dt"
  95:                  return dt.DefaultView;  //COnvierte la consulta en una vista (en un tipo "DataView")
  96:              }
  97:              catch (Exception)
  98:              {
  99:                  return null;
 100:              }
 101:              finally
 102:              {//Se cierra la conexión
 103:                  if (conexion.State == ConnectionState.Open)
 104:                      conexion.Close();
 105:              }
 106:          }
 107:      }
 108:  }

viernes, 31 de julio de 2009

Mostrar un mensaje en pantalla en una aplicación web ASP.Net

Puesto que en las aplicaciones web de ASP.Net no pueden utilizarse las Clases "MessageBox" ni "MsgBox" para mostrar un mensaje en pantalla, en este tipo de aplicaciones habrá que crear un método con el código adecuado y llamarlo, por ejemplo, desde el "evento Load" de la página en la que debe mostrarse.

El método que construye el mensaje en tiempo de ejecución debe seguir los siguientes pasos:
1º. Crear el Script.
2º. Registrarlo en la página en la que debe mostrarse el mensaje para que quede asociado a la petición al Servidor.
3º. Asociarlo a algún evento que pueda desencadenarse en esa página. Por ejemplo, al evento "click" de un "botón".

Veamos el código:


   1:  using System;
   2:  using System.Collections.Generic;
   3:  using System.Linq;
   4:  using System.Web;
   5:  using System.Web.UI;
   6:   
   7:  namespace BlogSalvatrosh
   8:  {
   9:      public class Script : System.Web.UI.UserControl
  10:      {
  11:          /// <summary>
  12:          /// Este método registra en la página que vaya a cargarse un mensaje escrito en código JavaScript que solicita al usuario la confirmación de la eliminación de un registro y se asocia al evento "onclick" del botón Eliminar. Cuando se pulse el botón eliminar el mensaje se mostrará en pantalla.
  13:          /// </summary>
  14:          public void AsociarScriptMensajeAdvertencia()
  15:          {
  16:              //Creamos un Script en lenguaje "javascript" que asociaremos luego a la petición al servidor
  17:              System.Text.StringBuilder script = new System.Text.StringBuilder();
  18:              //Iremos concatenando el código hasta completar la función "MensajeAdvertencia()" que se ejecutará en el servidor
  19:              //tras el registro de la página:
  20:              script.Append("<script type= 'text/javascript' language= 'javascript'>");   //Se abre la etiqueta del Script y se indica que es de tipo javascript
  21:              script.Append("function MensajeAdvertencia(mensaje){");   //Nombre de la función javascript que recibe como parámetro un mensaje de texto
  22:              script.Append("if(!window.confirm(mensaje)){");  //Si el usuario hace click en "cancelar"
  23:              script.Append("event.returnValue=false;");  //A la propiedad "returnValue" del Evento  "event" se le asigna el valor "false" 
  24:              script.Append("return false;"); //Y se retorna false
  25:              script.Append("}");
  26:              script.Append("else{"); //En caso contrario, es decir, si el usuario hace click en "Aceptar"
  27:              script.Append("return true;");  //Se retorna true
  28:              script.Append("}");
  29:              script.Append("}");
  30:              script.Append("</script>"); //Se cierrra la etiqueta del Script
  31:   
  32:              //Registramos el script en la página que vaya a cargarse:
  33:              this.Page.ClientScript.RegisterStartupScript(typeof(Page), this.ClientID + "script", script.ToString());
  34:   
  35:              //Asociamos el atributo "onclick" del botón "BotonEliminar" a la funcion "MensajeAdvertencia" que se encuentra en el script registrado en el punto anterior
  36:              this.BotonEliminar.Attributes.Add("onclick", "javascript:MensajeAdvertencia('Desea eliminar este registro de la Base de Datos?');");
  37:          }
  38:      }
  39:  }

sábado, 25 de julio de 2009

Insertar un registro en una base de datos SQL Server utilizando un Procedimiento Almacenado en Visual C#.

Para insertar un Registro en una Base de Datos SQL Server utilizando un Procedimiento Almacenado (que por supuesto debe haberse definido previamente en la Base de Datos), Visual C# necesita conocer:
1º. El objeto (registro) que desea insertarse en la Base de datos, con todos sus campos y valores, el cual puede haberse definido en una Clase (por ejemplo una Clase "Articulo"). Este Articulo (o la Clase que sea) se pasa como un tipo "object" (que aquí hemos llamado "obj").
2º. Que, efectivamente, se va a utilizar un Procedimiento Almacenado.
3º. El nombre del Procedimiento Almacenado.
4º. Los parámetros de dicho Procedimiento.

A su vez, para que Procedimiento Almacenado pueda ser ejecutado, Visual C# exige conocer de cada parámetro del Procedimiento:
1º. El nombre del parámetro.
2ª. El tipo de dato SQL.
3º. El valor del parámetro.

Para obtener toda esta información vamos a recurrir a "Reflexion", una de las características esenciales de Visual C#, recorriendo las "propiedades públicas" del objeto "obj" que se desea insertar en la Base de Datos.

Quizá lo más complejo sea obtener el tipo de dato SQL, ya que los tipos de datos utilizados por Visual C# no son equivalentes a los tipos de datos SQL Server y, por ello, será necesario realizar una conversión explícita y evitar un error en tiempo de ejecución.

Veamos como hacerlo paso a paso:


   1:  using System;
   2:  using System.Collections.Generic;
   3:  using System.Linq;
   4:  using System.Text;
   5:  using System.Data;
   6:  using System.Data.SqlClient;
   7:  using System.Configuration;
   8:  using System.Reflection;
   9:   
  10:  namespace AccionBaseDatos
  11:  { 
  12:      public class Insertar
  13:      {
  14:          //Variable que se va a utilizar para las instrucciones "lock" cuando la Aplicación entre en un proceso crítico
  15:          private static string semaforo = string.Empty;
  16:   
  17:   
  18:          /// Inserta un registro en la Base de datos utilizando el Procedimiento Almacenado cuyo nombre recibe como parámetro de entrada.
  19:          /// Para obtener los parámetros del Procedimiento Almacenado habrá que leer los datos de los campos y sus valores que vienen definidos en el parámetro "obj" que es de tipo "object"
  20:          public bool GuardarRegistroConProcedimiento(IDbConnection idbConnect, string nomProcedimiento, object obj)
  21:          {
  22:              //Creamos el comando SQL con el nombre del Procedimieneto Almacenado:
  23:              SqlCommand sqlCmd = new SqlCommand(nomProcedimiento);
  24:              //Se llama al método que obtiene los parámetros que necesita el Procedimiento almacenado
  25:              sqlCmd = ObtenerParametrosDelObjeto(sqlCmd, obj);
  26:              //Le indicamos que el comando SQL es de tipo Procedimniento Almacenado
  27:              sqlCmd.CommandType = CommandType.StoredProcedure;
  28:   
  29:              return RealizarTransaccion(sqlCmd, idbConnect); //Se llama al método que realiza la inserción y devuelve true o false si la ha realizado o no
  30:          }
  31:   
  32:   
  33:   
  34:          /// Obtiene los parámetros que necesita el Procedimieneto Almacenado para poder ejecutarse a partir de las "propiedades públicas" del Objeto "obj"  que se van a obtener utilizando el método "GetProperties()"
  35:          public SqlCommand ObtenerParametrosDelObjeto(SqlCommand sqlComando, object obj)
  36:          {
  37:              SqlDbType sqlDbTipo;
  38:              string nombreCampo = string.Empty;
  39:              string typ = string.Empty;
  40:              object valor = null;
  41:   
  42:              //Para obtener las "propiedades públicas" del Objeto "obj" las recorremos utilizando un bucle "foreach" y el método "GetProperties()":
  43:              foreach (PropertyInfo propiedad in obj.GetType().GetProperties()) //El método GetProperties() devuelve la propiedad
  44:              {
  45:                  nombreCampo = propiedad.Name; //Obtenemos el nombre del campo que hemos hecho coincidir con el nombre de la propiedad
  46:                  typ = propiedad.PropertyType.Name; //Obtenemos el nombre del tipo de dato (nombre del tipo de dato que utiliza el Framework).
  47:                  //Para obtener el tipo de dato SQL llamamos al método que realiza la conversión de tipos:
  48:                  sqlDbTipo = ComprobarTipoDeDatoSql(typ);
  49:                  //Obtenemos el valor del campo a partir del valor de la propiedad pública del objeto:
  50:                  valor = propiedad.GetValue(obj, null); //Como las propiedades del objeto "obj" no están indizadas el segundo parámetro es null
  51:                  //Creamos una variable de tipo Parámetro SQL con el nombre el campo y el tipo de dato SQL:
  52:                  SqlParameter sqlParametro = new SqlParameter("@" + nombreCampo, sqlDbTipo);
  53:                  //Le asignamos el valor del campo obtenido del objeto "obj" al valor del parámetro:
  54:                  sqlParametro.Value = valor;
  55:                  //Añadimos el parámetro al comando SQL
  56:                  sqlComando.Parameters.Add(sqlParametro);
  57:              }
  58:              return sqlComando; //Devuelve el comando SQL con los parámetros obtenidos
  59:          }
  60:   
  61:   
  62:          /// Obtiene el tipo de dato SQL guardado en el parámetro "tipo"
  63:          public SqlDbType ComprobarTipoDeDatoSql(string tipo)
  64:          {
  65:              SqlDbType tipoDatoSql;
  66:   
  67:              if (tipo == "Int32")
  68:                  tipoDatoSql = SqlDbType.Int;
  69:              else if (tipo == "DateTime")
  70:                  tipoDatoSql = SqlDbType.DateTime;
  71:              else if (tipo == "String")
  72:                  tipoDatoSql = SqlDbType.NVarChar;
  73:              else if (tipo == "Float")
  74:                  tipoDatoSql = SqlDbType.Float;
  75:              else if (tipo == "Boolean")
  76:                  tipoDatoSql = SqlDbType.Bit;
  77:              else if (tipo == "Double")
  78:                  tipoDatoSql = SqlDbType.Real;
  79:              else if (tipo == "Decimal")
  80:                  tipoDatoSql = SqlDbType.Decimal;
  81:              else
  82:                  tipoDatoSql = SqlDbType.Variant;
  83:   
  84:              return tipoDatoSql; //Devuelve el tipo de dato SQL obtenido
  85:          }
  86:   
  87:   
  88:   
  89:   
  90:          /// Ejecuta un comando SQL en la base de datos utilizando el método "ExecuteNonQuery()"
  91:          private bool RealizarTransaccion(SqlCommand sqlCmd, IDbConnection idbConnect)
  92:          {
  93:              try
  94:              {
  95:                  lock (semaforo) //Con la instrucción "lock" se indica que el programa va a entrar en un punto crítico para evitar que se ejecuten simultáneamente otros subprocesos
  96:                  {
  97:                      if (idbConnect.State == ConnectionState.Closed) //Se comprueba el estado de la conexión. Si está cerrada vuelve a abrirse:
  98:                          idbConnect.Open();
  99:   
 100:                      sqlCmd.Connection = (SqlConnection)idbConnect; //Se inicializa el objeto SqlConnection con la propia conexión "idbConnect" indicando que la conexión es de tipo SQL
 101:                      int filas = sqlCmd.ExecuteNonQuery(); //Se ejecuta la instrucción SQL, devolviendo el número de columnas afectadas
 102:                      if (filas > 0)
 103:                          return true;
 104:                      else
 105:                          return false;
 106:                  }
 107:              }
 108:              catch (Exception)
 109:              {
 110:                  return false;
 111:              }
 112:              finally
 113:              {//Se cierra la conexión
 114:                  if (idbConnect.State == ConnectionState.Open)
 115:                      idbConnect.Close();
 116:              }
 117:          }
 118:      }
 119:  }

jueves, 23 de julio de 2009

Crear un Diccionario de datos de tipo Clave/Valor en Visual C#

Vamos a crear una estructura de datos de tipo "Diccionario de pares Clave/Valor" (un tipo Dictionary) en el que tanto el tipo de dato de la Clave como del Valor serán de tipo String (aunque podrían ser de cualquier otro tipo).

Estas estructuras son útiles cuando se precisa almacenar y recuperar datos que deban estar relacionados en pares de valores. Por ejemplo, el nombre de una serie de personas con su DNI, ó
el nombre de una serie de artículos con su precio, etc.

Cada par de datos Clave/Valor se almacenan dentro del Diccionario como una estructura de datos denominada "KeyValuePair" (TKey, TValue).

Los diccionarios de datos se suelen utilizar cuando sólo se necesitan algunas de las propiedades (Claves) de algún objeto de una Clase previamente definida y sus Valores correspondientes, aunque no hay ningún inconveniente en utilizarlo para guardar todas las propiedades del objeto.

En este caso crearemos un "Dictionary" para guardar los valores de varias propiedades de un supuesto objeto de tipo "libro". Veamos el código:


   1:  public Dictionary<string, string> CargarDiccionario()
   2:          {
   3:              //Creamos una estructura de datos de tipo "Dictionary":
   4:              Dictionary<string, string> miDic = new Dictionary<string, string>();
   5:   
   6:              //Supongamos que necesitamos guardar tres propiedades (codigo, titulo y precio) que vamos añadiendo al Diccionario con sus correspondientes valores (por ejemplo, 2442, D. Quijote de la Mancha, 52). Cuando el valor es de tipo numérico lo convertimos previamente a tipo string
   7:              miDic.Add("codigo", Convert.ToString(2442));    
   8:              miDic.Add("titulo", "D. Quijote de la Mancha");  
   9:              miDic.Add("precio", Convert.ToString(52));
  10:   
  11:              RecorrerDiccionario(miDic);
  12:   
  13:              return miDic;
  14:          }


Para recuperar los datos almacenados en un Diccionario de pares de Clave/Valor habrá que recorrer cada uno de sus elementos "KeyValuePair" utilizando un bucle "for each". En este caso sencillamente realizamos la lectura y escribimos los datos en la secuencia de salida standard:

   1:  public void RecorrerDiccionario(Dictionary<string, string> elDic)
   2:          {
   3:              foreach (KeyValuePair<string, string> kvp in elDic)
   4:              {
   5:                  Console.Write(kvp.Key);
   6:                  Console.Write(kvp.Value);
   7:              }
   8:          }
Webs amigas:
Eduardo Soriano
Solcan
Taller de Joyería