Almacenar una Imagen en una Base de Datos

Contenido

1. Introducción
2. Una Base de Datos de Ejemplo
3. Construyendo una Interfaz Gráfica
4. Almacenado la Imagen
5. Conclusión

1. Introducción

En este artículo cubriremos el proceso de almacenar una imagen en una base de datos de SQL Server,
basándonos en un ejemplo de un pequeño catálogo de 'Productos'. El almacenamiento de imágenes en bases
de datos no suele ser la mejor solución para el tratamiento de imágenes en las aplicaciones enlazadas a
datos; sin embargo, en algunos casos es necesaria esta práctica cuando se desea aprovechar las
capacidades del SGBD que se haya elegido. Para comenzar a ejemplificar este proceso, comenzaremos a
crear una base de datos de ejemplo la cual se describirá en la siguiente sección.

Principio de la página

2. Una Base de Datos de Ejemplo

En una base de datos de ejemplo llamada 'Store', crearemos una tabla sencilla llamada 'Productos', cuya
definición será la siguiente:

CREATE TABLE Products

(
id int NOT NULL ,
name nvarchar (80) NOT NULL,
quantity int NOT NULL,
price smallmoney NOT NULL,
productImage image NULL ,
CONSTRAINT PK_Products PRIMARY KEY CLUSTERED (id)
)

Visualmente, en el administrador corporativo, tendría el aspecto que muestra la Figura 1:

Figura 1. Volver al texto.

Principio de la página

3. Construyendo una Interfaz Gráfica

Construiremos una pequeña interfaz gráfica que nos servirá para obtener los datos de los productos, entre
ellos, la imagen. El aspecto del formulario será el que muestra la Figura 2:
Figura 2. Volver al texto.

Principio de la página

4. Almacenado la Imagen

Para almacenar los datos (incluyendo la imagen) primero tenemos que ingresarlos en el formulario; para
ingresar la imagen nos apoyaremos en un objeto OpenFileDialog, el que usaremos para que el usuario
escoja la imagen que quiere asociar al producto, y lo mostraremos cuando el usuario haya hecho clic sobre
el botón para navegar (...). Usaremos el siguiente código:

private void browseButton_Click(object sender, System.EventArgs e)

{
// Se crea el OpenFileDialog
OpenFileDialog dialog = new OpenFileDialog();
// Se muestra al usuario esperando una acción
DialogResult result = dialog.ShowDialog();

// Si seleccionó un archivo (asumiendo que es una imagen lo que

seleccionó)
// la mostramos en el PictureBox de la inferfaz
if (result == DialogResult.OK)
{
pictureBox.Image = Image.FromFile(dialog.FileName);
 }
}

Teniendo los datos de entrada que muestra la Figura 3, por ejemplo:

Figura 3. Volver al texto.

Teniendo los datos de entrada, incluyendo la imagen y no tomando en cuenta las validaciones sobre el
formulario de entrada, lo siguiente será guardar en sí los datos en la base de datos. (Esta acción se produce
cuando se hace clic sobre 'Guardar'). Utilizamos el siguiente código para hacerlo:

private void saveButton_Click(object sender, System.EventArgs e)

{
try
{
// Objetos de conexión y comando
System.Data.SqlClient.SqlConnection conn = new
System.Data.SqlClient.SqlConnection(@"Data Source=
(local);Initial Catalog=store;Integrated Security=SSPI");
System.Data.SqlClient.SqlCommand cmd = new
System.Data.SqlClient.SqlCommand();

// Estableciento propiedades
cmd.Connection = conn;
 cmd.CommandText = "INSERT INTO Products VALUES (@id, @name,
@quantity, @price, @image)";

// Creando los parámetros necesarios

cmd.Parameters.Add("@id", System.Data.SqlDbType.Int);
cmd.Parameters.Add("@name", System.Data.SqlDbType.NVarChar);
cmd.Parameters.Add("@quantity", System.Data.SqlDbType.Int);
cmd.Parameters.Add("@price", System.Data.SqlDbType.SmallMoney);
cmd.Parameters.Add("@image", System.Data.SqlDbType.Image);

// Asignando los valores a los atributos

cmd.Parameters["@id"].Value = int.Parse(idBox.Text);
cmd.Parameters["@name"].Value = nameBox.Text;
cmd.Parameters["@quantity"].Value = int.Parse(quantityBox.Text);
cmd.Parameters["@price"].Value = float.Parse(priceBox.Text);

// Asignando el valor de la imagen

// Stream usado como buffer

System.IO.MemoryStream ms = new System.IO.MemoryStream();
// Se guarda la imagen en el buffer
pictureBox.Image.Save(ms,
System.Drawing.Imaging.ImageFormat.Jpeg);
// Se extraen los bytes del buffer para asignarlos como valor para
el
// parámetro.
cmd.Parameters["@image"].Value = ms.GetBuffer();

conn.Open();
cmd.ExecuteNonQuery();
conn.Close();
}
catch (System.Exception ex)
{
MessageBox.Show(ex.Message);
}
}

Como puedes observar, el código usa parámetros para establecer los valores de los campos. Lo más
interesante está en la parte 'Asignando el valor de la imagen', ya que se usa un flujo de memoria intermedio
para extraer los bytes de la imagen (que es como realmente se guarda en la base de datos, como una
secuencia de bytes). Ahora bien, una vez que se tiene el objeto MemoryStream, podemos usar el método
Save() del objeto Image, para obtener los bytes de la imagen y colocarlos en un flujo, especificando el tipo
de formato de la imagen. Ya con los bytes cargados en el MemoryStream lo último que tenemos que hacer
es asignar realmente los bytes en el valor del parámetro, lo que se hace obteniendo el buffer del
MemoryStream (los bytes) y asignarlo a la propiedad Value del parámetro.

Para referenciar a la imagen en cuestión, se obtuvo desde la propiedad Image del objeto PictureBox; esto es
porque se asume que debió de haber estado cargada una imagen en el cuadro. Habrá ocasiones en las que
no se desee hacer de esta forma, ya sea porque se dé una ruta directa a una imagen (en modo texto), etc.
Para obtener una referencia a la imagen a almacenar para utilizar el método Save(), podría usarse el método
estático Image.FromFile y se obtendría la referencia a una imagen, o también de otra forma, podrían
leerse los bytes directamente del archivo de imagen, en este caso la lectura habría que llevarla a cabo
"manualmente" ya que no se usaría el método Save(). Dejo a tu elección cualquiera de estas técnicas, ya
que esto puede variar en distintas situaciones.