Publicidad

ADO.NET. Proveedor de acceso a datos genérico


Por Alex el 24/07/2005 , Comentar el artículo

Comparte este artículo:        




A veces tenemos la necesidad en nuestras aplicaciones de acceder a diferentes orígenes de datos, SQL Server, Oracle, MySql, Access, etc … y para poder conectar con cada uno de ellos necesitamos crear diferentes clases de acceso a datos, que en el fondo es repetir código cambiando el proveedor de acceso. Una solución para no tener que realizar código para cada origen de datos es crear un proveedor de acceso a datos genérico.


Voy a realizar un ejemplo que podréis incluir en vuestras aplicaciones y ampliarlo según vuestras necesidades. Una clase de acceso a datos genérica que pasando una serie de parámetros puede servir para cualquier origen de datos. Con ésto nos ahorraremos tener que escribir código para cada uno de los orígenes de datos que necesitemos utilizar.

La filosofía de desarrollo es la misma que si estuviéramos utilizando un único origen de datos, por ejemplo SQL Server, en este caso utilizaríamos los métodos SqlConnection, SqlCommand, etc … Pero en lugar de utilizar un proveedor especifico para cada origen de datos vamos a utilizar un proveedor genérico que va a servir para todos. Utilizaremos los interfaces definidos en el espacio de nombre System.Data:

  • IDbConnection
  • IDbCommand
  • IDataAdapter
  • IDataParameter.

A través de los cuales podremos asociar cualquier proveedor de acceso a datos especifico, como por ejemplo SQL Server.

IDbConnection

Es el interface que va a representar una conexión abierta con un origen de datos.

Clases que implementan IDbConnection:

  • OdbcConnection
  • OleDbConnection
  • OracleConnection
  • SqlConnection
  • SqlCeConnection

En el momento de abrir nuestra conexión a tenemos que asociarlo al proveedor de datos que queremos utilizar. Un método para realizar la conexión quedaría de la siguiente forma:

private static IDbConnection GetConnection() {
 IDbConnection objectConnection = new SqlConnection(_ConnectionString);

 objectConnection.Open();

 return (objectConnection);
}

Con este código tendríamos una conexión con el proveedor de datos SqlClient.

Si ahora queremos ampliar el abanico de proveedores solo necesitamos pasar el tipo de proveedor por parámetros y añadir una sentencia switch, que diferencie el tipo de proveedor:

private static IDbConnection GetConnection(string providerType) {
 IDbConnection objectConnection;

 switch (providerType) {
  case "Provider_SqlClient":
   objectConnection = new SqlConnection(_ConnectionString);
   break;
  case "Provider_OleDb":
   objectConnection = new OleDbConnection(_ConnectionString);
   break;
  case "Provider_Odbc":
   objectConnection = new OdbcConnection(_ConnectionString);
   break;
  default:
   throw(new Exception("Tipo invalido de proveedor"));
 }
 objectConnection.Open();
 return (objectConnection);
}

Con este método obtenemos una conexión para tres tipos de proveedores, si necesitáramos más como por ejemplo Oracle, solo tendríamos que añadirlo.

IDbCommand

Representa la ejecución de un comando.

Clases que implementan IDbCommand:

  • ObdcCommand
  • OleDbCommand
  • OracleCommand
  • SqlCommand
  • SqlCeCommand

Igual que sucede con IDbConnection debemos asociarlo al proveedor de datos correspondiente.

private static IDbCommand CreateCommand(string providerType) {
 IDbCommand objectCmd;
 switch (providerType) {
  case "Provider_SqlClient":
   objectCmd = new SqlCommand();
   break;
  case "Provider_OleDb":
   objectCmd = new OleDbCommand();
   break;
  case "Provider_Odbc":
   objectCmd = new OdbcCommand();
   break;
  default:
   throw(new Exception("Invalid provider type"));
 }

 return (objectCmd);
}

En este caso obtendremos un objeto command definido para nuestro proveedor de acceso a datos.

IDataAdapter

Representa un DataAdapter, un cojunto de resultados que podemos utilizar y asociar a un DataSet.

