Programando una aplicación ASP.NET con MySQL y .NET

Desde la conexión hasta la programación es muy fácil, ya que con respecto a ADO.NET no cambia, así que puedo programar con ADO.NET y conectarme a MySQL, Oracle, Access y demás bases de datos. Un modelo para todos.

1.- Acceder a la página de MySQL  y descargar el conector que tiene soporte para Visual Studio 2008 . Yo descargué el 6.0 , existe uno el 6.1 pero aún esta beta. Si desean testear descarguen ese.

URL: http://dev.mysql.com/downloads/connector/net/6.0.html

2.- Deben tener instalado algún servidor, pueden descargar el community server de MySQL, pero si quieren evitar la fatiga de hacer estos pasos como lo muestran en este blog http://www.15seconds.com/issue/050210.htm y están usando el WAMP Server para desarrollar páginas PHP, pueden utilizar ese que ya tiene MySQL incluido.

3.-  Después de tener instalado los 2 componentes anteriores, vamos a realizar de forma gráfica la conexión con Visual Studio 2008, en el explorador de servidores (Server Explorer). Escogemos el recurso de datos como MySQL DataBase.

Hasta este punto debimos crear una base de datos en MySQL y las tablas

 

.

 

4.- Crear un proyecto o sitio web ASP.NET

5.- Programar la clase de Datos.

Importar los siguientes namespaces desde referencias y en código.

 

C#

using System.Data;
using MySql.Data;
using MySql.Data.MySqlClient;

VB.NET

Imports MySql.Data
Imports MySql.Data.MySqlClient

Quizás esta sea otra forma de programar con ADO.NET, lo adapté a un  estilo de programación reutilizable. Usted puede aplicarlo en la práctica.

 

Método CrearComando().- Este método es reutilizable para poder crear comandos.

C#

public static MySqlCommand CrearComando()
 {
  string _cadenaConexion = " server = localhost; user id = root; database = myCompany";
  MySqlConnection _conexion = new MySqlConnection();
  _conexion.ConnectionString = _cadenaConexion;
  MySqlCommand _comando = _conexion.CreateCommand();
   _comando.CommandType = CommandType.Text;
  return _comando;
 }

VB.NET

Public Shared Function CrearComando() As MySqlCommand
 Dim _cadenaConexion As String = " server = localhost; user id = root; database = myCompany"
 Dim _conexion As New MySqlConnection()
  _conexion.ConnectionString = _cadenaConexion
 Dim _comando As New MySqlCommand()
  _comando = _conexion.CreateCommand()
  _comando.CommandType = CommandType.Text
 Return _comando

    End Function

Método EjecutarComandoSelect(), Este metodo contiene un DataReader que lee todos los registros y carga la información a la tabla con la ayuda del evento ExecuteReader del comando.

C#

public static DataTable EjecutarComandoSelect(MySqlCommand comando)
        {
            DataTable _tabla;
            try
            {
                comando.Connection.Open();
                MySqlDataReader _lector = comando.ExecuteReader();
                _tabla = new DataTable();
                _tabla.Load(_lector);
                _lector.Close();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                comando.Connection.Close();
            }
            return _tabla;
        }

VB.NET

Public Shared Function EjecutarComandoSelect(ByVal comando As MySqlCommand) As DataTable
        Dim _tabla As New DataTable()
        Try
            comando.Connection.Open()
            Dim _lector As MySqlDataReader
            _lector = comando.ExecuteReader
            _tabla.Load(_lector)
            _lector.Close()

        Catch ex As Exception
            Throw ex

        Finally
            comando.Connection.Close()

        End Try

        Return _tabla

    End Function

6.- Programar la clase Seleccionar, en esta clase recibimos una consulta de tipo String y devolvemos los datos en forma de tabla, para posteriormente mostrarlos.

C#

public static DataTable Obtener(string consulta)
 {
    MySqlCommand _comando =Datos.CrearComando();
     _comando.CommandText=consulta;
    return Datos.EjecutarComandoSelect(_comando);
 }

VB.NET

