Almacenar una Imagen en una Base de Datos

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.

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.
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.
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.
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.