Conectándonos a SQL Server con ADO.

NET parte I
http://copstone.com/2010/03/conectandonos-a-sql-server-con-ado-net-parte-i/

Si estas cansado de ir guardando tu información en archivos, pues es hora que aprendas

a utilizar una Base de Datos. Este post, el primero de varios realicionados al tema, te
enseñará a conectarte a una Base de Datos para que esta información sea presentada
posteriormente en pantalla.

En los post ADO.NET y Cadenas de Conexión en ADO.NET (puestos al final de este

documento) he resumido información sumamente importante para poder llegar a
entender este post.

Recuerda que ADO.NET nos da las clases para conectarnos y posteriormente trabajar
con la información, y la cadena de conexión tiene los valores necesarios para acceder al
servidor donde la información esta almacenada. Haciendo uso de estos conceptos
veremos el código necesario que debemos usar para crear una aplicación que se conecte
a una base de datos MS SQL Server.

Antes de continuar, es necesario tener instalado o tener acceso a un servidor MS SQL

Server, puede ser 2005 o 2008. Si no tienes, puedes conseguir en forma gratuita, la
versión Express en la siguiente dirección: MS Sql Server 2008 Express, instálala en tu
computadora antes de continuar.

Creando una aplicación para conectarse a MS SQL Server

Cuando uno instala .Net Framework, se instalan las clases que permiten el acceso a una
base de datos MS Sql Server, por lo que dentro de la biblioteca de clases, vienen las
clases que nos permiten trabajar con esta base de datos. Si queremos cambiar de base de
datos, debemos de conseguirnos las clases que nos permitirán conectarnos a la base de
dato que deseemos, existen conectores para MySql, Postgress ,etc.

En esta ocasión, lo que voy a hacer es crear dos proyectos del tipo ClassLibrary, uno en
C# y otro en C++ para que tengas la aplicación en ambos lenguajes. A través de estas
aplicaciones me conectaré a una Base de Datos MS SQL Server 2008, extraeré la
información y en un post posterior te mostraré como puedes hacer para mostrarla en
pantalla.

Te recomiendo leer el post Creando un Proyecto Class Library para que recuerdes de
que se trata.

Continuando, recuerda que que estoy haciendo dos proyectos, uno en C# y otro en C++,
pero basta con hacer sólo uno de ellos, porque recuerda que en Visual Studio, puedes
combinar, en una misma solución, varios lenguajes.

En general, para conectarnos a una base de datos necesitamos de un objeto Connection

y un objeto Command y de manera puntual los objetos en el caso de SQL son
SqlConnection y SqlCommand, ambos definidos en el namespace System.Data.Sql. De
igual forma necesitamos de un SqlAdapter, quien es el vínculo entre el comando
definido y por lo tanto quien será el canal de comunicación entre nuestra aplicación y la
base de datos.

Luego de crear los proyectos, lo primero que voy a colocar son los namespace que me
hacen falta para trabajar:

Visual C++

C#

1 using namespace System;

2 using namespace System::Collections::Generic;
3 using namespace System::Linq;
4 using namespace System::Text;
5 using namespace System::Data;
6 using namespace System::Data::Sql;
7 using namespace System::Data::SqlClient;

Asignando la Cadena de Conexión

Por su nombre en inglés, la cadena de conexión es asignada mediante la propiedad

ConnectionString, del objeto Connection que se utilice para conectarse a la Base de
Datos indicada.

Si leíste los dos post a los que hago mención al inicio, pudiste observar que hay una
serie de Clases que nos permitirán trabajar con la data. Uno de estas clases es el
DataSet. El DataSet, te permite definir un objeto para que, luego de extraída la
información, el cliente pueda mostrarla, insertar nuevos campos, modificarla, etc. En
resumen, el DataSet se refleja desde el lado Cliente, por lo que permite que la aplicación
Cliente, tenga en memoria los datos que han sido extraídos para poder trabajar con ellos.

Por lo tanto, voy a definir una función que te permita obtener todos los registros de la
tabla CopstoneTable ubicada en la base de datos llamada CopstoneBD y que retorne un
DataSet, el cual será recorrido o manipulado por otra aplicación.

Visual C++

public ref class MiPrimeraConexionaunaBD

{
public <img
src="http://copstone.com/wp-includes/images/smilies/icon_biggrin.gif"
alt=":D" class="wp-smiley"> ataSet^ Trae_Informacion_Desde_BD()
{
/*Creamos un objeto del tipo SqlConnection
* para conectarnos a la Base de Datos*/
SqlConnection ^sqlcon = gcnew SqlConnection();
/*Mediante la propiedad ConnectionString
*asignamos la cadena de conexión */
sqlcon->ConnectionString = "DatSource=localhost;
initial catalog=Pubs;
user id=sa; password=SsAa";
/*Creamos un comando para seleccionar
*los campos que deseamos obtner*/
SqlCommand ^cmd = gcnew SqlCommand("Select * from pubs");
/*Creamos un sqladapter que estará
* vinculado a la consulta realizada*/
SqlDataAdapter ^da = gcnew SqlDataAdapter(cmd);
//Creamos un objeto DataSet
DataSet ^ds = gcnew DataSet();
try
{ //Abrimos la conexión a la BD
sqlcon->Open();
try{
/*A partir del sqladapter
*definido llenamos
el dataset*/

da->Fill(ds);
}
__finally{

/*Finalmente siempre cerramos

la conexión a la BD
*/
sqlcon->Close();
}
}
catch(...)
{ //Ante cualquier error lanzamos la excepción
throw ;
}
/*Retornamos el objeto dataset
*para ser utilizado por el cliente*/
return ds;
}
};
C#

public class MiPrimeraConexionaunaBD