Public Shared Function Obtener(ByVal consulta As String) As DataTable
  Dim _comando As MySqlCommand = Datos.CrearComando()
  _comando.CommandText = consulta
  Return Datos.EjecutarComandoSelect(_comando)
    End Function

7.- Crear una clase o modulo para colocar ahí y separar las consultas.

C#

public class Consultas
    {

        public static string consultarEmpleados="SELECT * FROM Empleados";
    }

VB.NET

Module Consultas

    Public consultarEmpleados = "Select * from Empleados"

End Module

8.- En el sitio web en Default.aspx o la página en donde deseen.

Agregamos un ListView al formulario, el diseño HTML es el mismo para ambos lenguajes.

HTML :

<asp:ListView ID="ListView1" runat="server">
    <LayoutTemplate>
        <asp:PlaceHolder ID="itemPlaceHolder" runat="server"></asp:PlaceHolder>

    </LayoutTemplate>
    <ItemTemplate>
     <br />
        <asp:Label ID="Label1" runat="server" Text='<%# Bind("ID") %>'> </asp:Label> <br />
         <asp:Label ID="Label2" runat="server" Text='<%# Bind("Nombre") %>'> </asp:Label> <br />
          <asp:Label ID="Label3" runat="server" Text='<%# Bind("Salario") %>'> </asp:Label> <br />
    </ItemTemplate>
    <ItemSeparatorTemplate>
    ---------------------------------------

    </ItemSeparatorTemplate>
    </asp:ListView>

El listview debe contar un un LayoutTemplate y en el colocar un PlaceHolder con el ID=”itemPlaceHolder” de otro modo les marcará error.

Dentro del itemTemplate vamos a colocar la información que mostrará, como lo vamos a ligar a la clase Seleccionar entonces utilizamos Bind o podemos ocupar Eval, es cuestión de lo que usteden desean.

En el archivo CodeFile del Default ya sea Default.aspx.cs o Default.aspx.vb

Cargamos la información como datasource del control ListView.

C#

protected void Page_Load(object sender, EventArgs e)
        {
            ListView1.DataSource = Seleccionar.Obtener(Consultas.consultarEmpleados);
            ListView1.DataBind();
        }

VB.NET

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        ListView1.DataSource = Seleccionar.Obtener(Consultas.consultarEmpleados)
        ListView1.DataBind()
    End Sub

Resultado:

Que sea de gran utilidad. Saludos.

Descarga del proyecto en C#

Descarga del proyecto en VB.NET

Curso: Desarrollando Sitios Web Seguros

Como redireccionar de http a https en C#

Si están buscando como cambiar de http a https y viceversa de https a http, aquí les dejo un código que me ha funcionado.

public partial class Default : System.Web.UI.MasterPage
{
    protected void Page_Load(object sender, EventArgs e)
    {
//Llamando al método true= https; false = http;
        protocoloSeguro(true);
    }

//Metodo de redireccionamiento..
    public void protocoloSeguro(bool bSeguro)
    {

        string redirectUrl = null;

        if (bSeguro && !Request.IsSecureConnection) redirectUrl = Request.Url.ToString().Replace("http:", "https:");
        else
            if (!bSeguro && Request.IsSecureConnection) redirectUrl = Request.Url.ToString().Replace("https:", "http:");

        if (redirectUrl != null)
            Response.Redirect(redirectUrl);

    }
}

Manejar ASP.NET Themes dinámicamente

Tal vez este sea uno de los post más buscados, por lo menos yo batallé en su momento.

Chequemos los archivos que utilizaremos:

• Dos temas : Black y Blue con sus respectivas hojas de estilo CSS
• Una MasterPage y un ContenPage (WebForm), dentro del formulario un DropDownList.
• Un archivo Global.asax

Dentro de un archivo Web.Config agregaremos un tag <anonymousIdentification>, <profile> y dentro del profile <properties> Tema y Master.

<?xml version="1.0"?>
<configuration>
    <appSettings/>
    <connectionStrings/>
    <system.web>
        <compilation debug="true">
        </compilation>
        <anonymousIdentification enabled="true"/>
        <profile enabled="true">
            <properties>
                <add name="Tema" allowAnonymous="true"/>
                <add name="Master" allowAnonymous="true"/>
            </properties>
        </profile>
        <authentication mode="Windows"/>
    </system.web>
