CONECTAR C# CON POSTGRESQL USANDO NPGSQL 2.0.11 POSTGRE

1. TUTORIAL: CONECTAR C# CON POSTGRESQL USANDO NPGSQL 2.0.11
Comenzando con el tutorial, antes que nada comenzare descargando el conector Npgsql 2.0.11,
para poder trabajar con el lenguaje de programación C# y el net.framework 3.5 sp1. Bien
comencemos.
Paso 1: descargar el conector de la página http://pgfoundry.org/frs/?group_id=1000140
Paso 2: creamos un proyecto denominado CapaDatos de tipo Biblioteca de clases

2. Paso 3: el Proyecto nos queda de la siguiente manera (en el explorador de soluciones).
Nótese que hay dos clases creadas BaseDatos.cs y BaseDatosException.cs. son dos clases que he
creado ya les mostrare más adelante.
Paso 4: ya que hemos creado el proyecto de tipo librería de clases ahora hay que agregar nuestras
referencias al proyecto lo haremos como se muestra en la siguiente imagen a continuación.
Buscamos donde hemos descomprimido el conector que hemos descargado en el paso 1.

3. Bien Ahora detallamos que contiene las siguientes clases que hemos mencionado en el paso 3:
comenzamos con la clase BaseDatos.cs
/* código de BaseDatos.cs */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.Common;
using System.Configuration;
using Npgsql;
namespace CapaDatos
{
publicclassBaseDatos
{
privateDbConnection _Conexion = null;
privateDbCommand _Comando = null;
privateDbTransaction _Transaccion = null;
privateString _CadenaConexion;
privatestaticDbProviderFactory _Factory = null;
///<summary>
/// Crea una instancia del acceso a la base de datos.
///</summary>
///<param name="prov">proveedor de base de datos.</param>
///<param name="cad">cadena de conexion.</param>
public BaseDatos(String prov, String cad)
{
Configurar(prov, cad);
}
//''' <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>
//''' <param name="prov" >es el nombre de la variable del proveedor de
base de datos del archivo de configuracion</param>
//''' <param name="cadena">es el nombre de la variable de la cadena de
conexion del archivo de configuracion</param>
privatevoid Configurar(String prov, String cadena)
{
try
{
String proveedor = ConfigurationManager.AppSettings.Get(prov);
this._CadenaConexion = ConfigurationManager.AppSettings.Get(cadena);
BaseDatos._Factory = DbProviderFactories.GetFactory(proveedor);
}
catch (ConfigurationErrorsException ex)

4. {
thrownewBaseDatosException("Error al cargar la configuración del acceso a
datos.", ex);
}
}
//''' <summary>
//''' Permite desconectarse de la base de datos.
//''' </summary>
publicvoid Desconectar()
{
if (this._Conexion.State.Equals(ConnectionState.Open))
{
this._Conexion.Dispose();
this._Conexion.Close();
}
}
//''' <summary>
//''' Se concecta con la base de datos.
//''' </summary>
//''' <exception cref="BaseDatosException">Si existe un error al
conectarse.</exception>
publicvoid Conectar()
{
if (this._Conexion != null)
{
if (this._Conexion.State.Equals(ConnectionState.Closed))
{
thrownewBaseDatosException("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)
{
thrownewBaseDatosException("Error al conectarse.", 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>

5. //''' <param name="sentenciaSQL">La sentencia SQL con el formato:
SENTENCIA [param = @param,]</param>
publicvoid 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>
publicvoid 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>
publicvoid 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>
publicvoid AsignarParametroEntero(String nombre, int valor)
{
AsignarParametro(nombre, "", valor.ToString());
}
publicvoid AsignarParametroBooleano(String nombre, Boolean valor)
{
AsignarParametro(nombre, "", valor.ToString());
}
publicvoid AsignarParametroDecimal(String nombre, Decimal valor)
{
AsignarParametro(nombre, "", valor.ToString());
}
publicvoid AsignarCualquierParametro(String nombre, Object valor)
{
AsignarParametro(nombre, "", valor.ToString());

6. }
publicvoid AsignarParametroByte(String nombre, Byte[] valor)
{
NpgsqlParameter pa = new Npgsql.NpgsqlParameter(nombre,
NpgsqlTypes.NpgsqlDbType.Bytea, valor.Length);
pa.Value = valor;
this._Comando.Parameters.Add(pa);
}
//''' <summary>
//''' Ejecuta la Consulta y lo devuelve en un DataSet
//''' </summary>
publicDataSet EjecutarConsultaDataSet()
{
DataSet dsResult = newDataSet();
NpgsqlDataAdapter adapter =
newNpgsqlDataAdapter(this._Comando.CommandText.ToString(),
(NpgsqlConnection)(this._Conexion));
DataSet customers = newDataSet();
adapter.Fill(dsResult, "Tabla1");
return dsResult;
}
//''' <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>
privatevoid 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>
publicvoid AsignarParametroFecha(String nombre, DateTime valor)
{
//AsignarParametro(nombre, "'", valor.ToString("dd/MM/yyyy h:MM tt"));
AsignarParametro(nombre, "'", valor.ToString("dd/MM/yyyy
h:MM"));
}

7. //''' <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>
publicDbDataReader EjecutarConsulta()
{
returnthis._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>
publicint EjecutarEscalar()
{
int escalar = 0;
try
{
escalar =
int.Parse(this._Comando.ExecuteScalar().ToString());
}
catch (InvalidCastException ex)
{
thrownewBaseDatosException("Error al ejecutar un escalar.", ex);
}
return escalar;
}
//''' <summary>
//''' Ejecuta el comando creado.
//''' </summary>
publicvoid 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>
publicvoid 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.

8. //''' </summary>
//''' <remarks></remarks>
publicvoid CancelarTransaccion()
{
if (this._Transaccion != null)
{
this._Transaccion.Rollback();
}
}
//''' <summary>
//''' Confirma todo los comandos ejecutados entre el
<c>ComanzarTransaccion</c>
//''' y ésta invocación.
//''' </summary>
publicvoid ConfirmarTransaccion()
{
if (this._Transaccion != null)
{
this._Transaccion.Commit();
}
}
}
}
/* fin del código BaseDatos.cs */
Ahora la siguiente clase que no es compleja.
/* BaseDatosExcepcion.cs */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CapaDatos
{
publicclassBaseDatosException : ApplicationException

9. {
///<summary>
/// Construye una instancia en base a un mensaje de error y la una
excepción original.
///</summary>
///<param name="mensaje">El mensaje de error.</param>
///<param name="original">La excepción original.</param>
public BaseDatosException(String mensaje, Exception original)
: base(mensaje, original)
{
}
///<summary>
/// Construye una instancia en base a un mensaje de error.
///</summary>
///<param name="mensaje">El mensaje de error.</param>
public BaseDatosException(String mensaje) : base(mensaje) { }
}
}
/* fin del código BaseDatos.cs */
Paso 5: con esto ya hemos creado una librería de conexión a postgresql con C#, ahora hay que
agregar un proyecto a la solución para probar la Librería que hemos creado denominado
CapaDatos. Para agregamos un proyecto en la soluciónclick derecho sobre la solución y hacemos
como la siguiente imagen.

10. Nos saldrá una imagen como sigue
En este caso hemos agregado un proyecto de tipo aplicación de Windows Forms
Paso 6: Ahora click derecho sobre el nuevo proyecto agregado ClienteCapaDatos y agregamos las
referencias del proyecto de tipo librería de clases como se muestra en la imagen

11. Paso 7: bien hasta el momento hemos referenciado a nuestra proyecto cliente la librería de dato,
nos falta crear la base de Datos en postgresql para no hacerla más larga al tutorial solo pondré el
script de la base de datos en postgresql (asumiendo que ya saben crear base de datos en
postgresql)
Bien el script es el sgte:
--
-- PostgreSQL database dump
--
-- Started on 2011-05-09 23:37:04
SET statement_timeout = 0;
SET client_encoding = 'UTF8';
SET standard_conforming_strings = off;
SET check_function_bodies = false;
SET client_min_messages = warning;
SET escape_string_warning = off;

12. --
-- TOC entry 304 (class 2612 OID 16386)
-- Name: plpgsql; Type: PROCEDURAL LANGUAGE; Schema: -; Owner: postgres
--
CREATE PROCEDURAL LANGUAGE plpgsql;
ALTER PROCEDURAL LANGUAGE plpgsql OWNER TO postgres;
SET search_path = public, pg_catalog;
SET default_tablespace = '';
SET default_with_oids = false;
--
-- TOC entry 1491 (class 1259 OID 16548)
-- Dependencies: 3
-- Name: clientes; Type: TABLE; Schema: public; Owner: postgres; Tablespace:
--
CREATE TABLE clientes (
clie_id integer NOT NULL,
clie_nombre character varying(100)
);
ALTER TABLE public.clientes OWNER TO postgres;
--
-- TOC entry 1771 (class 0 OID 16548)
-- Dependencies: 1491
-- Data for Name: clientes; Type: TABLE DATA; Schema: public; Owner: postgres
--
INSERT INTO clientes (clie_id, clie_nombre) VALUES (1, 'JIMMY PRADA GUADALUPE');

13. INSERT INTO clientes (clie_id, clie_nombre) VALUES (2, 'ALVARO PRADA GUADALUPE');
INSERT INTO clientes (clie_id, clie_nombre) VALUES (3, 'CHRISTIAN ERICK PRADA GUADALUPE');
INSERT INTO clientes (clie_id, clie_nombre) VALUES (4, 'LORENA LOPEZ COBOS');
INSERT INTO clientes (clie_id, clie_nombre) VALUES (5, 'WENDY ESPINOZA LOPEZ');
INSERT INTO clientes (clie_id, clie_nombre) VALUES (6, 'KURT PRADA LOPEZ');
--
-- TOC entry 1770 (class 2606 OID 16552)
-- Dependencies: 1491 1491
-- Name: clientes_pkey; Type: CONSTRAINT; Schema: public; Owner: postgres; Tablespace:
--
ALTER TABLE ONLY clientes
ADD CONSTRAINT clientes_pkey PRIMARY KEY (clie_id);
--
-- TOC entry 1776 (class 0 OID 0)
-- Dependencies: 3
-- Name: public; Type: ACL; Schema: -; Owner: postgres
--
REVOKE ALL ON SCHEMA public FROM PUBLIC;
REVOKE ALL ON SCHEMA public FROM postgres;
GRANT ALL ON SCHEMA public TO postgres;
GRANT ALL ON SCHEMA public TO PUBLIC;
-- Completed on 2011-05-09 23:37:05
--
-- PostgreSQL database dump complete

14. Paso 8: ahora tenemos que crear un archivoapp.config (archivo de configuración de aplicaciones)
click derecho sobre el proyecto clienteCapaDatos y agregamos un elemento app.conf en caso no
tengamos en nuestro proyecto cliente es el app.configdebe quedar asi:
<?xmlversion="1.0"encoding="utf-8" ?>
<configuration>
<configSections>
<sectionGroupname="userSettings"type="System.Configuration.UserSettingsGr
oup, System, Version=2.0.0.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089">
<sectionname="SislogADO.My.MySettings"type="System.Configuration.ClientSe
ttingsSection, System, Version=2.0.0.0, Culture=neutral,
PublicKeyToken=b77a5c561934e089"allowExeDefinition="MachineToLocalUser"re
quirePermission="false" />
</sectionGroup>
</configSections>
<system.data>
<DbProviderFactories>
<addname="Npgsql Data
Provider"invariant="Npgsql"support="FF"description=".Net Framework Data
Provider for Postgresql Server"type="Npgsql.NpgsqlFactory, Npgsql,
Version=2.0.11.91, Culture=neutral, PublicKeyToken=5d8b90d52f46fda7" />
</DbProviderFactories>
</system.data>
<appSettings>
<!-- El proveedor ADO.NET -->
<addkey="PROVEEDOR_ADONET"value="Npgsql" />
<!-- La cadena de conexion -->
<addkey="CADENA_CONEXION_CapaDatosDB"value="Server=localhost;Database=Cap
aDatosDb; Port=5432; User id=postgres;password=1234567890;pooling=false "
/>
<addkey="ClientSettingsProvider.ServiceUri"value="" />
</appSettings>
</configuration>
Paso 9: ahora en la clase Program.cs de nuestra aplicación agregamos lo siguiente debe quedar de
esta forma:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
namespace ClienteCapaDatos
{
staticclassProgram
{
publicstaticString PROVEEDOR_PGSQL = "PROVEEDOR_ADONET";
publicstaticString CADENA_CONEXION_CapaDatosDb =
"CADENA_CONEXION_CapaDatosDb";
///<summary>
/// Punto de entrada principal para la aplicación.
///</summary>

15. [STAThread]
staticvoid Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(newForm1());
}
Y en nuestro formulario arrastramos un DataGridView y en el form1.cs en
el evento load agregamos lo siguiente:
privatevoid Form1_Load(object sender, EventArgs e)
{
BaseDatos bd = newBaseDatos(Program.PROVEEDOR_PGSQL,
Program.CADENA_CONEXION_CapaDatosDb);
DataSet ds;
try
{
bd.Conectar();
bd.CrearComando("select * from clientes");
ds = bd.EjecutarConsultaDataSet();
dataGridView1.DataSource = ds.Tables [0];
}
catch (Exception ex)
{
thrownewException(ex.Message, ex);
}
finally
{
bd.Desconectar();
}
}
Y ejecutamos nos debe mostrar una venata como sigue