{
public DataSet Trae_Informacion_Desde_BD()
{
/*Creamos un objeto del tipo SqlConnection
* para conectarnos a la Base de Datos*/
SqlConnection sqlcon = new SqlConnection();
/*Mediante la propiedad ConnectionString
*asignamos la cadena de conexión */
sqlcon.ConnectionString = "DatSource=localhost;
initial catalog=CopstoneBD;
user id=sa; password=SsAa";
/*Creamos un comando para seleccionar
*los campos que deseamos obtner*/
SqlCommand cmd = new SqlCommand("Select * from
CopstoneTable");
/*Creamos un sqladapter que estará
* vinculado a la consulta realizada*/
SqlDataAdapter da = new SqlDataAdapter(cmd);
//Creamos un objeto DataSet
DataSet ds = new DataSet();
try
{ //Abrimos la conexión a la BD
sqlcon.Open();
/*A partir del sqladapter
*definido llenamos el dataset*/
da.Fill(ds);
}
catch
{ //Ante cualquier error lanzamos la excepción
throw;
}
finally
{
//Finalmente cerramos la conexión a la BD
sqlcon.Close();
}
/*Retornamos el objeto dataset
*para ser utilizado por el cliente*/
return ds;
}
}

Bueno, con este código, cambiado el nombre de la Base de Datos en la cadena de

conexión y el nombre de la tabla, puedes obtener la información desde cualquier tabla.
Cuando instalas MSSQL Server, trae Bases de Datos de Ejemplo: Pubs, NorthWind,
etc, las cuales puedes utilizar para practicar estas rutinas.

Lo que hace este código únicamente es recopilar información desde una tabla, pero lo
que aún no hacemos es como insertar, modificar o borrar los valores, eso lo iremos
aprendiendo de a pocos.
Conectándonos a SQL Server con ADO.NET parte II
Si en el post anterior vimos como conectarnos a un Servidor SQL, es momento de
aprender como podemos recorrer la información obtenida mediante un DataSet. En este
post he tratado de hacer una definición resumida de lo que es un DataSet pero
principalmente he colocado el código necesario para que puedas ir aprendiendo más
acerca de esta clase importante de ADO.NET

En el post Conectándonos a SQL Server con ADO.NET parte I , vimos como

conectarnos a un servidor de base de datos (MSSQL Server) a través de ADO.NET.
Declaramos un proyecto ClassLibrary que era el encargado de definir el método
necesario para conectarnos al servidor, recopilar la información de una tabla y retornarla
mediante un objeto DataSet.

Bueno, ahora lo que haremos es crear una aplicación del tipo consola que reciba el
objeto DataSet y lo recorra mostrando su contenido. Para poder hacer esto, primero
definamos que es un objeto DataSet.

Según Microsoft uno de los principales componentes de ADO.NET es el DataSet. Un

DataSet es la representación de los datos recopilados, de un origen de datos, en la
memoria caché del computador. Ahora, lo que tienes que tener cuidado de no confundir
lo siguiente, la definición anterior te habla de datos recopilados, no te dice de una sola
tabla. Por qué hago esta aclaración?, porque es un error muy frecuente creer que un
DataSet sólo almacena datos de una tabla, un objeto DataSet puede almacenar datos de
varias tablas, cada una con sus filas y columnas, además permite definir relaciones entre
las tablas que contiene.

Un punto clave en un DataSet y quizás lo mas importante tal como lo puedes ver en la
imagen siguiente, es que todo está soportado por XML, lo cual hace posible trabajar
con diversas fuentes de datos de la misma forma, realmente eso es muy importante.
El objetivo de este post es enseñarte a recorrer un DataSet, enseñarte como acceder a las
tablas que contiene, a las filas y columnas de cada una de éstas, por lo que vamos a ver
los bloques de código necesarios para cumplir con éstos puntos. Antes de empezar te
muestro la siguiente figura para que vayas reconociendo como será el esquema de

trabajo.

Recuerda que vamos a crear una aplicación consola, y que vamos a hacer referencia al
proyecto creado en el post Conectándonos a SQL Server con ADO.NET parte I para
poder obtener la información y en la aplicación consola que crees vamos a recorrer la
información.

Invocando a los namespace necesarios

Visual C++
using namespace System;
//Namespace donde esta definido el DataSet
using namespace System::Data;
/*Namespace de nuestro proyecto
*que se conecta a la BD */
using namespace CopstoneClassLibrary;

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//Namespace donde esta definido el DataSet
using System.Data;
/*Namespace de nuestro proyecto
*que se conecta a la BD */
using CopstoneClassLibrary;

Creando los Objetos necesarios para trabajar con el

DataSet
Recuerda que estamos trabajando con un proyecto del tipo ClassLibary definido
previamente, por lo que debemos de definir un objeto de esta clase para poder
interactuar con los métodos definidos.

Visual C++

namespace TrabajandoconDataSet
{
int main()
{
//Creamos un objeto para conectarnos a una BD
MiPrimeraConexionaunaBD^ mibd=gcnew MiPrimeraConexionaunaBD();
/*Le indicamos al objeto que nos devuelva
*un DataSet con los datos recopilados*/
DataSet^ ds=mibd->Trae_Informacion_Desde_BD();
//AQUI COLOCAR LA LLAMADA A LOS METODOS
}
}

C#

namespace TrabajandoconDataSet
{
class Program
{
//AQUI COLOCAR LOS METODOS
 static void Main(string[] args)
{
//Creamos un objeto para conectarnos a una BD
MiPrimeraConexionaunaBD mibd = new
MiPrimeraConexionaunaBD();
/*Le indicamos al objeto que nos devuelva
*un DataSet con los datos recopilados*/
DataSet ds=mibd.Trae_Informacion_Desde_BD();

//AQUI COLOCAR LA LLAMADA A LOS METODOS

}
}
}

Recorriendo las Tablas de un DataSet

Recuerda que un DataSet tiene una colección de DataTable, por lo que debemos
recorrer esta colección para poder obtener información de las tablas que han sido
recopiladas.

Visual C++

/*Método para mostrar el detalle de cada DataTable del DataSet*/

void Imprime_Detalle_Tablas(DataSet^ ds)
{
for (int i=0;i<ds->Tables->Count-1;i++)
{
//Mostramos el nombre de la tabla
Console::WriteLine("Nombre de la Tabla : {0}",
ds->Tables[i]->TableName);
//Mediante Rows accedemos a las filas de la tabla
Console::WriteLine("Cantidad de Filas : {0}",
ds->Tables[i]->Rows->Count );
//Mediante Columns accedemos a las columnas de la tabla
Console::WriteLine("Cantidad de Columnas : {0}",
ds->Tables[i]->Columns->Count);

}
}

C#

/*Método para mostrar el detalle de cada DataTable del DataSet*/

void Imprime_Detalle_Tablas(DataSet ds)
{
foreach (DataTable dt in ds.Tables)
{
//Mostramos el nombre de la tabla
Console.WriteLine("Nombre de la Tabla : {0}", dt.TableName);
//Mediante Rows accedemos a las filas de la tabla
Console.WriteLine("Cantidad de Filas : {0}", dt.Rows.Count );
//Mediante Columns accedemos a las columnas de la tabla
Console.WriteLine("Cantidad de Columnas : {0}",
dt.Columns.Count);
 }
}

Recorriendo las Filas de un DataTable

Una DataTable, esta conformado por filas (DataRow) y columnas (DataColumn), por lo
que empezaremos recorriendo el primero de ellos. Recuerda que cada fila de un
DataTable, muestra información almacenada para cada uno de los campos que
conforman la definición de la Tabla en una Base de Datos.

Visual C++

/*Método para mostrar las Filas de cada DataTable del DataSet*/

void Imprime_Filas_Tablas(DataSet^ ds)
{
//Puedes cambiar el siguiente foreach por :
//DataTable dt=ds->Tables["Nombre_de_la_Tabla"];
//Para acceder a la tabla que indiques.
for (int i=0;i<ds->Tables->Count-1;i++)
{
for (int j=0;j<ds->Tables[i]->Rows->Count -1;j++)
{
//Si Cambias Nombre_Campo_X, por el nombre de la columna
//Podras adecuar este codigo a la tabla que necesites
Console::WriteLine("Campo 1 : {0}",
ds->Tables[i]->Rows[j]["Nombre_Campo_1"]->ToString());
Console::WriteLine("Campo 2 : {0}",
ds->Tables[i]->Rows[j]["Nombre_Campo_2"]->ToString());
Console::WriteLine("Campo 3 : {0}",
ds->Tables[i]->Rows[j]["Nombre_Campo_3"]->ToString());
//Añade o elimina la cantidad de campos que deseas mostrar
}
}
}

C#

/*Método para mostrar las Filas de cada DataTable del DataSet*/

void Imprime_Filas_Tablas(DataSet ds)
{
//Puedes cambiar el siguiente foreach por :
//DataTable dt=ds.Tables["Nombre_de_la_Tabla"];
//Para acceder a la tabla que indiques.
foreach (DataTable dt in ds.Tables)
{
foreach (DataRow dr in dt.Rows )
{
//Si Cambias Nombre_Campo_X, por el nombre correcto del
campo
//Podras adecuar este código a la tabla que necesites
Console.WriteLine("Campo 1 : {0}",

dr["Nombre_Campo_1"].ToString());
Console.WriteLine("Campo 2 : {0}",
 dr["Nombre_Campo_2"].ToString());
Console.WriteLine("Campo 3 : {0}",

dr["Nombre_Campo_3"].ToString());
//Añade o elimina la cantidad de campos que deseas mostrar
}
}

Recorriendo las Columnas de un DataTable

Por concepto de Base de Datos, una Tabla guarda información de una entidad, esta
información puede ser apellido, nombre, e-mail, etc. y conforman cada uno de los
campos que deseamos recordar para realizar un proceso posterior. Estos campos no son
mas que las columnas del DataTable.

En el código anterior, hemos recorrido las filas del DataTable, es decir la información,
en esta ocasión vamos a recorrer qué campos estamos almacenando en la tabla así como
las propiedades de éstos.

Visual C++

/*Método para mostrar información de las Columnas de cada

DataTable del DataSet*/
void Imprime_Columnas_Tablas(DataSet^ ds)
{
//Puedes cambiar el siguiente foreach por :
//DataTable dt=ds->Tables["Nombre_de_la_Tabla"];
//Para acceder a la tabla que indiques.
for (int i=0;i<ds->Tables->Count-1;i++)
{
for (int j=0;j<ds->Tables[i]->Columns->Count -1;j++)
{
//Para acceder a las propiedades del DataColumn
//Basta con colocar el nombre del objeto seguido de "." y te
//aparece un lista desplegable.
Console::WriteLine("Nombre de la Columna : {0}",
ds->Tables[i]->Columns[j]->ColumnName);
Console::WriteLine("Permite Nulos? : {0}",
ds->Tables[i]->Columns[j]->AllowDBNull-
>ToString());
Console::WriteLine("Tipo de Dato que almacena : {0}",
ds->Tables[i]->Columns[j]->DataType-
>ToString());
Console::WriteLine("Valor por Defecto : {0}",
ds->Tables[i]->Columns[j]->DefaultValue-
>ToString());
}
}

}
C#

/*Método para mostrar información de las Columnas de cada DataTable

del DataSet*/
void Imprime_Columnas_Tablas(DataSet ds)
{
//Puedes cambiar el siguiente foreach por :
//DataTable dt=ds.Tables["Nombre_de_la_Tabla"];
//Para acceder a la tabla que indiques.
foreach (DataTable dt in ds.Tables)
{
foreach (DataColumn dc in dt.Rows)
{
//Para acceder a las propiedades del DataColumn
//Basta con colocar el nombre del objeto seguido de "." y te
//aparece un lista desplegable.
Console.WriteLine("Nombre de la Columna : {0}", dc.ColumnName);
Console.WriteLine("Permite Nulos? : {0}",
dc.AllowDBNull.ToString());
Console.WriteLine("Tipo de Dato que almacena : {0}",
dc.DataType.ToString());
Console.WriteLine("Valor por Defecto : {0}",
dc.DefaultValue.ToString());

}
}
}

Bueno, ya sabemos como recorrer el DataSet, he tratado de ser algo genérico en el

código para que puedas aplicarlo. En un futuro post, veremos como insertar filas, borrar
algunas y modificar las existentes para posteriormente guardar estos cambios en una
Base de Datos.

Conectándonos a SQL Server con ADO.NET parte III

Si ya vimos como recorrer el DataSet y revisar el contenido de un DataTable para ver la
información, ahora aprenderemos como insertar, modificar y eliminar algunas filas para
que puedas manipular la información.

Ya dirán ustedes que quiero imitar a los productores de Rocky o Terminator por la gran
cantidad de secuelas que tienen esos films, pues la respuesta es no!. El objetivo de crear
varias partes para este tema es por lo amplio que es y creo que dividiéndolo en varias
partes es mejor de comprender. En esta ocasión seguiremos trabajando con el DataSet,
pero vamos a aprender a añadir, modificar y eliminar filas de un DataTable.
Recomiendo que antes de continuar leyendo este post, leas estos dos post para que te
orientes mejor:

 Conectándonos a Sql Server con Ado.Net parte I

 Conectándonos a Sql Server con Ado.Net parte II

Algo que aclarar en este punto. Un DataSet es del lado cliente; es decir, los cambios que
se hagan en este sólo se observan en la computadora en la cual se realizan esos cambios,
no se reflejan de manera inmediata a la Base de Datos. Esto se llama trabajar en un
ambiente desconectado.

En esta ocasión lo que voy a hacer es, sobre el proyecto realizado en Conectándonos a
Sql Server con Ado.Net parte II voy a añadir métodos para insertar, modificar y
eliminar una nueva fila. En un siguiente post veremos como crear los métodos
necesarios para trasladar los cambios realizados en el DataSet al Servidor de Base de
Datos.

Trabajando con las Filas

Insertar nueva fila

Antes de ver el código, debes de recordar que el DataTable es quien tiene una colección
de filas, a las cuales podemos acceder mediante la propiedad Rows. Cada uno de los
elementos de esta colección son del tipo DataRow.

Visual C++

/*Método para insertar una Fila en la tabla indicada con

Nombre_Tabla*/
void Insertar_Fila(DataSet^ ds)
{
/*Creamos una nueva Fila en la Tabla indicada*/
DataRow^ dr=ds->Tables["Nombre_Tabla"]->NewRow();
/*Asignamos el valor a cada uno de los campos*/
dr["Nombre_Campo_1"] = Valor_Campo_1;
dr["Nombre_Campo_2"] = Valor_Campo_2;
dr["Nombre_Campo_3"] = Valor_Campo_3;
/*Finalmente añadimos la fila en la colección*/
ds->Tables["Nombre_Tabla"]->Rows->Add(dr);

C#

/*Método para insertar una Fila en la tabla indicada con

Nombre_Tabla*/
void Insertar_Fila(DataSet ds)
{
/*Creamos una nueva Fila en la Tabla indicada*/
DataRow dr=ds.Tables["Nombre_Tabla"].NewRow();
/*Asignamos el valor a cada uno de los campos*/
dr["Nombre_Campo_1"] = Valor_Campo_1;
dr["Nombre_Campo_2"] = Valor_Campo_2;
dr["Nombre_Campo_3"] = Valor_Campo_3;
/*Finalmente añadimos la fila en la colección*/
ds.Tables["Nombre_Tabla"].Rows.Add(dr);
 }

Modificar fila

Entendamos por modificar una fila al hecho de querer modificar información de alguno
de los campos que lo conforman. Si hablamos de modificar una fila, la lógica nos diría
que primero debemos de encontrar la fila que vamos a alterar, por lo que debemos de
tener en cuenta lo siguiente: Cuando definimos una tabla en una Base De Datos, casi
siempre le definimos un campo como llave, de forma tal que este campo identifique a la
información almacenada y no la repitamos. Pero puede darse el caso que la tabla no
tenga llave definida y por lo tanto la información esté repetida.Tomando ambos casos,
voy a definir el código para modificar una fila, bajo dos casos: una tabla con una
columna como llave y en el otro caso una tabla sin llave.

Tabla con llave

Si tenemos una tabla que tiene una llave, debemos de realizar la búsqueda de la
información basándonos en este campo único. Para tal efecto voy a hacer uso de un
método definido en la propiedad Rows del DataTable llamado find.

Visual C++

/*Método para modificar una Fila en la tabla indicada con Nombre_Tabla

y con una llave del tipo int. Si cambias el tipo de dato
del parámetro llave, funciona igual*/
void Modificar_Fila_Tabla_Con_Llave(DataSet ^ds, int llave)
{
/*Buscamos la Fila en la Tabla indicada*/
DataRow^ dr = ds->Tables["Nombre_Tabla"]->Rows-
>Find(llave);
//Comprobamos que la búsqueda nos deje un resultado
if (dr != null)
{
//Activamos la edición de la fila
dr->BeginEdit();
/*Asignamos el nuevo valor a cada uno de los campos
* De preferencia no cambiar el campo llave de la
tabla */
dr["Nombre_Campo_1"] = Nuevo_Valor_Campo_1;
dr["Nombre_Campo_2"] = Nuevo_Valor_Campo_2;
dr["Nombre_Campo_3"] = Nuevo_Valor_Campo_3;
/*Finalmente desactivamos la edición de la fila */
dr->EndEdit();
}

C#

/*Método para modificar una Fila en la tabla indicada con Nombre_Tabla

y con una llave del tipo int. Si cambias el tipo de dato
del parámetro llave, funciona igual*/
 void Modificar_Fila_Tabla_Con_Llave(DataSet ds, int llave)
{
/*Buscamos la Fila en la Tabla indicada*/
DataRow dr = ds.Tables["Nombre_Tabla"].Rows.Find(llave);
//Comprobamos que la búsqueda nos deje un resultado
if (dr != null)
{
//Activamos la edición de la fila
dr.BeginEdit();
/*Asignamos el nuevo valor a cada uno de los campos
* De preferencia no cambiar el campo llave de la
tabla */
dr["Nombre_Campo_1"] = Nuevo_Valor_Campo_1;
dr["Nombre_Campo_2"] = Nuevo_Valor_Campo_2;
dr["Nombre_Campo_3"] = Nuevo_Valor_Campo_3;
/*Finalmente desactivamos la edición de la fila */
dr.EndEdit();
}

Tabla sin llave

Si tenemos una tabla que no tiene una llave, debemos de realizar nuestro método de
búsqueda, basándonos en uno o más campos.

Visual C++

/*Método para modificar una Fila en la tabla indicada con Nombre_Tabla

y con un campo para la busqueda.*/
void Modificar_Fila_Tabla_Sin_Llave(DataSet ^ds, int valorcampo1)
{
int i;
/*Buscamos la Fila en la Tabla indicada por el valor del campo */
for (i=0;i<ds->Tables["Nombre_Tabla"]->Rows->Count-1;i++ )
{
//Al encontrar el campo, terminamos la búsqueda
if (((int)ds->Tables["Nombre_Tabla"]->Rows[i]["Nombre_Campo_1"])
==valorcampo1)
break ;
}
//Comprobamos que la búsqueda nos deje un resultado
if (i<ds->Tables["Nombre_Tabla"]->Rows->Count)
{
DataRow^ dr = ds->Tables["Nombre_Tabla"]->Rows[i];
//Activamos la edición de la fila
dr->BeginEdit();
/*Asignamos el nuevo valor a cada uno de los campos
* De preferencia no cambiar el campo llave de la tabla */
dr["Nombre_Campo_1"] = Nuevo_Valor_Campo_1;
dr["Nombre_Campo_2"] = Nuevo_Valor_Campo_2;
dr["Nombre_Campo_3"] = Nuevo_Valor_Campo_3;
/*Finalmente desactivamos la edición de la fila */
dr->EndEdit();
}
}
C#

/*Método para modificar una Fila en la tabla indicada con Nombre_Tabla

y con un campo para la busqueda.*/
void Modificar_Fila_Tabla_Sin_Llave(DataSet ds, int valorcampo1)
{
int i;
/*Buscamos la Fila en la Tabla indicada por el valor del campo */
for (i=0;i<ds.Tables["Nombre_Tabla"].Rows.Count-1;i++ )
{
//Al encontrar el campo, terminamos la búsqueda
if (((int)ds.Tables["Nombre_Tabla"].Rows[i]["Nombre_Campo_1"])
==valorcampo1)
break ;
}
//Comprobamos que la búsqueda nos deje un resultado
if (i<ds.Tables["Nombre_Tabla"].Rows.Count)
{
DataRow dr = ds.Tables["Nombre_Tabla"].Rows[i];
//Activamos la edición de la fila
dr.BeginEdit();
/*Asignamos el nuevo valor a cada uno de los campos
* De preferencia no cambiar el campo llave de la tabla */
dr["Nombre_Campo_1"] = Nuevo_Valor_Campo_1;
dr["Nombre_Campo_2"] = Nuevo_Valor_Campo_2;
dr["Nombre_Campo_3"] = Nuevo_Valor_Campo_3;
/*Finalmente desactivamos la edición de la fila */
dr.EndEdit();
}
}

Eliminar fila

Así como podemos insertar una nueva fila o modificar una existente, también podemos
eliminarla. Debo de confesar que no tengo por costumbre la eliminación de información
de una Base de Datos. Lo que yo hago es tener un campo adicional que me indica si la
fila esta activa o no, pero no hago una eliminación información, sólo la oculto.

Pero como la eliminación de la información es una posibilidad, es mi deber mostrar

como se hace, por lo que aqui te dejo el código necesario.

Tabla con llave

Visual C++

/*Método para eliminar una Fila en la tabla indicada con

Nombre_Tabla y con una llave del tipo int.Si cambias
el tipo de dato del parámetro llave, funciona igual*/
void Eliminar_Fila_Tabla_Con_Llave(DataSet ^ds, int llave)
{
/*Buscamos la Fila en la Tabla indicada*/
DataRow dr = ds->Tables["Nombre_Tabla"]->Rows-
>Find(llave);
//Comprobamos que la búsqueda nos deje un resultado
 if (dr != null)
{
//Eliminamos la fila encontrada
ds->Tables["Nombre_Tabla"]->Rows->Remove(dr);
}
}

C#

/*Método para eliminar una Fila en la tabla indicada con

Nombre_Tabla y con una llave del tipo int.Si cambias
el tipo de dato del parametro llave, funciona igual*/
void Eliminar_Fila_Tabla_Con_Llave(DataSet ds, int llave)
{
/*Buscamos la Fila en la Tabla indicada*/
DataRow dr = ds.Tables["Nombre_Tabla"].Rows.Find(llave);
//Comprobamos que la búsqueda nos deje un resultado
if (dr != null)
{
//Eliminamos la fila encontrada
ds.Tables["Nombre_Tabla"].Rows.Remove(dr);
}
}

Tabla sin llave

Visual C++

/*Método para eliminar una Fila en la tabla indicada con

Nombre_Tabla y con campos para la busqueda*/

void Eliminar_Fila_Tabla_Sin_Llave(DataSet^ ds, int valorcampo1)

{
int i;
/*Buscamos la Fila en la Tabla indicada por el valor del campo */
for (i = 0; i < ds->Tables["Nombre_Tabla"]->Rows->Count - 1; i++)
{
//Al encontrar el campo, terminamos la búsqueda
if (((int)ds->Tables["Nombre_Tabla"]->Rows[i]["Nombre_Campo_1"])
== valorcampo1)
break;
}
//Comprobamos que la búsqueda nos deje un resultado
if (i < ds->Tables["Nombre_Tabla"]->Rows->Count)
{
//Eliminamos la fila con el índice encontrado
ds->Tables["Nombre_Tabla"]->Rows->RemoveAt(i);
}
}
C#

/*Método para eliminar una Fila en la tabla indicada con

Nombre_Tabla y con campos para la busqueda*/

void Eliminar_Fila_Tabla_Sin_Llave(DataSet ds, int valorcampo1)

{
int i;
/*Buscamos la Fila en la Tabla indicada por el valor del campo */
for (i = 0; i < ds.Tables["Nombre_Tabla"].Rows.Count - 1; i++)
{
//Al encontrar el campo, terminamos la búsqueda
if (((int)ds.Tables["Nombre_Tabla"].Rows[i]["Nombre_Campo_1"]) ==
valorcampo1)
break;
}
//Comprobamos que la búsqueda nos deje un resultado
if (i < ds.Tables["Nombre_Tabla"].Rows.Count)
{
//Eliminamos la fila con el índice encontrado
ds.Tables["Nombre_Tabla"].Rows.RemoveAt(i);
}
}

Luego de revisar como podemos modificar las filas en un DataTable, lo que nos falta es
aprender a llevar estos cambios en el servidor de Base de Datos, para que nuestra
información quede almacenada, actualizada y pueda ser compartida.

Conectándonos a SQL Server con ADO.NET parte IV

Para finalizar esta saga, te dejo lo que hace falta: LLevar la información almacenada en
el DataSet de regreso a la Base de Datos.

Bueno, en los post anteriores ya hemos visto toda una secuencia de como trabajar con
Base de Datos, en el post Conectándonos a SQL Server con ADO.NET parte I,
aprendimos a conectarnos a un servidor MSSQL para obtener la información
almacenada en una tabla y retornarla en un objeto DataSet. En el post Conectándonos a
SQL Server con ADO.NET parte II , lo que hicimos fue trabajar, desde el lado cliente,
con el DataSet, de forma que podamos recorrer los DataTable allí contenidos, así como
recorrer las filas y columnas de cada DataTable, y en el post Conectándonos a SQL
Server con ADO.NET parte III , aprendimos a insertar, modificar y eliminar filas
siempre en el DataSet. Para finalizar la secuencia, en este post lo que haremos es llevar
la información nueva o modificada contenida en un DataSet, de regreso a una Tabla de
una Base de Datos.

Bueno, para tal motivo lo que haremos es trabajar con nuestro proyecto del tipo Class
Library, definido en Conectándonos a SQL Server con ADO.NET parte I, le
agregaremos los métodos necesarios para actualizar la información de un DataSet
recibido como parámetro.
Para poder hacer esto, voy a crear objetos que me permitan ejecutar StoredProdecures
en una base de datos MSSQL, para lo cual, de ser necesarios, voy a insertar parámetros
y asociarle el valor de los campos que han sido modificados recientemente en el
DataSet.

Ahora, cuando insertas, modificas o eliminas, debes de crear 3 objetos Sqlcommand y

asignar, cada uno de ellos, a un objeto SqlAdapter, y es éste último el encargado de
realizar la inserción, modificación o eliminación de cada fila, según sea el caso, en la
Base de Datos, mediante la invocación del método Update.

Como el código es algo amplio, para cada SqlCommand he creado 3 funciones:

Crear_Insert_Command(), Crear_Update_Command(), Crear_Delete_Command(), cada
uno de ellos crea el SqlCommand correspondiente según la acción a realizar. A
continuación te muestro cada uno de ellos

Crear_Insert_Command()

Visual C++

private :SqlCommand^ Crear_Insert_Command()

{

SqlCommand ^inscmd = gcnew

SqlCommand("NOMBRE_STORED_PROCEDURE_PARA_INSERTAR" );
//Indicamos que el comando es un StoredProcedure
inscmd->CommandType = CommandType::StoredProcedure;
/*Debemos insertar cada campo de la fila,
mediante parametros. Para el ejemplo he definido sólo 3
*/
SqlParameterCollection^ insparamcolec = inscmd->Parameters;
SqlParameter^ insparam;
/*Debemos indicar, para cada parametro,
su tipo y de donde obtiene la información*/
insparam = insparamcolec->Add("@NombreCampo1",
SqlDbType::Int, 4, "NombreCampo1");
/*Debemos indicar que el valor del campo lo
obtiene de la version actual del DataSet*/
insparam->SourceVersion = DataRowVersion::Current;
insparam = insparamcolec->Add("@NombreCampo2",
SqlDbType::Float, 8, "NombreCampo2");
insparam->SourceVersion = DataRowVersion::Current;
insparam = insparamcolec->Add("@NombreCampo3",
SqlDbType::VarChar, 50, "NombreCampo3");
insparam->SourceVersion = DataRowVersion::Current;
//Finalmente retornamos el SqlCommand creado
return inscmd;
}

C#

private SqlCommand Crear_Insert_Command()

{
 SqlCommand inscmd = new
SqlCommand("NOMBRE_STORED_PROCEDURE_PARA_INSERTAR" );
//Indicamos que el comando es un StoredProcedure
inscmd.CommandType = CommandType.StoredProcedure;
/*Debemos insertar cada campo a insertar de la fila,
mediante parametros. Para el ejemplo he colocado sólo 3*/
SqlParameterCollection insparamcolec = inscmd.Parameters;
SqlParameter insparam;
/*Debemos indicar, para cada parametro, su tipo
y de donde obtiene la información*/
insparam = insparamcolec.Add("@NombreCampo1",
SqlDbType.Int, 4, "NombreCampo1");
/*Debemos indicar que el valor del campo lo
obtiene de la version actual del DataSet*/
insparam.SourceVersion = DataRowVersion.Current;
insparam = insparamcolec.Add("@NombreCampo2",
SqlDbType.Float, 8, "NombreCampo2");
insparam.SourceVersion = DataRowVersion.Current;
insparam = insparamcolec.Add("@NombreCampo3",
SqlDbType.VarChar, 50, "NombreCampo3");
insparam.SourceVersion = DataRowVersion.Current;
//Finalmente retornamos el SqlCommand creado
return inscmd;
}

Crear_Update_Command()

Visual C++

private :SqlCommand^ Crear_Update_Command()

{
SqlCommand^ updcmd = gcnew
SqlCommand("NOMBRE_STORED_PROCEDURE_PARA_ACTUALIZAR");
//Indicamos que el comando es un StoredProcedure
updcmd->CommandType = CommandType::StoredProcedure;
/*Debemos insertar cada campo a insertar de la fila,
mediante parametros. Para el ejemplo he colocado sólo 3*/
SqlParameterCollection^ updparamcolec = updcmd->Parameters;
SqlParameter^ updparam;
/*Debemos indicar, para cada parametro, su tipo
y de donde obtiene la información*/
updparam = updparamcolec->Add("@NombreCampo1",
SqlDbType::Int, 4, "NombreCampo1");
/*Debemos indicar que el valor del campo
lo obtiene de la version actual del DataSet*/
updparam->SourceVersion = DataRowVersion::Current;
updparam = updparamcolec->Add("@NombreCampo2",
SqlDbType::Float, 8, "NombreCampo2");
updparam->SourceVersion = DataRowVersion::Current;
updparam = updparamcolec->Add("@NombreCampo3",
SqlDbType::VarChar, 50, "NombreCampo3");
updparam->SourceVersion = DataRowVersion::Current;
//Finalmente retornamos el SqlCommand creado
return updcmd;
}
C#

private SqlCommand Crear_Update_Command()

{
SqlCommand updcmd = new
SqlCommand("NOMBRE_STORED_PROCEDURE_PARA_ACTUALIZAR");
//Indicamos que el comando es un StoredProcedure
updcmd.CommandType = CommandType.StoredProcedure;
/*Debemos insertar cada campo a modificar de la fila,
mediante parametros. Para el ejemplo he colocado sólo 3*/
SqlParameterCollection updparamcolec = updcmd.Parameters;
SqlParameter updparam;
/*Debemos indicar que el valor del campo lo
obtiene de la version actual del DataSet*/
updparam = updparamcolec.Add("@NombreCampo1",
SqlDbType.Int, 4, "NombreCampo1");
/*Debemos indicar que el valor del campo lo
obtiene de la version actual del DataSet*/
updparam.SourceVersion = DataRowVersion.Current;
updparam = updparamcolec.Add("@NombreCampo2",
SqlDbType.Float, 8, "NombreCampo2");
updparam.SourceVersion = DataRowVersion.Current;
updparam = updparamcolec.Add("@NombreCampo3",
SqlDbType.VarChar, 50, "NombreCampo3");
updparam.SourceVersion = DataRowVersion.Current;
//Finalmente retornamos el SqlCommand creado
return updcmd;
}

Crear_Delete_Command()

Visual C++

private :SqlCommand^ Crear_Delete_Command()

{
SqlCommand^ delcmd = gcnew
SqlCommand("NOMBRE_STORED_PROCEDURE_PARA_ELIMINAR");
//Indicamos que el comando es un StoredProcedure
delcmd->CommandType = CommandType::StoredProcedure;
/*Debemos insertar cada campo a modificar de la fila,
mediante parametros. Para el ejemplo he colocado sólo 3*/
SqlParameterCollection^ delparamcolec = delcmd->Parameters;
SqlParameter^ delparam;
//Debemos indicar, para cada parametro, su tipo y de donde obtiene la
información
delparam = delparamcolec->Add("@NombreCampo1",
SqlDbType::Int, 4, "NombreCampo1");
/*Debemos indicar que el valor del campo lo
obtiene de la version actual del DataSet*/
delparam->SourceVersion = DataRowVersion::Current;
delparam = delparamcolec->Add("@NombreCampo2",
SqlDbType::Float, 8, "NombreCampo2");
delparam->SourceVersion = DataRowVersion::Current;
delparam = delparamcolec->Add("@NombreCampo3",
 SqlDbType::VarChar, 50, "NombreCampo3");
delparam->SourceVersion = DataRowVersion::Current;
//Finalmente retornamos el SqlCommand creado
return delcmd;
}

C#

private SqlCommand Crear_Delete_Command()

{
SqlCommand delcmd = new
SqlCommand("NOMBRE_STORED_PROCEDURE_PARA_ELIMINAR");
//Indicamos que el comando es un StoredProcedure
delcmd.CommandType = CommandType.StoredProcedure;
//Debemos insertar cada campo de la fila a eliminar.
Para el ejemplo he colocado sólo 3*/
SqlParameterCollection delparamcolec = delcmd.Parameters;
SqlParameter delparam;
/*Debemos indicar, para cada parametro, su tipo
y de donde obtiene la información*/
delparam = delparamcolec.Add("@NombreCampo1",
SqlDbType.Int, 4, "NombreCampo1");
/*Debemos indicar que el valor del campo lo
obtiene de la version actual del DataSet*/
delparam.SourceVersion = DataRowVersion.Current;
delparam = delparamcolec.Add("@NombreCampo2",
SqlDbType.Float, 8, "NombreCampo2");
delparam.SourceVersion = DataRowVersion.Current;
delparam = delparamcolec.Add("@NombreCampo3",
SqlDbType.VarChar, 50, "NombreCampo3");
delparam.SourceVersion = DataRowVersion.Current;
//Finalmente retornamos el SqlCommand creado
return delcmd;
}

Bueno, ya tenemos los métodos que crea cada uno de los SqlCommand. Lo que nos
falta es utilizarlo con un objeto SqlAdapter, por lo que voy a crear una método que cree
al SqlAdapter, invoque a los métodos anteriores y posteriormente grabe la información
en la Base de Datos, mediante el método Update.

Visual C++

public :void Actualiza_Informacion_En_BD(DataSet^ dsupd)

{
/*Creamos un objeto del tipo SqlConnectio*/
SqlConnection^ sqlcon = gcnew SqlConnection();
/*Asignamos la cadena de conexión */
sqlcon->ConnectionString = "DatSource=localhost; initial
catalog=MiBD; user id=sa; password=SsAa";
/*Creamos un sqladapter*/
SqlDataAdapter^ da = gcnew SqlDataAdapter();
da->InsertCommand = Crear_Insert_Command();
da->UpdateCommand = Crear_Update_Command();
da->DeleteCommand = Crear_Delete_Command();
try
{ //Abrimos la conexión a la BD
sqlcon->Open();
try{
//Actualizamos sólo la tabla con el nombre indicado
 da->Update(dsupd,"Nombre_Tabla");
}
__finally{
//Finalmente siempre cerramos la conexión a la BD
sqlcon->Close();
}
}
catch(...)
{ //Ante cualquier error lanzamos la excepción
throw ;
}

C#
public void Actualiza_Informacion_En_BD(DataSet dsupd)
{
/*Creamos un objeto del tipo SqlConnectio*/
SqlConnection sqlcon = new SqlConnection();
/*Asignamos la cadena de conexión */
sqlcon.ConnectionString = "DatSource=localhost;
initial catalog=MiBD; user id=sa; password=SsAa";
/*Creamos un sqladapter*/
SqlDataAdapter da = new SqlDataAdapter();
//Asociamos los SqlCommand respectivos
da.InsertCommand = Crear_Insert_Command();
da.UpdateCommand = Crear_Update_Command();
da.DeleteCommand = Crear_Delete_Command();
try
{ //Abrimos la conexión a la BD
sqlcon.Open();
//Actualizamos sólo la tabla con el nombre indicado
da.Update(dsupd, "Nombre_Tabla");
}
catch
{ //Ante cualquier error lanzamos la excepción
throw;
}
finally
{
//Finalmente siempre cerramos la conexión a la BD
sqlcon.Close();
}

He tratado de resumir en 4 post todo lo que tienes que hacer para conectarte a una base
de datos y poder obtener información, posteriormente cambiarla y de nuevo regresarla a
la base de datos, espero que al leer todo te haya quedado claro lo que debes de hacer,
pero si tienes algún problema, no dudes en dejar un comentario
ADO.NET
http://copstone.com/2010/02/ado-net/

Para realizar una aplicación que interactúe con una Base de Datos, en Visual Studio,
debes de conocer algunos conceptos nuevos, empieza aprendiendo qué es ADO.NET.

Cuando Microsoft creó la plataforma .NET, cambió por completo los componentes que
se tenían hasta entonces para trabajar con las diversas Bases de Datos del mercado. Esta
revolución no sólo implica componentes, sino clases y librerías que involucran el
manejo, control y consumo de un origen de datos cualquiera, incluyendo archivos XML.

ADO.NET (Activex Data Objects .Net), es considerado como una evolución de ADO,
versión que venía hasta Visual Basic 6.0, pero para ser sincero y a mi manera de ver las
cosas, no se parecen, son conceptos e ideas de trabajo distintas.

Lo que se busca con ADO.NET, es de separar dos cosas: El origen o proveedor de los
datos (La Base de Datos) y el manejo de la información luego de ser extraída. En la
siguiente imagen, podemos apreciar de qué estamos hablando.

En el primer caso, izquierda de la imagen, estamos hablando de todos los componentes

para conectarse a una base de datos, reconocer los tipos de datos que esta maneja,
control de acceso, realizar transacciones, ejecutar stored procedures para realizar
actualizaciones, inserciones, eliminaciones, etc. Mientras que en el segundo caso,
estamos hablando de cómo manejar la información, extraída del servidor, en el lado
cliente mediante un DataSet.

Cuando hablamos que ADO.NET, encierra a todo el conjunto de clases que nos
permiten trabajar con las diversas bases de datos, no podemos negar que trabaja
perfectamente con MS. SQL Server, pero de manera particular he trabajado muy bien
con MySql, PostGres, Oracle y archivos XML, por lo que puedo dar fe de lo bien que se
maneja la información.

Namespace de ADO.NET
Recuerda, cuando hablamos de ADO.NET, estamos hablando de un conjunto de clases
o librerías que permiten interactuar con una fuente de datos (no necesariamente es un
SQL Server u Oracle, puede ser un archivo XML, MySql, Postgres, etc.). Por lo que es
necesario saber donde se encuentran estas clases y cuáles son los namespace que los
agrupan.

 System.Data

Engloba las clase principal para poder trabajar con la información extraída en el lado
cliente: DataSet.

 System.Xml

XML es un estándar de intercambio de información, por lo que bajo este namespace se

encuentran las clases que proporcionan funcionalidad basada en estándares para
procesar código XML.

 System.Data.OleDb

.Net Framework trae, por defecto, en ADO.NET las clases que proporcionan conexión y
funcionalidad para orígenes de datos compatibles con OLE DB. Estas clases permiten
conectarse a un origen de datos OLE DB, ejecutar comandos en el origen y leer los
resultados.

 System.Data.SqlClient

En este namespace que engloba a las clases que conforman el proveedor de datos
de .NET Framework para MS SQL Server.

 System.Data.SqlTypes

Proporciona clases para tipos de datos nativos de MS SQL Server. Estas clases
ofrecen una alternativa más segura y más rápida a otros tipos de datos.

 System.Data.OracleClient

Clases que componen el proveedor de datos de .NET Framework para Oracle. Estas
clases permiten el acceso a orígenes de datos Oracle en el espacio administrado.

Interactuando con ADO.NET

ADO.Net, representa únicamente a los componentes necesarios para consumir y
manipular la información que existe en una base de datos, pero no reemplaza a las capas
o medios que son responsables de mostrar o presentar al usuario al información que ha
sido extraída.

Un error común o como dicen algunos, una mala práctica, de un programador que recién
se inicia es colocar todo el código en una sola unidad, clase o librería. Este error, si no
lo corriges a tiempo te puede originar muy serios problemas si estamos hablando de
construir aplicaciones profesionales y sobre todo, mantenibles en el tiempo.

La idea cuando un programador empieza a trabajar con Base de Datos es la de

inculcarle que, mientras más estén separadas las funcionalidades dentro de una
aplicación, es mucho mejor. Por ejemplo: si tienes una aplicación visual que muestra
información desde una base de datos, debes de pensar en lo siguiente:

 Definir un formulario que tenga los controles necesarios para mostrar la información.
 Definir una clase, aparte del formulario, si es posible en un proyecto del tipo Class
Library, que sea la responsable de conectarse a la Base de Datos y de llevarle la
información al formulario.

Por ningún motivo, trates de juntar todo en un sólo proyecto, por más pequeña que sea
tu aplicación, te recomiendo siempre hacer las cosas como se deben.

Bajo lo antes escrito, te presento el siguiente diagrama:

Para los que lo han visto antes, claramente pueden saber que se trata de un diagrama de
capas o niveles, en donde cada recuadro, tiene un nombre basado en la responsabilidad
que cumple dentro de la aplicación. El primero es capaz de mostrar la información al
usuario (sea en Web o Windows), el segundo – donde esta ADO.NET- es llamado el
nivel de negocios y el tercero donde está la información es el Nivel de datos. Este es un
diagrama base, pero cada uno puede tener su propia versión, siempre y cuando respete
que cada nivel cumple con una funcionalidad diferenciada a las demás.
Resumen

Espero que este artículo te haya servido para entender básicamente lo siguiente acerca
de ADO.NET:

 Es la forma de trabajo que brinda .Net Framework para trabajar con diversos tipos de
orígenes de datos, teniendo mejor relación con MS SQL Server, pero trabaja sin
problemas con todas las existentes en el mercado.
 Engloba un conjunto de librerías, clases que permiten definir objetos para interactuar
con los diversos orígenes de datos.

 Engloba clases tanto para conexión al origen de datos, como manejo de los mismos
luego que éstos son extraídos y colocados en la aplicación cliente.

 La idea de trabajar con ADO.NET, es de ir aprendiendo que dentro de una aplicación,

cada componente tiene una funcionalidad y la de ADO.NET es de trabajar con los datos
almacenados en un origen de datos.

Cadenas de Conexión en ADO.NET

http://copstone.com/2010/02/cadenas-de-conexion-en-ado-net/

Si crees que sólo hace falta saber de objetos, clases, etc. para conectarse a una Base de
Datos, pues te equivocas, tienes que saber también de Servidor, usuarios, passwords,
etc. Te dejo este post para que completes tu información y puedas aprender como
conectarte a una Base de Datos

En un post anterior escribí acerca de ADO.NET, expliqué que nos brinda componentes
para conectarte a un servidor de base de datos y extraer la información para mostrarla en
una aplicación cliente.

Bueno, una cosa es tener el componente o la clase que permita definir objetos para
conectarse a un servidor y otra muy distinta es tener acceso a un servidor (remoto por lo
general) mediante un usuario y password que tenga los niveles de acceso respectivos
para poder realizar las acciones que sean necesarias.

Teniendo en cuenta esto último, podemos decir entonces que necesitamos dos cosas
para conectarnos a una Base de Datos:

1. Un objeto llamado Connection, el cual depende del origen de datos al cual deseamos
conectarnos. Puede ser: SqlConnection – si nos vamos a conectar a una Base de Datos
MS SQL SERVER- OleDbConnection, ODBCConnection, etc. Cada una definida y
declarada en su namespace respectivo.
2. Y tener información acerca de: Nombre del Servidor de BD (puede ser local o remoto),
Nombre de la BD, un usuario en la BD y un password o en su defecto que el usuario
 con el cual accedes a Windows, tenga acceso al servidor de BD, todos estos
almacenados en una cadena, llamada comúnmente cadena de conexión.

Partes de una Cadena de Conexión

Ya he mencionado que una cadena de conexión, es una cadena – valga la redundancia-
que guarda información, básicamente de: Servidor, Base de Datos, usuario, password,
pero debemos saber como se maneja la información.

Nombre del
Descripción
Campo

Hace referencia al servidor de Base de datos. A este campo se le puede asignar

uno de los siguientes valores:
Data Source o
El nombre del equipo servidor, por ejemplo: BDEJEMPLO
Server
La IP del servidor, por ejemplo: 10.10.1.1
La instancia del servidor de Base de Datos, por ejemplo: (LOCAL)\SQLINSTANCE

Initial Catalog Hace referencia a la Base de datos contenida en el Data Source indicado, debe
o DataBase de escribirse el nombre de la base de datos, no el nombre de la tabla.

Hace referencia al nombre del usuario de la base de datos con el cual se

user id
accederá a la base de datos.

password Hace referencia a la constraseña del usuario indicado en user id.

Este campo se usa sólo si no vamos a usar los dos anteriores e indica que el
Integrated usuario con el cual vamos a ingresar a trabajar al servidor de base de datos es
Security igual al que hemos usado para iniciar sesión en Windows. El valor de este campo
es True.

Con estas secciones, entonces nuestra cadena de conexión la podemos ir armando de la

siguiente forma:

Opción 1: Acceso a un servidor de Base de Datos con usuario de base de datos

Data Source=<miservidorBD>;Initial Catalog=<miBasedeDatos>; user
id=<miusuario>;
password=<password>;

Opción 2: Acceso a un servidor de Base de Datos con usuario de Windows.

Data Source=<miservidorBD>;Initial Catalog=<miBasedeDatos>; Integrated
Security= True;

Ejemplos de Cadena de Conexión

La cadena de conexión depende principalmente de la Base de datos a la cual deseamos
conectarnos, el ejemplo más clásico es hacer una cadena de conexión para conectarnos a
MS SQL SERVER, pero y si quiero conectarme a MySql? y si quiero conectarme a
Postgres? o a Access?, bueno aquí te dejo algunas cadenas de conexión que te pueden
ayudar en algunos casos.

Antes de darte los ejemplos es necesario que aclare algo, de la forma como estoy
acostumbrado a programar, mis cadenas de conexión, no tienen el campo Integrated
Security, siempre usan un usuario y un password de la Base de Datos, así sea una
aplicación sencilla o pequeña, por lo que los ejemplos que pondré son de este tipo.

Cadena de conexión para MS SQL

"Data Source=<SERVIDOR>;Initial Catalog=<BASE DE DATOS>;User
Id=<USUARIO>;
Password=<PASSWORD>"

Cadena de conexión para MySql

"Driver={MySQL ODBC 3.51
Driver};Server=<SERVIDOR>;Port=3306;Database=<BASE DE DATOS>;
User id =<USUARIO>;Password=<PASSWORD>;Option=3;"

Cadena de conexión para Postgres

"Server=<IP SERVIDOR>;Port=5432;Database=<BASE DE DATOS>;User
id=<USUARIO>;
Password=<PASSWORD>;"

Cadena de conexión para Access 2007

"Provider=Microsoft.ACE.OLEDB.12.0;Data Source= <RUTA DEL
ARCHIVO ACCESS>;
Jet OLEDB:Database Password=<PASSWORD>;"

Por último te dejo esta página http://www.connectionstrings.com para que puedas

consultar más acerca de las diversas variaciones que puede tener una cadena de
conexión.
Algunos tips para crear una buena base de datos
http://copstone.com/2010/04/algunos-tips-para-crear-una-buena-base-de-datos/

Crear una Base de Datos, resulta tan importante como saber que componentes vas a usar
o que tecnología, te dejo este post para compartirte 5 puntos que siempre cumplo para
crear mis bases de datos.

Qué levante la mano aquel que no se ha hecho la pregunta de, existe alguna plantilla
para crear un buen modelo entidad relación (E-R)?.

Bueno, yo me hice esa pregunta, y aunque he realizado varios modelos entidad relación,
les puedo asegurar que muchas veces me han cuestionado cosas como : y por qué
normalizaste, o y por que no normalizaste?, porque tantos o tan pocos stored
procedures?, cuál es tu estándar? y una serie de preguntas, cuya respuestas me han
ayudado a ir mejorando mis modelos E-R y por lo tanto mis bases de datos.

De manera particular, te puedo comentar que cuando estoy armando una Base de datos,
y luego de puesta en producción, tengo en cuenta muchos factores, pero te voy a
compartir los que considero sumamente importantes:

Toma el tiempo justo para un buen diseño

La experiencia o los años, como quieras verlos, te van a enseñar que antes de crear tu
BD, en el motor de BD que prefieras, debes de sentarte, pensar y diagramar, el modelo
que va a almacenar la información que quieres manejar con tu aplicación. Debes de
tomarte el tiempo para identificar aquella información que cambia gracias a las
transacciones que se van llevando y también, identifica las que no cambian en el tiempo
y se mantienen estáticas. Normaliza las tablas que lo requieran, no soy partidario de
normalizar todo, pero si lo necesario. Una vez alguien me dijo: "Es buena la
normalización, pero no debes abusar de la misma", y es verdad, no es bueno tener todos
tus datos normalizados, solo los necesarios.

Define tu estándar

Punto clave luego de cumplido el anterior, sin un estándar para llamar a los campos, a
las entidades, para definir los tipos de datos, hasta para llamar los archivos, es
sumamente importante. Recuerda que la memoria es frágil y quizás no recuerdes lo que
hiciste luego de una semana, es mejor tener todo estandarizado de forma que sea fácil de
entender. Estandarizar es sumamente recomendable si se trabaja en equipo.

Define Llaves primarias adecuadas

Cuando uno normaliza una BD, tiende a colocar como llave primaria de una tabla un
campo que represente a la entidad que allí se almacena. Otros en cambio suelen colocar
un campo, autogenerado, como llave primaria de una tabla. En particular, cuando se
trata de llaves primarias, yo hago lo siguiente:

 Siempre defino un campo entero como llave primaria.

 Especifica esta columna como NOT NULL
 Trato que cada tabla tenga sólo una llave primaria.
 Trato que el campo que será la llave, no tenga relación con los datos que allí se
almacenan.
 En el campo llave principal, utiliza la opción de autoincremento, en los casos
que sea necesario, no abuses.

Usa Stored Procedures sin mucha lógica

Es casi "normal", hacer stored procedures con mucha lógica, pero te pido que te tomes
tu tiempo para analizar si realmente lo necesitas. Me explico, muchos programadores
tienden a colocar la lógica del negocio en los stored procedures, no digo que sea malo,
pero el abuso de esto, te puede traer problemas si de rendimiento y performance
hablamos. Realiza tus stored procedures de forma que hagan su trabajo lo más rápido
posible.

No utilices Select * para tus consultas

Cuando hacemos una consulta, lo hacemos esencialmente para traer información

importante de la base de datos, no tiene sentido traer toda la información por lo que
usar ( * ), hace trabajar al motor de base de datos mas de lo que se necesita. Te
recomiendo armar tus Select indicando el nombre de los campos que quieres obtener, de
forma que la información sea puntual, trabaje menos el motor de BD, y sobre todo si
alguien "intercepta" la consulta no obtiene más información de la que debe.

Espero que estos 5 tips te ayuden al momento de definir tus bases de datos de ahora en
adelante. Para terminar este post, te dejo unas líneas con respecto a una Base de Datos:
la práctica te enseña que no siempre la teoría es buena, pero si te enseña que es
sumamente útil para saber lo que haces, sobre todo si de normalización se trata.