</configuration>

En el método Page_Load vamos a colocar este código, en donde tenemos un array de tipo string que almacenará todos los temas que tengamos en la carpeta “App_Themes”, después ese array pasará como recurso de datos al DropDownList para mostrarlo en el formulario Web.

protected void Page_Load(object sender, EventArgs e)
    {
        if(!Page.IsPostBack)
        {

            string[] nombretemas;
            DirectoryInfo directorio;

            nombretemas=Directory.GetDirectories(Server.MapPath("App_Themes"));

            for (int i = 0; i < nombretemas.Length; i++){    

                directorio = new DirectoryInfo(nombretemas[i]);
                nombretemas[i]=directorio.Name;
                }

            DropDownList1.DataSource = nombretemas;
            DropDownList1.DataBind();
            DropDownList1.SelectedValue = Profile.Tema;
        }
    }

En el archivo Global.asax vamos a agregamos un método llamado Application_PreRequestHandlerExecute, de acuerdo al postback que hagamos al seleccionar el tema, este aplicará el tema del perfil (profile).

Guardando el tema para la siguiente vez que entre a la página.

<%@ Application Language="C#" %>

<script runat="server">
    void Application_Start(object sender, EventArgs e)
    {
    }

    void Application_End(object sender, EventArgs e)
    {
    }

    void Application_Error(object sender, EventArgs e)
    {
    }

    void Session_Start(object sender, EventArgs e)
    {
    }

    void Session_End(object sender, EventArgs e)
    {
    }
    void Application_PreRequestHandlerExecute(object sender,EventArgs e)
    {
        Page p= HttpContext.Current.Handler as Page;
        if(p!=null)
        {
            ProfileCommon pc= (ProfileCommon)HttpContext.Current.Profile;
            if(pc!=null){
            p.Theme=pc.Tema;
            //p.MasterPageFile=String.Format("~/{0}.master",pc.Master);
            }
        }
    }
</script>

Descarga el ejemplo:

URL: ASPNET_Themes.zip-download

Microsoft Data Access Application Block

Son pequeñas clases que nos ayudan mucho a los desarrolladores, en este caso para manipular los datos desde código, existe un archivo llamado SQLHelper que contiene métodos reutilizables para llamar procedimientos almacenados y comandos SQL en forma de texto.

Les recomiendo que lo descarguen y lo utilizen para sus proyectos.

URL: http://www.microsoft.com/downloads/details.aspx?FamilyID=f63d1f0a-9877-4a7b-88ec-0426b48df275&displaylang=en

Boxing y Unboxing en C#

Cuando una variable de tipo valor necesita ser convertida  a uno de tipo referencia, se le conoce como Boxing.

Y Unboxing simplemente lo contrario.

En este ejemplo lo vemos muy claro:

class Program
{
   static void Main(string[] args)
   {
       //String - tipo referencia
       string s = "Edison Daniel García Chiñas";

       //Char - tipo valor - Realizando el unboxing
       char[] sa = s.ToCharArray();       

       Array.Sort(sa);
       foreach (char c in sa)
       { Console.WriteLine(c);}

       //Realizando el boxing
       s = new string(sa);
       Console.WriteLine(s);
       Console.ReadLine();
   }
    

Para mayor referencia en MSDN:

Checa: http://msdn.microsoft.com/es-es/library/25z57t8s(VS.80).aspx

Resumen de Tipos de Datos en C#

Quizás este sea un resumen general de todos los posts hasta este momento vistos:

Tipo de Datos Value Type:

http://mredison.wordpress.com/2009/04/05/tipos-de-datos-valuetype-class/

Estructuras en C#:

http://mredison.wordpress.com/2009/04/05/estructuras-en-c/

Enumeraciones en C#:

http://mredison.wordpress.com/2009/04/05/enumeraciones-en-c/

Reference Types en C#:

http://mredison.wordpress.com/2009/04/05/referent-types-en-c/

http://mredison.wordpress.com/2009/04/05/reference-types-en-c-2/

Streams en C#:

http://mredison.wordpress.com/2009/04/06/streams-en-c/

Excepciones en C#:

http://mredison.wordpress.com/2009/04/06/excepciones-en-c/

 

Veamos un ejemplo que englobe todo:

Vamos a declarar algunas variables con diferentes tipos de datos, en donde determinaremos que tipo de dato es, si es valor o referencia.

sbyte a = 0;
byte b = 0;
Int16 c = 0;
Int32 d = 0;
Int64 e = 0;
UInt16 f = 0;
UInt32 g = 0;
UInt64 h = 0;
long j = 0;
float k = 0;
double l = 0.0;
decimal m = 0.00234432M;
char n = 'A';
bool activo = true;
DateTime fecha = new DateTime();
string s = "";
Exception ex = new Exception();
int[] valores = { 0, 1 };
object[] ejemplo = new object[2];

Los almacenaremos en un arreglo de tipo objeto, este arreglo la característica principal es que te permite almacenar varios elementos con diferentes tipos de datos, no como los arreglos normales.

object[] tipos = {a,b,c,d,e,f,g,h,j,k,l,m,n,activo,fecha,s,ex,valores,ejemplo};

Crearemos una condición que detecte que tipo de dato es.

foreach (object o in tipos)
      {
          string tipo;
          if (o.GetType().IsValueType)
          {
              tipo = "Tipo Valor";
          }
          else
          {
              tipo = "Tipo Referencia";
       }

Después crearemos una estructura FUERA de la Clase, el cual recibirá el tipo de objeto y poder hacer uso de el.

public struct Objeto
    {
        object o;

        public Objeto(object o)
        {
            this.o=o;
        }

        public object Ob
        {

            get { return o; }
        }

        public override string ToString()
        {
            return o.ToString();
        }

    }

Dentro del método static void main() de la clase.

Mandaremos a llamar al objeto desde la estructura:

object leer;
      Console.WriteLine("Escriba un tipo de sistema ...");
      leer = Console.ReadLine();

      Objeto obj = new Objeto(leer);
      Console.WriteLine( "Llamando a obj desde una escructura: " + obj.Ob.ToString());

Ya que tenemos listo la condición para saber que tipo de objeto es, necesitamos mostrarlo en pantalla, pero primero vamos a escribirlo en un archivo.txt y después leerlo para mostrarlo en pantalla.

private const string DIR_ARCHIVO = "c:\\archivo.txt";

Recordemos el ejemplo de Streams vamos a implementarlo usando excepciones por su ocurre algún error en tiempo de ejecución.

try
{
 StreamWriter escritor = File.CreateText(DIR_ARCHIVO);
 foreach (object o in tipos)
 {
     string tipo;
     if (o.GetType().IsValueType)
     {
         tipo = "Tipo Valor";
     }
     else
     {
         tipo = "Tipo Referencia";
  }
     escritor.WriteLine("{0}: {1}", o.GetType(), tipo);

 }
 escritor.Close();

 if (File.Exists(DIR_ARCHIVO))
     {

     using (StreamReader lector = new StreamReader(DIR_ARCHIVO))
     {
         Console.WriteLine(lector.ReadToEnd());
         lector.Close();
     }
 }

 object leer;
 Console.WriteLine("Escriba un tipo de sistema ...");
 leer = Console.ReadLine();

 Objeto obj = new Objeto(leer);
 Console.WriteLine( "Llamando a obj desde una escructura: " + obj.Ob.ToString());
}
catch (Exception el) {Console.WriteLine(el.Message); }
finally { Console.ReadLine(); }

}

Que tal si agregamos una enumeración, para indicar cuando el archivo está abierto o cerrado.

public enum Archivo
    {
        abierto,
        cerrado
    }

Código Completo:

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace ValueTypes
{
public enum Archivo
{
abierto,
cerrado
}
public struct Objeto
{
object o;

public Objeto(object o)
{
  this.o=o;
}

public object Ob
{

  get { return o; }
}

public override string ToString()
{
  return o.ToString();
}

}

class Program
{
private const string DIR_ARCHIVO = "c:\\archivo.txt";
static void Main(string[] args)
{

  sbyte a = 0;
  byte b = 0;
  short c = 0;
  int d = 0;
  uint e = 0;
  long f = 0;
  float g = 0;
  double h = 0.0;
  decimal i = 0.00234432M;
  char j = 'A';
  bool activo = true;
  DateTime fecha = new DateTime();
  string s = "";
  Exception ex = new Exception();
  int[] valores = { 0, 1 };
  object[] ejemplo = new object[2];

  object[] tipos = {a,b,c,d,e,f,g,h,i,j,activo,fecha,s,ex,valores,ejemplo};

  try
  {
      StreamWriter escritor = File.CreateText(DIR_ARCHIVO);
      foreach (object o in tipos)
      {
          string tipo;
          if (o.GetType().IsValueType)
          {
              tipo = "Tipo Valor";
          }
          else
          {
              tipo = "Tipo Referencia";
       }
          escritor.WriteLine("{0}: {1}", o.GetType(), tipo);

      }
      escritor.Close();

      if (File.Exists(DIR_ARCHIVO))
          {

          using (StreamReader lector = new StreamReader(DIR_ARCHIVO))
          {
              Console.WriteLine(Archivo.abierto);
              Console.WriteLine(lector.ReadToEnd());
              lector.Close();
          }
          Console.WriteLine(Archivo.cerrado);

      }

      object leer;
      Console.WriteLine("Escriba un tipo de sistema ...");
      leer = Console.ReadLine();

      Objeto obj = new Objeto(leer);
      Console.WriteLine( "Llamando a obj desde una escructura: " + obj.Ob.ToString());
  }
  catch (Exception el) {Console.WriteLine(el.Message); }
  finally { Console.ReadLine(); }

}

}
}

Excepciones en C#

Las excepciones son eventos inesperados que interrumpen la ejecución normal de un ensamblado o un proceso (programa).

Por ejemplo si un ensamblado esta leyendo un archivo de texto largo desde un disco removible y de pronto el usuario quita el dispositivo, el entorno de ejecución o el sistema operativo mandará una excepción. Las excepciones nunca deberán causar que un ensamblado falle por completo. En ese caso usted debe planear cuando las excepciones pueden ocurrir, atraparlas y responder a esos eventos.

Las excepciones derivan de la clase Exception del namespace System. Esta clase es la base de todas las excepciones. El entorno de ejecución del .NET Framework nos provee un modelo en el manejo de las excepciones que es basado en representar las excepciones como objetos y separando el código y el manejo de la excepción en bloques try y catch, respectivamente.Por último si no hubo ninguna excepción entrará en un bloque llamado finally, ideal para limpiar valores, o realizar algún método al final del proceso.

Dicho de otra manera colocaremos el código de nuestra aplicación, métodos, etc. dentro del bloque try, si ocurre algun tipo de excepción automáticamente entrará al bloque catch.

Tipos de Excepciones en C#

Existen dos categorías de excepciones bajo la clase Exception:

• Las clases predefinidas del entorno de ejecución (Common Language Runtime) derivando de SystemException.
• Y las definidas por el usuario en la aplicación derivando de la clase  ApplicationException.

Propiedades de una Excepción

Una excepción incluye un número de propiedades que ayudan a identificar la localización del código, el tipo, el archivo de ayuda y la razón de la excepción: StackTrace,InnerException,Message,HelpLink,HResult,Source,TargetSite,Data.

Mejores Prácticas:

Siguiendo el ejemplo anterior de los Streams en C#

http://mredison.wordpress.com/2009/04/06/streams-en-c/

Podemos definir bloques try, catch y finally:

try
{
 using (StreamReader lector = File.OpenText(DIR_ARCHIVO)){
  String linea;
  while ((linea = lector.ReadLine()) != null)
   {
    Console.WriteLine(linea);
   }
   lector.Close();
Console.WriteLine("------------------------");

 }
}
 catch(Exception ex){Console.WriteLine("Error al leer el archivo: {0}",ex.Message);}
 finally{Console.ReadLine();}return;

Más acerca de las excepciones en MSDN:

URL: http://msdn.microsoft.com/en-us/library/system.exception.aspx