Clase de conexion a BD (C# ASP.NET)

[irit]

Que tal:

Estoy tratando de hacer una clase de conexión a BD la cual contenga metodos para realizar la apertura y cerradura de conexion a la BD y metodos para le llenado de Dropdownlist, etc.

El primer problema que me he topado es que desconozco la diferencia entre usar ADO NET, ODBC, OleDB.... No se en que consista el usar una y otra :S

Mi segunda duda es como hacer uso del string de conexion tomandolo desde el archivo Web.Config.


Agradezco de antemano sus respuestas.

Saludos.

[jaullo]

http://www.forosdelweb.com/f69/difer...ole-db-595201/

Un poco resumido sería

ODBC
Es un estándar de acceso a bases de datos que utilizan los sistemas Microsoft. Las siglas significan Open DataBase Connectivity. A través de ODBC, un sistema Windows se puede conectar con cualquier base de datos. Bueno habría que decir que permite conectar con cualquier base de datos de la que exista un driver ODBC. Los creadores de las distintas bases de datos son los responsables de crear un driver ODBC para que su base de datos se pueda conectar desde un sistema Microsoft.


OLEDB
OLEDB es el sucesor de ODBC, un conjunto de componentes de software que permiten un "front end", como la interfaz gráfica de usuario basada en VB, C + +, acceso o lo que sea para contactar con un back-end tales como SQL Server, Oracle, DB2, mySQL. En muchos casos los componentes OLEDB ofrecen un rendimiento mucho mejor que la anterior ODBC.

OLEDB es un tipo diferente de proveedor de datos que se produjo con el acceso universal de datos de MS en 1996 y no requiere que haya configurado un DSN. Es comúnmente usado en la construcción de aplicaciones de VB y está estrechamente vinculada a ADO. Funciona con COM y DCOM como de SQL 7.0.

ADO.NET
ADO.NET es un conjunto de clases que exponen servicios de acceso a datos, ofrece muchos componentes para la creación de aplicaciones de uso compartido de datos distribuidas. Constituye una parte integral de .NET Framework y proporciona acceso a datos relacionales, XML y de aplicaciones. ADO.NET satisface diversas necesidades de desarrollo.
Para conectar con ODBC una base de datos se ha de crear un DSN, que es un nombre que asociamos a una conexión por ODBC para referirnos a ella desde las aplicaciones o programas que deban conectarse con la base de datos.

En cuanto al connection string desde esl webconfig, esta es la forma de obtnenerlo

Código ASP:

Dim strConnString As String = ConfigurationManager.ConnectionStrings("LocalSqlServer").ConnectionString
 

[BlueSkull]

Estimado visita mi blog ahi se encuentra la conexion.
Adios.

[irit]

Iniciado por BlueSkull

Estimado visita mi blog ahi se encuentra la conexion.
Adios.

Gracias. Lo voy a revisar. Saludos.

[mihina]

Mira Gracias a jaullo consegui connectar mi odbc desde Web.config:

en Web.config pon:
<connectionStrings>
<add name="OdbcHotel" connectionString="Driver={SQL Server};Server=MERCHE\SQLEXPRESS; Database=Hotel" providerName="System.Data.Odbc" />
</connectionStrings>

MERCHE\SQLEXPRESS : Es tu usuario de SQL Server te aparece cuando lo abres
Database=Hotel" : donde pongo Hotel pon tu base de datos.


Luego desde las otras paginas aspx.cs para llamar esta connexion es:

string strcon = ConfigurationManager.ConnectionStrings["OdbcHotel"].ConnectionString;
OdbcConnection con = new OdbcConnection(strcon);

OdbcCommand catCMD = new OdbcCommand("GENERAS LA CONSULTA", con);
con.Open(); // ABRES CONNEXION
catCMD.ExecuteNonQuery(); //EJECUTAS LA CONSULTA
con.Close(); // CIERRAS CONEXION.

PD: yo soy novata en asp net justo ahora estoy aprendiendo, espero que te sea util

[papurri]

amigo yo uso la clase de conexion de una app que encontre en el sitio del desarrollador 5 estrellas. contiene muchos metodos como por ejemplo:
apertura y cierre de conexion, crea comandos , ejecuta consultas entre otras cosas. te dejo el codigo:


using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.Common;
using System.Configuration;

namespace DCE05.Ejemplos.EstrellaUno.AccesoDatos {

/// <summary>
/// Representa la base de datos en el sistema.
/// Ofrece los métodos de acceso a misma.
/// </summary>
public class BaseDatos {

private DbConnection conexion = null;
private DbCommand comando = null;
private DbTransaction transaccion = null;
private string cadenaConexion;

private static DbProviderFactory factory = null;

/// <summary>
/// Crea una instancia del acceso a la base de datos.
/// </summary>
public BaseDatos() {
Configurar();
}

/// <summary>
/// Configura el acceso a la base de datos para su utilización.
/// </summary>
/// <exception cref="BaseDatosException">Si existe un error al cargar la configuración.</exception>
private void Configurar() {
try {
string proveedor = ConfigurationManager.AppSettings.Get("PROVEEDOR_AD ONET");
this.cadenaConexion = ConfigurationManager.AppSettings.Get("CADENA_CONEX ION");
BaseDatos.factory = DbProviderFactories.GetFactory(proveedor);
} catch (ConfigurationException ex) {
throw new BaseDatosException("Error al cargar la configuración del acceso a datos.", ex);
}
}

/// <summary>
/// Permite desconectarse de la base de datos.
/// </summary>
public void Desconectar()
{
if( this.conexion.State.Equals(ConnectionState.Open) )
{
this.conexion.Close();
}
}

/// <summary>
/// Se concecta con la base de datos.
/// </summary>
/// <exception cref="BaseDatosException">Si existe un error al conectarse.</exception>
public void Conectar()
{
if (this.conexion != null && !this.conexion.State.Equals(ConnectionState.Closed )) {
throw new BaseDatosException("La conexión ya se encuentra abierta.");
}
try {
if (this.conexion == null) {
this.conexion = factory.CreateConnection();
this.conexion.ConnectionString = cadenaConexion;
}
this.conexion.Open();
} catch (DataException ex) {
throw new BaseDatosException("Error al conectarse a la base de datos.", ex);
}
}

/// <summary>
/// Crea un comando en base a una sentencia SQL.
/// Ejemplo:
/// <code>SELECT * FROM Tabla WHERE campo1=@campo1, campo2=@campo2</code>
/// Guarda el comando para el seteo de parámetros y la posterior ejecución.
/// </summary>
/// <param name="sentenciaSQL">La sentencia SQL con el formato: SENTENCIA [param = @param,]</param>
public void CrearComando(string sentenciaSQL)
{
this.comando = factory.CreateCommand();
this.comando.Connection = this.conexion;
this.comando.CommandType = CommandType.Text;
this.comando.CommandText = sentenciaSQL;
if (this.transaccion != null) {
this.comando.Transaction = this.transaccion;
}
}

/// <summary>
/// Setea un parámetro como nulo del comando creado.
/// </summary>
/// <param name="nombre">El nombre del parámetro cuyo valor será nulo.</param>
public void AsignarParametroNulo(string nombre)
{
AsignarParametro(nombre, "", "NULL");
}

/// <summary>
/// Asigna un parámetro de tipo cadena al comando creado.
/// </summary>
/// <param name="nombre">El nombre del parámetro.</param>
/// <param name="valor">El valor del parámetro.</param>
public void AsignarParametroCadena(string nombre, string valor) {
AsignarParametro(nombre, "'", valor);
}

/// <summary>
/// Asigna un parámetro de tipo entero al comando creado.
/// </summary>
/// <param name="nombre">El nombre del parámetro.</param>
/// <param name="valor">El valor del parámetro.</param>
public void AsignarParametroEntero(string nombre, int valor) {
AsignarParametro(nombre, "", valor.ToString());
}

/// <summary>
/// Asigna un parámetro al comando creado.
/// </summary>
/// <param name="nombre">El nombre del parámetro.</param>
/// <param name="separador">El separador que será agregado al valor del parámetro.</param>
/// <param name="valor">El valor del parámetro.</param>
private void AsignarParametro(string nombre, string separador, string valor) {
int indice = this.comando.CommandText.IndexOf(nombre);
string prefijo = this.comando.CommandText.Substring(0, indice);
string sufijo = this.comando.CommandText.Substring(indice + nombre.Length);
this.comando.CommandText = prefijo + separador + valor + separador + sufijo;
}

/// <summary>
/// Asigna un parámetro de tipo fecha al comando creado.
/// </summary>
/// <param name="nombre">El nombre del parámetro.</param>
/// <param name="valor">El valor del parámetro.</param>
public void AsignarParametroFecha(string nombre, DateTime valor)
{
AsignarParametro(nombre, "'", valor.ToString());
}

/// <summary>
/// Ejecuta el comando creado y retorna el resultado de la consulta.
/// </summary>
/// <returns>El resultado de la consulta.</returns>
/// <exception cref="BaseDatosException">Si ocurre un error al ejecutar el comando.</exception>
public DbDataReader EjecutarConsulta()
{
return this.comando.ExecuteReader();
}

/// <summary>
/// Ejecuta el comando creado y retorna un escalar.
/// </summary>
/// <returns>El escalar que es el resultado del comando.</returns>
/// <exception cref="BaseDatosException">Si ocurre un error al ejecutar el comando.</exception>
public int EjecutarEscalar()
{
int escalar = 0;
try {
escalar = int.Parse(this.comando.ExecuteScalar().ToString()) ;
} catch (InvalidCastException ex) {
throw new BaseDatosException("Error al ejecutar un escalar.", ex);
}
return escalar;
}

/// <summary>
/// Ejecuta el comando creado.
/// </summary>
public void EjecutarComando()
{
this.comando.ExecuteNonQuery();
}

/// <summary>
/// Comienza una transacción en base a la conexion abierta.
/// Todo lo que se ejecute luego de esta ionvocación estará
/// dentro de una tranasacción.
/// </summary>
public void ComenzarTransaccion()
{
if( this.transaccion == null )
{
this.transaccion = this.conexion.BeginTransaction();
}
}

/// <summary>
/// Cancela la ejecución de una transacción.
/// Todo lo ejecutado entre ésta invocación y su
/// correspondiente <c>ComenzarTransaccion</c> será perdido.
/// </summary>
public void CancelarTransaccion()
{
if( this.transaccion != null )
{
this.transaccion.Rollback();
}
}

/// <summary>
/// Confirma todo los comandos ejecutados entre el <c>ComanzarTransaccion</c>
/// y ésta invocación.
/// </summary>
public void ConfirmarTransaccion()
{
if( this.transaccion != null )
{
this.transaccion.Commit();
}
}

}
}