using System;

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
//Después de agregar la referencia
//es necesario agregar las respectivas
//clausulas using.
using System.Configuration;
using System.Web;

namespace DataLayer
{
/// <summary>
/// Objeto que permite obtener la cadena de
/// conexión de el archivo WebConfig referente
/// a la apliación ASP.NET bajo la cual
/// corre la dll DataLayer
/// </summary>
public sealed class Connection
{
/// <summary>
/// Definimos en una constante el nombre de la cadena de conexión
/// Recordemos que esta cadena está definida en el WebConfig de la
/// aplicación ASP.NET
/// </summary>
private const string DemoASPConnectionString1 = "DemoASPConnectionString1";

private string connectionString;

public string ConnectionString {

get{
return connectionString;
}
private set {
connectionString = value;
}
}
/// <summary>
/// Cuando creamos un objeto connection la propiedad
/// ConnectionString obtiene el valor de la cadena de conexión
/// de la siguiente forma.
/// </summary>
public Connection() {
ConnectionString = System.Web.Configuration.WebConfigurationManager.
ConnectionStrings[DemoASPConnectionString1].ConnectionString;
}
}
}
Así cuando se creé un objeto:

Connection connection = new Connection()

string cadena = connection.ConnectionString;

La propiedad Connection String tendrá almacenada la cadena de conexión a la base de datos que podría ser usada en cualquier
parte de la capa de datos.
Ahora necesitamos crear una clase la cual llamaremos Person haciendo referencia al nombre de la misma tabla existente en la
base de datos. En esta clase vamos a crear métodos los cuales permiten impactar la base de datos haciendo sentencias Select,
Update, Insert, Delete:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;