Clases que implementan IDataAdapter:

  • DataAdapter

    Igual que sucede con los anteriores tenemos que asociar el IDataAdapter con el correspondiente proveedor de acceso que utilicemos.

    IDataAdapter da;
    switch (providerType) {
     case "Provider_SqlClient":
      da = new SqlDataAdapter((SqlCommand)cmd);
      break;
     case "Provider_OleDb":
      da = new OleDbDataAdapter((OleDbCommand)cmd);
      break;
     case "Provider_Odbc":
      da = new OdbcDataAdapter((OdbcCommand)cmd);
      break;
     default:
      throw(new Exception("Invalid provider type"));
    }

    En la siguiente página explicaré la estructura de la clase GenericDataAccess.cs y cómo se puede ampliar.

    Generis Data Access

    Como podéis comprobar a través de estos interfaces genéricos podemos crear clases de acceso a datos que nos sirvan para cualquier proveedor.

    En el ejemplo que viene con el artículo hay una clase llamada GenericDataAccess.cs. A través de esta clase tenéis los métodos básicos para conectar y obtener un conjunto de resultados con los proveedores de acceso a datos.

    Definimos las contantes donde especificamos los proveedores que vamos a utilizar.

    public const string PROVIDER_SQLCLIENT = "Provider_SqlClient";
    public const string PROVIDER_OLEDB = "Provider_OleDb";
    public const string PROVIDER_ODBC = "Provider_Odbc";

    Creamos dos variable para asignar mediante propiedades la sentencia SQL que ejecutaremos y el tipo de conexión.

    private static string _sqlQuery = string.Empty;
    private static string _ConnectionString = string.Empty;
    //
    public static string SetConnectionString {
     set {
      _ConnectionString = value;
     }
    }
    //
    public static string SetSqlQuery {
     set {
      _sqlQuery = value;
     }
    }

    Método para obtener una conexión

    private static IDbConnection GetConnection(string providerType) {
    // Código explicado en el articulo
    }

    Método para obtener un commando

    private static IDbCommand CreateCommand(string providerType) {
    // Código explicado en el articulo
    }

    Creamos un método para obtener un DataSet a través de la ejecución de un DataAdapter.

    public static DataSet ExecuteDataset(string providerType) {
     //
     // Creamos una conexión
     IDbConnection connection = GetConnection(providerType);
     // Creamos un comando
     IDbCommand cmd = CreateCommand(providerType);
     //
     // Creamos un DataAdpater genérico y lo asignamos a tipo de //proveedor
     //
     IDataAdapter da;
     switch (providerType) {
      case "Provider_SqlClient":
       da = new SqlDataAdapter((SqlCommand)cmd);
       break;
      case "Provider_OleDb":
       da = new OleDbDataAdapter((OleDbCommand)cmd);
       break;
      case "Provider_Odbc":
       da = new OdbcDataAdapter((OdbcCommand)cmd);
       break;
      default:
       throw(new Exception("Invalid provider type"));
     }

     cmd.Connection = connection;
     cmd.CommandType = CommandType.Text;
     cmd.CommandText = _sqlQuery;

     DataSet ds = new DataSet();

     da.Fill(ds);
     //

     connection.Close();

     return ds;
    }

    Como podéis ver el código es muy simple y sencillo. Ahora solo queda por vuestra parte que añadáis los restantes métodos que quedan para trabajar con orígenes de datos: ExecuteNonQuery, ExecuteEscalar, Excetureader, etc… y tendréis una clase completa de acceso a datos que os servirá para cualquier proveedor.

    El código fuente que acompaña al articulo, a parte de la clase de acceso a datos, contiene un ejemplo ejecutando un DataGrid con tres orígenes de datos diferentes.

    Enlaces relacionadas:

    Codigo fuente del artículo 

    Saludos
    Alex


    Si te ha gustado el artículo compartelo en:        


    Publicidad

    También puede interesarte:

    Instalar .NET Core en Ubuntu

    Instalar .NET Core en Ubuntu

    Por Alex, el 07/02/2020

    Limpiar datos de un combobox en winforms.

    Limpiar datos de un combobox en winforms.

    Por Alex, el 23/03/2010

    Crear, copiar y borrar bases de datos SQL Server desde c#.

    Crear, copiar y borrar bases de datos SQL Server desde c#.

    Por Alex, el 07/03/2010

    Escribir en un excel desde c#.

    Escribir en un excel desde c#.

    Por Alex, el 04/03/2010

    Llenar un Repeater o DataList con un DataTable.

    Llenar un Repeater o DataList con un DataTable.

    Por Alex, el 29/12/2008

    El evento SelectedIndexChanged no funciona

    El evento SelectedIndexChanged no funciona

    Por Alex, el 26/12/2008


    Añadir un comentarios:

    Nombre:
    Email: (no se publica el email)




  • SIGUENOS EN

    ARCHIVO

    Publicidad

    .