namespace DataLayer
{
public class Person
{
private string _ConnectionString;

/// <summary>
/// Esta constante representa un Select a todos los registro existentes en
/// la tabla Person
/// </summary>
private const string SelectAllTablePerson = @"SELECT [Id], [PersonalId], [FirstName],
[SecondName], [FirstLastName], [SecondLastName]
FROM [Person]";
/// <summary>
/// Esta constante representa un Insert a la tabla Person
/// </summary>
private const string InsetTablePerson = @"INSERT INTO [Person]
([PersonalId], [FirstName], [SecondName], [FirstLastName], [SecondLastName])
VALUES (@PersonalId, @FirstName, @SecondName, @FirstLastName, @SecondLastName)";
/// <summary>
/// Esta constante representa un Update a un registro que coincida con el Id
/// de una persona en la tabla Person.
/// </summary>
private const string UpdateTablePerson = @"UPDATE [Person]
SET [PersonalId] = @PersonalId, [FirstName] = @FirstName,
[SecondName] = @SecondName, [FirstLastName] =
@FirstLastName,
[SecondLastName] = @SecondLastName
WHERE [Id] = @Id";
/// <summary>
/// Esta constante representa la sentencia Delete de un registro
/// en la tabla Person de la base de datos DemoASP
/// </summary>
private const string DeleteTablePerson = "DELETE FROM [Person] WHERE Id = @Id";

/// <summary>
/// Constantes que representan cada uno de los parámetros
/// Existentes en cada una de las sentencias SQL
/// </summary>
private const string P_Id = "@Id" , P_PersonalId = "@PersonalId",
P_FirstName = "@FirstName", P_SecondName = "@SecondName",
P_FirstLastName = "@FirstLastName", P_SecondLastName = "@SecondLastName";

/// <summary>
/// Al crear un objeto Person de la capa de datos
/// este inicaliza una instancia de Connection
/// y por ende se puede tener acceso a la cedena de conexión.
/// </summary>
public Person()
{
Connection connection = new Connection();
_ConnectionString = connection.ConnectionString;
}
 /// <summary>
/// Este método permite obtener Todos los registros de la
/// tabla Person en la base de datos DemoASP
/// </summary>
public DataTable GetAllPeople(ref string error)
{
DataTable dt = new DataTable();
using (SqlConnection connection = new SqlConnection(_ConnectionString))
{
using (SqlCommand cmd = new SqlCommand(SelectAllTablePerson, connection))
{
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
try
{
cmd.Connection.Open();
da.Fill(dt);
}
catch (SqlException sqlEx)
{
error = sqlEx.Message;
}
}
}
}
return dt;
}

//Este método retorna como resultado un objeto DataTable con todos los registro de la tabla Person, Cómo vemos para
//inicializar un SqlConnection lo hacemos pasando como parámetro la cadena de conexión a la base de datos, el Objeto
//SqlCommand se inicializa dentro pasando como parámetro la constante que declaramos en la parte incial de la Clase y la cual
//hace referencia a el tipo de instrucción que queremos hacer y por otra parte se pasa el objeto connection para así el objeto
//command inicialice la conexión. En la siguiente línea declaramos un SqlDataAdapter el cual permite manejar conexión y tipo
//de sentencia que queremos ejecutar contra la base de datos (para profundizar con estos objetos ver documentación msdn).
//Como se puede ver cada uno de estos objetos se encuentra en un ámbito using esto permite que los recursos de memoria
//sean liberados al finalizar la ejecución de cada sentencia.
/// <summary>
/// Este método permite insertar un registro en la tabla
/// Person de la base de datos DemoASP
/// </summary>
public void Insert(ref string errors, int id, int personalId, string firstName, string secondName,
string firstLastName, string secondLastName)
{
using (SqlConnection connection = new SqlConnection(_ConnectionString))
{
using (SqlCommand cmd = new SqlCommand(InsetTablePerson, connection))
{
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue(P_PersonalId, personalId);
cmd.Parameters.AddWithValue(P_FirstName, firstName);
cmd.Parameters.AddWithValue(P_SecondName, secondName);
cmd.Parameters.AddWithValue(P_FirstLastName,firstLastName);
cmd.Parameters.AddWithValue(P_SecondLastName, secondLastName);
try
{
cmd.Connection.Open();
cmd.ExecuteNonQuery();
}
catch (SqlException sqlEx)
{
errors = sqlEx.Message;
}
}
}
}
//En el anterior método se tiene la instrucción insert, que aparte de que la realizamos casi exactamente a como hicimos la
//sentencia select, aquí incluimos parámetros y mediante el objeto cmd agregamos cada uno de estos, mediante el método
//AddWithValue le pasamos nombre del parámetro correspondiente a la sentencia SQL por ejemplo @Id va a estar
//representado por la constante P_Id que definimos en la cabecera de la clase Person y cómo se ve anteriormente el método
//recibe como parámetros cada unos de los datos que constituyen un registro en la tabla Person de la base de datos, así al
//hacer cmd.ExecuteNonQuery() y no ocurre ningún error se habrá insertado dicho registro. Si ocurriese un error el parámetro
//por referencia errors almacenara el mansaje de la excepción ocurrida y podríamos posteriormente procesar dicha excepción
//para presentar al usuario un error con formato más entendible.
/// <summary>
/// Este método permite actualizar un registro en Person
/// en la base de datos DemoASP
/// </summary>

public void Update(ref string errors, int id, int personalId, string firstName, string secondName,
string firstLastName, string secondLastName)
{
using (SqlConnection connection = new SqlConnection(_ConnectionString))
{
using (SqlCommand cmd = new SqlCommand(UpdateTablePerson, connection))
{
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue(P_Id, id);
cmd.Parameters.AddWithValue(P_PersonalId, personalId);
cmd.Parameters.AddWithValue(P_FirstName, firstName);
cmd.Parameters.AddWithValue(P_SecondName, secondName);
cmd.Parameters.AddWithValue(P_FirstLastName, firstLastName);
cmd.Parameters.AddWithValue(P_SecondLastName, secondLastName);
try
{
cmd.Connection.Open();
cmd.ExecuteNonQuery();
}
catch (SqlException sqlEx)
{
errors = sqlEx.Message;
}
}
}
}
/// <summary>
/// Este método permite eliminar un registro Person
/// de la base de datos DemoASP
/// </summary>
/// <param name="errors"></param>
/// <param name="id"></param>
public void Delete(ref string errors, int id)
{
using (SqlConnection connection = new SqlConnection(_ConnectionString))
{
using (SqlCommand cmd = new SqlCommand(DeleteTablePerson, connection))
{
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue(P_Id, id);
try
{
cmd.Connection.Open();
cmd.ExecuteNonQuery();
}
catch (SqlException sqlEx)
{
errors = sqlEx.Message;
}
}
}
}
}
}