Usar JavaScript con Controles Asp.Net

miércoles, 28 de noviembre de 2012

En esta ocasión veremos como usar javascript en controles asp.net.

Veremos un ejemplo sencillo donde se ara una suma o resta dependiendo de la opcion del usuario.

El diseño de la aplicacion es la siguiente.

Diseño

Como veran el diseño es sencillo el usuario ingresara datos en los 2 textbox y luego mediante un dropdowlist elegirá si realiza una suma o resta y mostraremos el resultado en un label.

Veamos el código.
function Operacion() 
{
        //capturar valores
        var dato1 = document.getElementById('<%=TextBox1.ClientID%>').value;
        var dato2 = document.getElementById('<%=TextBox2.ClientID%>').value;
        var opcion = document.getElementById('<%=DropDownList1.ClientID%>').value;
        //comprobar que los datros sean numericos
        if (!isNaN(dato1) && !isNaN(dato2)) 
        {
             //si selecciono suma realizo suma
             if (opcion == "Sumar") 
             {
                  var resul = parseFloat(dato1) + parseFloat(dato2);
                  document.getElementById('<%=Label1.ClientID%>').innerHTML = resul;
             }
             //si no realiza resta
             else 
             {
                  var resul = parseFloat(dato1) - parseFloat(dato2);
                  document.getElementById('<%=Label1.ClientID%>').innerHTML = resul;
             }
        }
        else 
        {
            alert('ingrese numero');
        }

}

function Limpiar() 
{
      document.getElementById('<%=TextBox1.ClientID%>').value = '';
      document.getElementById('<%=TextBox2.ClientID%>').value = '';
      document.getElementById('<%=Label1.ClientID%>').innerHTML = '';
}
Como verán tenemos 2 funciones la primera Operación() es la que se encarga de realizar la operación seleccionada por el usuario, en la primera parte del código capturamos los valores introducidos en los textbox y la opcion seleccionada en el dropdowlist, comprobamos si los datos introducidos son numéricos y luego evaluamos si el usuario selecciono la suma o resta y hacemos la operación para cada opcion y mostramos el resultado en un label.
La segunda función Limpiar() como pueden imaginarse lo único que hace es limpiar los datos. Ahora para llamar las funciones desde los botones tenemos el siguiente código.
<asp:button id="Button1" onclientclick="Operacion(); return false;" runat="server" text="Calcular" />

<asp:button id="Button2" onclientclick="Limpiar(); return false;" runat="server" text="Limpiar" />
Usamos la propiedad OnclientClick para llamar la función javascript, incluimos el return false para evitar que el botón  haga postback

Captura

Eso seria todo espero les sea de utilidad.

Descargar Ejemplo

Microsoft Community Contributor(MCC)



En esta ocasión quiero compartir con ustedes la noticia agradable que he sido reconocido como Microsoft Community Contributor(MCC) gracias a  los pequeños aportes que hago a los foros de MSDN.

Así que quiero darles las gracias a esta hermosa comunidad  MSDN que gracias a ella a lo largo de estos meses he aprendido mucho y a sido una gran herramienta para poder mejorar mis conocimientos sobre .Net espero seguir aportando para poder responder sus dudas.

Gracias a todos.
 Saludos.

Desarrollo en Capas .Net (Parte 4) - Capa Presentacion

miércoles, 31 de octubre de 2012

En el articulo anterior desarrollamos nuestra capa de negocio

 Pueden ver el articulo aquí Desarrollo en Capas .Net (Parte 3) - Capa de Negocio

La capa presentación(presentation) es la que ve el usuario (también se la denomina "capa de usuario"), presenta el sistema al usuario, le comunica la información y captura la información del usuario en un mínimo de proceso (realiza un filtrado previo para comprobar que no hay errores de formato).

En este ultimo articulo es donde veremos como se comunican las diferentes capas entre si.

capas


Diseño de la aplicación.

Diseño


Cargar Alumnos y Materias.
 
        //cargo alumnos en combobox
        private void CargarAlumnos()
        {
            cbxalumnos.DataSource = AlumnoBL.CargarAlumnos();
            cbxalumnos.ValueMember = "AluId";
            cbxalumnos.DisplayMember = "AluNombre";
        }

        private void FrmAlumno_Load(object sender, EventArgs e)
        {
            CargarAlumnos();

            //cargo materias en combobox
            cbxmaterias.DataSource = MateriaBL.CargarMaterias();
            cbxmaterias.ValueMember = "MatId";
            cbxmaterias.DisplayMember = "MatNombre";

        }
Tenemos un método CargarAlumnos() que lo que hace es cargos el nombre de todos los alumnos en un combobox este método lo llamaremos luego de actualizar o agregar un nuevo alumno para que los datos del combobox se actualicen y en el evento load del formulario también cargamos todas las materias en otro combobox.

Agregar o Actualizar Alumno.
 
       //Variable global que prepresenta al alumno seleccionado
       Alumno alum = null;

        private void btnguardar_Click(object sender, EventArgs e)
        {
            //compruebo las validaciones
            if (!ValidacionesAlumno())
                return;

            // si el cliente se ha seleccionado lo actualizo, sino se crea uno nuevo
            if(alum == null)
                alum = new Alumno();

            alum.AluNombre = txtnombre.Text;
            alum.AluApellido = txtapellido.Text;
            alum.AluEdad = Convert.ToInt16(txtedad.Text);
            alum.AluDireccion = txtdireccion.Text;

            alum = AlumnoBL.Save(alum);
            MessageBox.Show("Se agrego o Actulizo el Alumno con Id:" +alum.AluId);
            CargarAlumnos();
            Limpiar();
        }
Tenemos una variable global que representa un alumno, luego la capa de negocio validad si la entidad(Alumno) existe o no por medio del id y en base a esto se ejecuta la operación correspondiente a cada caso, también en el código encontramos los métodos ValidacionesAlumno() que lo que hace es validar que los datos de la entidad Alumno sean los correctos, CargarAlumnos() luego de agregar o actualizar un alumno vuelve a cargar los alumnos y Limpiar() que limpia los datos de los textbox.

Agregar Nota.
 
        private void btnguardarnota_Click(object sender, EventArgs e)
        {
            //compruebo las validaciones
            if (!ValidacionesNotas())
                return;

            //creo una nota nueva
            Nota not = new Nota();
            not.AluId = Convert.ToInt32(cbxalumnos.SelectedValue);
            not.MatId = Convert.ToInt32(cbxmaterias.SelectedValue);
            not.NotNota = Convert.ToDecimal(txtnota.Text);

            //si nota para la materia no existe se crea si no muestra mensaje que ya existe
            if (!NotaBL.CreateNota(not))
            {
                MessageBox.Show("Se agrego la Nota con Id:" + not.NotId);
                Limpiar();
            }
            else
                MessageBox.Show("Ya Existe una Nota del Alumno para la Materia:" + cbxmaterias.Text);
        }
La capa de negocio se encarga de validar si ya existe una nota para una materia de un alumno si no existe la agrega y si existe muestra un mensaje que ya existe una nota para la materia, dentro del codigo encontramos los metodos ValidacionesNotas() que lo que hace que los datos para agregar una nota sean correctos y Limpiar() limpia los datos de los textbox.

Editar Notas.
 
        //variable global de entidad nota
        Nota not = new Nota();

        private void btnguardar_Click(object sender, EventArgs e)
        {
            //compruebo validaciones
            if (!ValidacionesNota())
                return;

            not.NotId = Convert.ToInt32(txtidnota.Text);
            not.AluId = Convert.ToInt32(txtidalumno.Text);
            not.MatId = Convert.ToInt32(txtidmateria.Text);
            not.NotNota = Convert.ToDecimal(txtnota.Text);

            //si nota existe la actualizo
            if (NotaBL.UpdateNota(not))
            {
                MessageBox.Show("Se actualizo la nota con Id:" + not.NotId);
                CargarGrilla();
                Limpiar();
            }
            else
                MessageBox.Show("No se pudo actualizar la nota");           
        }
La capa de negocio se encarga de validar si la nota existe por medio del id, si existe actualiza el registro si no muestra mensaje que no se puede actualizar, en el código encontramos los métodos ValidacionesNota() valida que los datos para agregar una nota sean correctos, CargarGrilla() carga todas las notas de un alumno en un datagridview y Limpiar() limpia los datos de los textbox.

Capturas


Conclusión
A lo largo de los 4 artículos hemos visto como desarrollar un proyecto en capas en .net usando entity framework, si bien el ejemplo puede ser un poco sencillo pero puede servir de guía o ejemplo para nuestros futuros desarrollos.

Descargar Proyecto C#

Descargar Proyecto VB.Net

Desarrollo en Capas .Net (Parte 3) - Capa de Negocio

jueves, 25 de octubre de 2012

En el articulo anterior desarrollamos nuestra capa de datos.

 Pueden ver el articulo aquí. Desarrollo en Capas .Net (Parte 2) - Capa de Datos

La capa de negocio(BussinesLayer) se comunicara con la capa de presentación, para recibir las solicitudes y presentar los resultados, y con la capa de datos  para almacenar o recuperar datos de la base de datos.

Algo que seguro a mas de uno les traerá molestias de esta capa de negocio sera que la mayoría de las operaciones  serán un pasamano, ya que esta retorna las operaciones de la capa de datos y las devolverá en la capa de presentación, pero no siempre sera así en otros casos se vera la importancia de esta capa sobre todo en aplicaciones complejas.

Empecemos agregando una clase llamada AlumnoBL.
    public class AlumnoBL
    {
        public static List<Alumno> CargarAlumnos()
        {
            return AlumnoDAL.CargarAlumnos();
        }

        public static Alumno IdAlumno(int id)
        {
            return AlumnoDAL.IdAlumno(id);
        }

        public static Alumno Save(Alumno alum)
        {
            if (AlumnoDAL.Existe(alum.AluId))
                return AlumnoDAL.UpdateAlumno(alum);
            else
                return AlumnoDAL.CreateAlumno(alum);          
        }
    }  
Dentro de la clase tenemos los siguientes métodos.
CargarAlumnos() Este método retorna  todos los registros de la tabla Alumno.
IdAlumno() Este metodo retorna los datos de un alumno por medio del id.
Save() Este método valida si el registro existe por medio del id y dependiendo de esto actualiza o agrega un registro.

Ahora agreguemos una clase llamada MateriaBL.
 
    public class MateriaBL
    {
        public static List<Materia> CargarMaterias()
        {
            return MateriaDAL.CargarMaterias();
        }
    } 
Dentro de esta clase solo tenemos un método CargarMaterias() que lo único que hace es retornar todos los registros de la tabla materia.

Ahora agreguemos una clase llamada NotaBL.
 
    public class NotaBL
    {
        public static Nota IdNota(int id)
        {
            return NotaDAL.IdNota(id);
        }

        public static bool CreateNota(Nota not)
        {
            if (NotaDAL.Existe(not.AluId, not.MatId))
                return true;
            else
            {
                NotaDAL.CreateNota(not);
                return false;
            }
        }

        public static bool UpdateNota(Nota not)
        {
            if (NotaDAL.Existe(not.AluId, not.MatId))
            {
                NotaDAL.UpdateNota(not);
                return true;
            }
            else
            {
                return false;
            }
        }
    } 
Dentro de esta clase encontramos los siguientes métodos.
IdNota() Este método lo que hace es retornar los datos datos de un registro por medio del id.
CreateNota() Este método valida si un registro existe por medio del id del alumno y el id de la materia si existe retorna true, y si no existe crea el registro y retorna false. Validamos si el registro no existe para que un alumno solo pueda agregar una nota por materia..
UpdateNota() Este método igual que el anterior valida si el registro existe por medio del id del alumno y id de la materia solo que si el registro existe actualizamos el registro y retornamos true, y si no existe retornamos false.

Ahora agreguemos una clase llamada NotaAlumnoBL.
 
    public class NotaAlumnoBL
    {
        public static  List<NotaAlumno> CargarNotas()
        {
            return NotaAlumnoDAL.CargarNotas();
        }

        public static  List<NotaAlumno> NotasAlumno(int id)
        {
            return NotaAlumnoDAL.NotasAlumno(id);
        }
    } 
Dentro de esta clase encontramos los siguientes métodos.
CargarNotas() este método retorna todos los registros de la tabla nota.
NotasAlumno() este método retorna todas las notas de un alumno es por eso que hacemos uso del id del alumno para solo devolver solo las notas de un alumno.

Importante que dentro de cada clase que agregamos a nuestra capa de negocio(BussinesLayer) necesitamos  agregar referencias hacia las capas DataAcces Entities.
using DataAcces;
using Entities; 

Eso seria todo en nuestra capa de negocio(BussinesLayer) al final nuestro proyecto quedara de la siguiente manera.

Proyecto


Descargar Proyecto C#

Descargar Proyecto VB.Net

En el próximo y ultimo articulo desarrollaremos nuestra capa de presentación.
Desarrollo en Capas .Net (Parte 4) - Capa Presentacion

Desarrollo en Capas .Net (Parte 2) - Capa de Datos

domingo, 21 de octubre de 2012

En el articulo anterior  creamos nuestro modelo EDMX de nuestra base de datos y también creamos nuestras clases entidades  y las dividimos en una capa aparte llamada Entities.

Pueden ver el primer articulo aquí.
Desarrollo en Capas .Net(Parte 1)

 Pues bien en este segundo articulo desarrollaremos el código que tendrá nuestra capa de datos(DataAcces).

En la capa de datos(DataAcces) es donde tendremos todas las query a nuestra base de datos.

Antes de empezar a programar en nuestra capa de datos  primero agregaremos una clase llamada NotaAlumno en nuestra capa Entities(ya veremos para que nos servira).
   
public class NotaAlumno
{
    public int NotId { get; set; }
    public string AluNombre { get; set; }
    public string MatNombre { get; set; }
    public decimal NotNota { get; set; }
}
Entonces nuestra capa Entities nos quedara de la siguiente manera.

Entities


Como pueden observar nuestra capa Entities tendrá nuestras clases entidades que generamos en el articulo anterior y la nueva clase que acabamos de agregar.

Ahora si empecemos con el código que tendrá nuestra capa de datos(DataAcces) lo que aremos es que por cada clase entidad agregaremos una clase a nuestra capa de datos(DataAcces)  y dentro de estas tendremos las diferentes query a nuestra base de datos.

Agreguemos la primera clase que se llamara AlumnoDAL.
    public class AlumnoDAL
    {
        public static List<Alumno> CargarAlumnos()
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                return bd.Alumno.ToList();
            }
        }

        public static bool Existe(int id)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = (from al in bd.Alumno where al.AluId == id select al).Count();
                if (query == 0)
                    return false;
                else
                    return true;
            }
        }

        public static Alumno IdAlumno(int id)
        {
            Alumno alum = new Alumno();
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = (from al in bd.Alumno
                             where al.AluId == id
                             select al).Single();

                alum.AluId = query.AluId;
                alum.AluNombre = query.AluNombre;
                alum.AluApellido = query.AluApellido;
                alum.AluEdad = query.AluEdad;
                alum.AluDireccion = query.AluDireccion;
            }
            return alum;
        }

        public static Alumno CreateAlumno(Alumno alum)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                Alumno al = new Alumno();
                al.AluNombre = alum.AluNombre;
                al.AluApellido = alum.AluApellido;
                al.AluEdad = alum.AluEdad;
                al.AluDireccion = alum.AluDireccion;
                bd.Alumno.Add(al);
                bd.SaveChanges();
                alum.AluId = al.AluId;
            }
            return alum;
        }

        public static Alumno UpdateAlumno(Alumno alum)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = (from al in bd.Alumno
                             where al.AluId == alum.AluId
                             select al).Single();

                query.AluNombre = alum.AluNombre;
                query.AluApellido = alum.AluApellido;
                query.AluEdad = alum.AluEdad;
                query.AluDireccion = alum.AluDireccion;
                bd.SaveChanges();
            }
            return alum;
        }
        
    }
Dentro de esta clase tenemos una serie de métodos que ahorita explicare.
CargarAlumnos() Este método lo único que hace es retornar todos los registros de la tabla Alumno.
Existe() Este método se encarga de comprobar si un alumno existe por medio del id retorna false si no existe y true si ya existe.
IdAlumno() Este método lo que hace es retornar los datos de un alumno también por medio del id.
CreateAlumno() Este método agrega un nuevo alumno a nuestra base de datos y luego de agregarlo retornamos la entidad osea el alumno agregado.
UpdateAlumno() Este método actualiza un alumno utilizamos el id para actualizar los datos y luego también retornamos la entidad osea el alumno actualizado.

Ahora agreguemos una clase llamada NotaDal.
    public class NotaDal
    {
        public static bool Existe(int idalum, int idmat)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = (from not in bd.Nota where not.AluId == idalum && not.MatId == idmat select not).Count();
                if (query == 0)
                    return false;
                else
                    return true;
            }
        }

        public static Nota IdNota(int id)
        {
            Nota not = new Nota();
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = (from n in bd.Nota
                             where n.NotId == id 
                             select n).Single();

                not.NotId = query.NotId;
                not.AluId = query.AluId;
                not.MatId = query.MatId;
                not.NotNota = query.NotNota;
            }
            return not;
        }

        public static Nota CreateNota(Nota not)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                Nota n = new Nota();
                n.AluId = not.AluId;
                n.MatId = not.MatId;
                n.NotNota = not.NotNota;
                bd.Nota.Add(n);
                bd.SaveChanges();
                not.NotId = n.NotId;
            }
            return not;
        }

        public static Nota UpdateNota(Nota not)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = (from n in bd.Nota
                             where n.NotId == not.NotId 
                             select n).Single();

                query.AluId = not.AluId;
                query.MatId = not.MatId;
                query.NotNota = not.NotNota;
                bd.SaveChanges();
            }
            return not;
        }
    }
Dentro de esta clase encontramos los siguientes métodos.
Existe() Este método se encargara de comprobar si una nota ya existe por medio del id del alumno y el id de la materia este método nos ayudara para que un alumno solo pueda agregar una nota por materia.
IdNota() Este método lo que hace es retornar los datos datos de un registro por medio del id.
CreateNota()  Este método agrega un registro a la tabla nota  y luego  retornamos la entidad osea el registro agregado.
UpdateNota() Este método actualiza una nota utilizamos el id para actualizar los datos y luego también retornamos la entidad osea el registro actualizado.

Ahora agreguemos una clase llamada MateriaDal.
.
    public class MateriaDal
    {
        public static List<Materia> CargarMaterias()
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                return bd.Materia.ToList();
            }
        }
    }
Dentro de esta clase solo tenemos un método CargarMaterias() que lo único que hace es retornar todos los registros de la tabla materia.

Ahora agreguemos una clase llamada NotaAlumnoDal.
    public class NotaAlumnoDal
    {
        public static List<NotaAlumno> CargarNotas()
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = from not in bd.Nota
                            select new NotaAlumno
                            {
                                NotId = not.NotId,
                                AluNombre = not.Alumno.AluNombre,
                                MatNombre = not.Materia.MatNombre,
                                NotNota = not.NotNota
                            };
                return query.ToList();
            }
        }

        public static List<NotaAlumno> NotasAlumno(int id)
        {
            using (EstudiantesEntities bd = new EstudiantesEntities())
            {
                var query = from not in bd.Nota
                            where not.AluId == id
                            select new NotaAlumno
                            {
                                NotId = not.NotId,
                                AluNombre = not.Alumno.AluNombre,
                                MatNombre = not.Materia.MatNombre,
                                NotNota = not.NotNota
                            };

                return query.ToList();
            }
        }
    }
Dentro de esta clase encontramos los siguientes métodos.
CargarNotas() este método retorna todos los registros de la tabla nota.
NotasAlumno() este método retorna todas las notas de un alumno es por eso que hacemos uso del id del alumno para solo devolver solo las notas de un alumno.
En esta clase  hicimos uso de la clase que agregamos a nuestra capa Entities llamada NotaAlumno si se fijan en la query que hacemos a la tabla nota hacemos uso de las propiedades de la clase para en vez de que nos muestre el id del alumno y la materia nos muestre el nombre del alumno y de la materia, haciendo también uso de las propiedades de navegación que existen ente las tablas.

Importante que dentro de cada clase que agregamos a nuestra capa de datos(DataAcces) necesitamos el espacio de nombres Entities para poder hacer uso de nuestras clases entidades.
using Entities;

Eso seria todo en nuestra capa de datos, al final nuestro proyecto nos quedara de la siguiente manera.

Proyecto

Resumiendo lo que hicimos agregamos 4 clases(DAL) a nuestra capa de datos(DataAcces) una por cada clase entidad y dentro de estas tenemos las diferentes query hacia la base de datos.

Descargar Proyecto C#

Descargar Proyecto VB.Net

En el próximo articulo desarrollaremos el código de nuestra capa de negocio(BussinesLayer).
Desarrollo en Capas .Net (Parte 3) - Capa de Negocio

Desarrollo en Capas .Net (Parte 1)

viernes, 12 de octubre de 2012

Introducción
Este sera el primero de 4 artículos en el que trataremos el desarrollo en capas en .net usando Entity Framework.

Aspectos a considerar
  • Se usara Visual Studio 2010 y Sql Express 2008.
  • Se realizara con los lenguajes de C# y VB.Net.(pero solo se explicara con c#)
  • Se usara la versión 4.1 de Entity Framework
  • Se usara un generador de plantillas T4.

En este primer articulo veremos como generar nuestro modelo de datos .edmx de entity framework y veremos como usar DbContext Generator para generar nuestro contexto y clases poco de nuestro modelo. Cual es la finalidad de esto separa las entidades de la persistencia para poder usar estas en otras capas. Para hacer esto necesitaremos la versión ADO.NET Entity Framework 4.1 tambien necesitaremos el generador de plantillas para c# EF 4.x DbContext Generator for C# o para vb.net EF 4.x DbContext Generator for VB.NET

Lo que aremos a lo largo de todo el ejemplo sera dividir el proyecto en capas para poder notar todas las ventajas que esto aporta entre ellas reutilización de código, mejor mantenimiento  de la aplicación, separación de responsabilidades etc.

La siguiente imagen muestra la estructura que tendrá nuestro proyecto final y la comunicación que abra entre las diferentes capas.

Estructura


Para todo el ejemplo usare una base de datos llamada Estudiantes que tiene el siguiente diseño.

Base datos 

Lo primero sera crear un proyecto en blanco y agregar una biblioteca de clases llamada DataAcces.


Data Acces


Ahora vamos a generar  el modelo de nuestra base de datos para eso agregamos un nuevo elemento y elegimos ADO.NET Entity Data Model.

Modelo

Elegimos generar desde la base de datos.

generar desde bd

Especificamos la cadena de conexión hacia la base de datos.

cadena conexion


Ahora seleccionamos los objetos de la base de datos que queremos modelar en este caso seleccionamos las 3 tablas.

tablas


Con esto tendremos nuestro modelo de la base de datos.

modelo bd


Ahora vamos a generar nuestras clases poco haciendo uso del generador de DbContext. Para esto hacemos clic derecho en un espacio en blanco del modelo y elegimos Agregar elemento de generación de código.

generador dbdcontext


Elegimos ADO.NET DbContext Generator(tienen que haberlo instalado antes).

DbContext Generator


Si aparece un cuadro de advertencia eligen no mostrar este mensaje de nuevo y aceptar. Esto agregara 2 plantillas(cuyos nombres terminan en .tt) a su proyecto.

plantillas


La plantilla Students.Context.tt creó una clase DbContext conteniendo las colecciones de entidades y la plantilla Students.tt creó clases separadas para cada tabla.

Para que el modelo DbContext funcione necesita de la version 4.1 de entity framework(tienen que instalarlo) así que agregaremos la dll para eso agregamos una referencia al proyecto y buscamos la dll en la ruta que se instalo que por lo general es C:\Archivos de programa\Microsoft ADO.NET Entity Framework 4.1\Binaries
EF4.1


Ahora lo que aremos es mover la plantilla Students.tt la que contiene las clases de cada tabla a otro proyecto biblioteca de clases en este caso llamado Entities.

Proyecto Entities


Para que esta plantilla funcione ahora que lo hemos movido a una proyecto nuevo tendremos que configurar la linea que apunta hacia el modelo EDMX para eso damos doble clic en la platilla Students.tt y cambiamos la ruta de string InputFile para que apunte hacia el modelo EDMX que se encuentra en el proyecto DataAcces.

inputfile


Ahora cambiaremos el espacio de nombres de la platilla Students.Context.tt ya que las clases entidades las movimos hacia el proyecto Entities tenemos que modificar el espacio de nombres de la plantilla Students.Context.tt para esto abrimos la ventana de propiedades de la plantilla y establecemos el espacio de nombres en Entities.

espacio nombres


Por ultimo lo que tenemos que hacer es agregar una referencia del proyecto Entities en el proyecto DataAcces.

referencia entities


Nota: En el caso del proyecto vb.net en la clase de la platilla Students.Context.vb es necesario agregar un Imports Entities para que el contexto reconozca las clases entidad.

Con esto terminamos la primera parte de nuestro Proyecto. Lo que hemos hecho es crear el modelo de nuestra base de datos y también hemos generado el contexto y las clases entidad del modelo y también hemos separado las clases entidad en un proyecto aparte para poder usar estas clases en las demás capas, ya que como lo dije al principio la finalidad de todos esto es separar las entidades de la persistencia.

Descargar Proyecto C#

Descargar Proyecto VB.Net
 
Nos vemos en la segunda parte donde desarrollaremos el código que tendrá nuestra cada de datos(DataAcces).

Ver segunda parte.
Desarrollo en Capas .Net(Parte 2) - Capa de Datos

Combinar Datos Linq(Cláusula Join) C# - VB.Net

sábado, 22 de septiembre de 2012

Siguiendo con ejemplos de linq ahora veremos como funciona la cláusula Join.

La cláusula Join sirve para establecer una relación entre 2 secuencias comparando sus claves.

 Los programadores familiarizados con conceptos de bases de datos relacionales reconocerán la cláusula Join como Inner Join.

 Mas información.
 join (Cláusula, Referencia de C#)

Veamos el diseño que tendrá nuestra aplicacion.

Diseño

 Ahora agregaremos 2 clases Categoría y Articulo.
public class Categoria
{
        public int CatId { get; set; }
        public string CatNombre { get; set; }

        public Categoria(int id, string nom)
        {
            CatId = id;
            CatNombre = nom;
        }
}
public class Articulo
{
        public int ArtId { get; set; }
        public string ArtNombre { get; set; }
        public double ArtPrecio { get; set; }
        public int CatId { get; set; }

        public Articulo(int id,string nom,double prec, int cat)
        {
            ArtId = id;
            ArtNombre = nom;
            ArtPrecio = prec;
            CatId = cat;
        }
}
Public Class Categoria
    Public Property CatId() As Integer
    Public Property CatNombre() As String
    Sub New(ByVal id As Integer, ByVal nom As String)
        CatId = id
        CatNombre = nom
    End Sub
End Class
Public Class Articulo
    Public Property ArtId() As Integer
    Public Property ArtNombre() As String
    Public Property ArtPrecio() As Double
    Public Property CatId() As Integer

    Sub New(ByVal id As Integer, ByVal nom As String, ByVal prec As Double, ByVal cat As Integer)
        ArtId = id
        ArtNombre = nom
        ArtPrecio = prec
        CatId = cat
    End Sub
End Class
Como podemos notar son 2 clases sencillas con algunas propiedades que usaremos para representar nuestros datos, importante notar que ambas clases tienen una propiedad en común CatId que es la que usaremos para establecer la relación entre ellas.

Ahora agreguemos algunos registros.

List<Categoria> categorialist = new List<Categoria>
{
     new Categoria(1, "Bebidas"),
     new Categoria(2, "Lacteos"),
     new Categoria(3, "Frutas")
};

List<Articulo> articulolist = new List<Articulo>
{
     new Articulo(1, "Cerveza negra Steeleye", 18.20, 1),
     new Articulo(2, "Queso Mozzarella", 34.50, 2),
     new Articulo(3, "Naranjas", 10.25, 3),
     new Articulo(4, "Cerveza Sasquatch", 15.00, 1),
     new Articulo(5, "Crema de Almejas", 9.75, 2),
     new Articulo(6, "Manzanas", 4.50, 3),
     new Articulo(7, "Vino Côte de Blaye", 250.25, 1),
     new Articulo(8, "Cerveza Heineken", 20.50, 1),
     new Articulo(9, "CocaCola", 5.75, 1)
};
    Dim categorialist As New List(Of Categoria)() From {
        New Categoria(1, "Bebidas"),
        New Categoria(2, "Lacteos"),
        New Categoria(3, "Frutas")
    }

    Dim articulolist As New List(Of Articulo)() From {
        New Articulo(1, "Cerveza negra Steeleye", 18.2, 1),
        New Articulo(2, "Queso Mozzarella", 34.5, 2),
        New Articulo(3, "Naranjas", 10.25, 3),
        New Articulo(4, "Cerveza Sasquatch", 15.0, 1),
        New Articulo(5, "Crema de Almejas", 9.75, 2),
        New Articulo(6, "Manzanas", 4.5, 3),
        New Articulo(7, "Vino Côte de Blaye", 250.25, 1),
        New Articulo(8, "Cerveza Heineken", 20.5, 1),
        New Articulo(9, "CocaCola", 5.75, 1)
    }
Hemos agregado 3 categorías y 9 artículos donde cada articulo tiene un código de categoría al que pertenece.

Carguemos los artículos en el datagrid sin aplicar join y veremos como se muestran.
private void Form1_Load(object sender, EventArgs e)
{
     var query = from art in articulolist select art;
     dataGridView1.DataSource = query.ToList();
}
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        Dim query = From art In articulolist Select art
        DataGridView1.DataSource = query.ToList()
End Sub
Datos

Lo que hemos hecho es cargar los artículos en el datagrid normalmente.

Ahora veamos como utilizar el  Join  de linq para que no nos muestre el código de categoría(CatId) si no que nos muestre el nombre de la categoría la que el articulo pertenece.
var query = from cat in categorialist
            join art in articulolist
            on cat.CatId equals art.CatId
            orderby art.ArtId ascending
            select new { Id = art.ArtId, Nombre = art.ArtNombre, Precio = art.ArtPrecio, Categoria = cat.CatNombre };

dataGridView1.DataSource = query.ToList();
Dim query = From cat In categorialist
            Join art In articulolist
            On cat.CatId Equals art.CatId
            Order By art.ArtId Ascending
            Select New With {.Id = art.ArtId, .Nombre = art.ArtNombre, .Precio = art.ArtPrecio, .Categoria = cat.CatNombre}

DataGridView1.DataSource = query.ToList()
Como verán tiene un gran parecido al inner join de sql donde por medio de la propiedad que tienen en común CatId podemos establecer la relación entre ambas clases y así poder consultar los campos que necesitemos.

Join

Eso es todo espero les sirva mucho saludos desde El Salvador...

Descargar Proyecto C#

Descargar Proyecto VB.Net


No olvides suscribirte al blog para estar pendientes de mis últimos artículos.

Consultar Tablas Relacionadas(Inner Join) Sql Server

sábado, 8 de septiembre de 2012

Cuando se trabaja con base de datos en mas de una ocasión tocara hacer consultas a tablas que se encuentran relacionadas ahora veremos como hacerlo usando inner join.

Para este ejemplo he creado una base de datos llamada Productos que cuenta con 2 tablas que están relacionadas Categoría y Articulo.

Tablas


Como pueden notar son 2 tablas Categoría y Articulo que tienen un campo en común por el cual están relacionadas CatId.

También e agregado algunos registros a cada tabla.

Categoria


Articulo


Como pueden notar he agregado 3 categorías y algunos artículos en donde cada articulo pertenece a un código de categoría.

Ahora veamos como hacer una consulta para obtener el nombre y el precio de los artículos que pertenezcan a una categoría.
select ArtNombre, ArtPrecio
From Articulo art Inner Join Categoria cat
on art.CatId = cat.CatId
Where CatNombre = 'Bebidas'

Lo primero que hacemos es un select a los campos que necesitamos en este caso nombre y precio luego hacemos la relación a las 2 tablas usando inner join por medio del campo que tienen en común CatId y por ultimo especificamos que nos muestre los artículos que pertenezcan a la categoría Bebidas.

Con esta consulta obtendríamos el nombre y precio de los artículos que son de la categoría bebidas.

Consulta


Bueno eso seria todos espero les sirva de algo.

Les dejo la base de datos por si quieren hacer pruebas.

Descargar Base de Datos


No olvides suscribirte al blog para estar pendientes de mis últimos artículos.

Agrupar Datos Linq (GroupBy) C# - VB.Net

martes, 28 de agosto de 2012

Siguiendo con ejemplos de linq ahora veremos como funciona el operador GroupBy.

El operador GroupBy nos permite agrupar una secuencia de datos bajo una clave.

Mas información.
group (Cláusula, Referencia de C#)
Group By (Cláusula, Visual Basic)

En este articulo trataremos los siguientes puntos.
  • Mostrar datos de una lista en ListView.
  • Agrupar datos de una lista tipo clase.
  • Mostrar datos agrupados en ListView.

Veamos el diseño que tendrá nuestra aplicacion.

Diseño


Como pueden observar el form solo cuenta con un listview al cual se le definieron 3 columnas en tiempo de diseño y también se tiene un botón.

Ahora agregamos una clase llamada Persona.
public class Persona
{
   public string Nombre { get; set; }
   public int Edad { get; set; }
   public string Pais { get; set; }
   public Persona(string nom, int ed, string pa)
   {
          Nombre = nom;
          Edad = ed;
          Pais = pa;
   }
} 

Public Class Persona
  Public Property Nombre() As String
  Public Property Edad() As Integer
  Public Property Pais() As String

  Public Sub New(ByVal nom As String, ByVal ed As Integer, ByVal pa As String)
      Nombre = nom
      Edad = ed
      Pais = pa
  End Sub

End Class

Es una simple clase que nos servirá para el manejo de nuestros datos.

Ahora creemos una lista de tipo Persona y agreguemos unos registros.
List<persona> personas = new List<persona>
{
   new Persona("Cristian", 21, "El Salvador"),
   new Persona("Fatima", 19, "Argentina"),
   new Persona("Juan", 25, "El Salvador"),
   new Persona("Maria", 18, "España"),
   new Persona("Javier", 40, "Argentina"),
   new Persona("Rosa", 35, "Mexico"),
   new Persona("Josue", 26, "España"),
   new Persona("Karla", 50, "Mexico")
};

Dim personas As New List(Of Persona)() From {
   New Persona("Cristian", 21, "El Salvador"), _
   New Persona("Fatima", 19, "Argentina"), _
   New Persona("Juan", 25, "El Salvador"), _
   New Persona("Maria", 18, "España"), _
   New Persona("Javier", 40, "Argentina"), _
   New Persona("Rosa", 35, "Mexico"), _
   New Persona("Josue", 26, "España"), _
   New Persona("Karla", 50, "Mexico") _
}

En los registros que hemos agregado pueden notar que algunas personas son del mismo país entonces utilizaremos ese dato para agruparlos por país.

Cargar datos en el ListView(cargamos los datos sin agrupar)

Primero cargaremos los datos así como están sin agrupar en listview.
foreach (var p in personas)
{
   ListViewItem item = new ListViewItem(p.Pais);
   item.SubItems.Add(p.Nombre);
   item.SubItems.Add(p.Edad.ToString());
   listView1.Items.Add(item);
}

For Each p In personas
  Dim item As New ListViewItem(p.Pais)
  item.SubItems.Add(p.Nombre)
  item.SubItems.Add(p.Edad.ToString())
  listView1.Items.Add(item)
Next

Recorremos la lista con un ciclo foreach y dentro vamos agregando los datos al listview.

Agrupar los datos y mostrarlos en el ListView.
Agruparemos los datos por país y de una sola vez los mostraremos agrupados dentro del listview.
var agrupar = personas.GroupBy(persona => persona.Pais);
string group = "";
ListViewGroup g = new ListViewGroup();
listView1.Items.Clear();
foreach (var p in agrupar)
{
    if (p.Key.ToString() != group)
    {
         g = new ListViewGroup(p.Key.ToString());
         group = p.Key.ToString();
         listView1.Groups.Add(g);
    }
    foreach (var persona in p)
    {
         ListViewItem item = new ListViewItem("");
         item.SubItems.Add(persona.Nombre);
         item.SubItems.Add(persona.Edad.ToString());
         item.Group = g;
         listView1.Items.Add(item);
    }
}

Dim agrupar = personas.GroupBy(Function(persona) persona.Pais)
Dim group As String = ""
Dim g As New ListViewGroup()
listView1.Items.Clear()
For Each p In agrupar
  If p.Key.ToString() <> group Then
       g = New ListViewGroup(p.Key.ToString())
       group = p.Key.ToString()
       listView1.Groups.Add(g)
  End If
  For Each persona In p
      Dim item As New ListViewItem("")
      item.SubItems.Add(persona.Nombre)
      item.SubItems.Add(persona.Edad.ToString())
      item.Group = g
      listView1.Items.Add(item)
  Next
Next

Lo primero que hacemos es agrupar los datos haciendo uso de linq agrupamos los datos por país, luego declaramos una variable string vacía y también se crea un objeto ListViewGroup esto nos servirá para poder mostrar los datos agrupados en el listview, luego recorremos el resultado de nuestra consulta linq y vamos agregando los datos ya agrupados en el listview.

Datos sin agrupar


Datos agrupados


Eso es todo espero les sirva mucho saludos desde El Salvador...

Descargar Proyecto C#

Descargar Proyecto VB.Net


No olvides suscribirte al blog para estar pendientes de mis últimos artículos.

Mejorar Diseño de Formulario Asp.Net con jqTransform

domingo, 19 de agosto de 2012

Siempre que se desarrollan aplicaciones web el diseño es una parte muy importante y siempre se busca una manera rápida y fácil de darle un bonito diseño a nuestras aplicaciones pues hay buenas noticias ya que con jqTransform un plugin de jquery podemos aplicar un bonito diseño a nuestros formularios asp.net de una forma fácil y rápida.

Primeramente veamos el diseño normal del formulario.

Diseño


Pueden notar que es un simple formulario al que hemos agregado algunos controles.

Ahora cambiaremos el diseño de los controles que hemos agregado usando el plugin jqTransform.




Lo que se hace es hacer referencia a la hoja de estilo que el plugin trae y también necesitamos hacer referencia a jquery y al plugin jqTransform, y en el código jquery lo único que hacemos es aplicar el estilo a todos los controles que estén dentro del formulario.

Ahora lo único que tenemos que hacer es dentro del código del formulario que queramos cambiar el diseño agregamos la clase del plugin jqTransform.

Eso seria todo con estas simples lineas de código estaríamos cambiando el diseño simple de nuestro formulario.

Captura


Captura


Eso seria todo espero les sirva de algo les dejo la descarga del ejemplo ya incluye el plugin jqTransform.

Descargar Ejemplo

Sumar Columnas DataGridView usando Linq

martes, 14 de agosto de 2012

Cuando usamos el control DataGridView muchas veces necesitamos realizar operaciones sobre las filas o columnas del control, ahora veremos la manera de como realizar la suma de una columna del datagriedview usando linq.

El ejemplo esta desarrollado en visual estudio 2010 con los lenguajes c# y vb.net.

El ejemplo es sencillo y usare un datatable que lleno manualmente para el origen de datos, en un ejemplo real este datatable se llenaría con datos de una base de datos.

El diseño de la aplicacion es el siguiente.

Diseño

Ahora veamos la manera como llenamos el datatable con los datos que usaremos.
        private DataTable Datos()
{
DataTable dt = new DataTable();
dt.Columns.Add("Id");
dt.Columns.Add("Producto");
dt.Columns.Add("Total");

DataRow row = dt.NewRow();
row["Id"] = 1;
row["Producto"] = "Arroz";
row["Total"] = 50.00;
dt.Rows.Add(row);

row = dt.NewRow();
row["Id"] = 2;
row["Producto"] = "Pollo";
row["Total"] = 75.25;
dt.Rows.Add(row);

row = dt.NewRow();
row["Id"] = 3;
row["Producto"] = "Frijoles";
row["Total"] = 60.25;
dt.Rows.Add(row);

row = dt.NewRow();
row["Id"] = 4;
row["Producto"] = "Leche";
row["Total"] = 45.25;
dt.Rows.Add(row);

return dt;
}

    Private Function Datos() As DataTable
Dim dt As New DataTable()
dt.Columns.Add("Id")
dt.Columns.Add("Producto")
dt.Columns.Add("Total")

Dim row As DataRow = dt.NewRow()
row("Id") = 1
row("Producto") = "Arroz"
row("Total") = 50.0
dt.Rows.Add(row)

row = dt.NewRow()
row("Id") = 2
row("Producto") = "Pollo"
row("Total") = 75.25
dt.Rows.Add(row)

row = dt.NewRow()
row("Id") = 3
row("Producto") = "Frijoles"
row("Total") = 60.25
dt.Rows.Add(row)

row = dt.NewRow()
row("Id") = 4
row("Producto") = "Leche"
row("Total") = 45.25
dt.Rows.Add(row)

Return dt
End Function

Es un método de tipo datatable que retornara todos los datos en este caso como ya lo dije agrego los datos manualmente en caso de usar una base de datos lo único que cambiaría seria la manera de como se llena el datatable.

Ahora en el evento load del formulario cargamos los datos en el datagriedview y agregamos una nueva fila al datatable.
        private void Form1_Load(object sender, EventArgs e)
{
//agregamos una nueva fila al datatable
DataTable dt = Datos();
DataRow row= dt.NewRow();
dt.Rows.Add(row);

//mostramos los datos en el datagriedview
dataGridView1.AutoGenerateColumns = false;
dataGridView1.DataSource = dt;

//Mostramos el valor de 0 en la fila que agregamos
DataGridViewRow rowtotal = dataGridView1.Rows[dataGridView1.Rows.Count - 1];
rowtotal.Cells["Total"].Value = 0;

}

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
'agregamos una nueva fila al datatable
Dim dt As DataTable = Datos()
Dim row As DataRow = dt.NewRow()
dt.Rows.Add(row)

'mostramos los datos en el datagriedview
dataGridView1.AutoGenerateColumns = False
dataGridView1.DataSource = dt

'mostramos el valor de 0 en la fila que agregamos
Dim rowtotal As DataGridViewRow = dataGridView1.Rows(dataGridView1.Rows.Count - 1)
rowtotal.Cells("Total").Value = 0
End Sub

Lo primero que hacemos es agregar una nueva fila al datatable que nos servirá para mostrar el total de la suma de la columna, luego cargamos los datos en el datagriedview y por ultimo le asignamos el valor de 0 a la fila que agregamos para calcular la suma.

Lo ultimo que nos queda por hacer es calcular la suma de la columna del datagriedview que en este caso sera la columna Total y mostrar el resultado.
       private void btntotal_Click(object sender, EventArgs e)
{
//hacemos la suma de la columna total
double resul = dataGridView1.Rows.Cast<DataGridViewRow>().Sum(x => Convert.ToDouble(x.Cells["Total"].Value));

//mostramos la suma en el textbox y en la fila que agregamos
txttotal.Text = Convert.ToString(resul);
DataGridViewRow rowtotal = dataGridView1.Rows[dataGridView1.Rows.Count - 1];
rowtotal.Cells["Total"].Value = resul;
}

    Private Sub btntotal_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btntotal.Click
'hacemos la suma de la columna Total
Dim resul As Double = dataGridView1.Rows.Cast(Of DataGridViewRow)().Sum(Function(x) Convert.ToDouble(x.Cells("Total").Value))

'mostramos la suma en el textbox y en la fila que agregamos
txttotal.Text = Convert.ToString(resul)
Dim rowtotal As DataGridViewRow = dataGridView1.Rows(dataGridView1.Rows.Count - 1)
rowtotal.Cells("Total").Value = resul
End Sub

Como pueden observar si se hace uso de linq se puede obtener la suma de la columna del datagriedview en una sola linea de codigo sin necesidad de recorrer el datagriedview, luego que se obtiene el resultado lo único que se hace es mostrarlo en el textbox y en la fila adicional que agregamos.

Captura

Eso es todo espero les sirva mucho saludos desde El Salvador...

Descargar Proyecto C#

Descargar Proyecto VB.Net


No olvides suscribirte al blog para estar pendientes de mis últimos artículos.


Guardar y Mostrar Imagenes de Base de Datos en .Net

lunes, 30 de julio de 2012

Hola espero todos anden bien, ahora veremos como trabajar con imágenes en .Net

En este articulo trataremos los siguientes puntos.
  • Insertar imágenes en base de datos.
  • Visualizar imágenes en Datagriedview.
  • Buscar y cargar imagen en PictureBox.

El ejemplo esta desarrollado en visual estudio 2010 con c# y vb.net y se usa sqlexpress 2008.

Para este ejemplo usaremos una bd llamada Database y que cuenta con una tabla llamada Personas que cuenta con un campo de tipo image, el campo id es de tipo identity osea se incrementara solo.

BD

El diseño de nuestra aplicacion sera el siguiente.

Diseño

Algo importante que hay que resaltar es que las columnas del datagriedview fueron establecidas en tiempo de diseño.

Columnas

Como pueden observar se crearon las 4 columnas para los datos indicando que una columna sea de tipo image, la propiedad importante cuando se crean las columnas en tiempo de diseño es DataPropertyName ya que sirve para indicar que campo del origen de datos será asignado a esa columna.

Una vez explicado el diseño de nuestra aplicacion vamos al código, lo primero que aremos sera agregar una clase(modulo en el caso de vb.net) llamada Datos y le agregaremos el siguiente código.
       public static DataTable Cargar()
      {
          using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ToString()))
          {
              DataTable dt = new DataTable();
              string query = "SELECT * FROM PERSONAS";
              SqlCommand cmd = new SqlCommand(query, conn);
              SqlDataAdapter adap = new SqlDataAdapter(cmd);
              adap.Fill(dt);
              return dt;
          }
      }

      public static void Insert(string nombre, string apellido, byte[] foto)
      {
          using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ToString()))
          {
              string query = "INSERT INTO Personas(nombre,apellido,foto) VALUES(@nombre,@apellido,@foto)";
              SqlCommand cmd = new SqlCommand(query, conn);

              cmd.Parameters.AddWithValue("@nombre", nombre);
              cmd.Parameters.AddWithValue("@apellido", apellido);
              cmd.Parameters.Add("@foto", System.Data.SqlDbType.Image).Value=foto;
              conn.Open();
              try
              {
                  cmd.ExecuteNonQuery();
                  MessageBox.Show("Registro Ingresado con Exito...");
              }
              catch (Exception ex)
              {
                  MessageBox.Show(ex.ToString());
              }
          }
      }

   Public Function Cargar() As DataTable
      Using conn As New SqlConnection(ConfigurationManager.ConnectionStrings("default").ToString())
          Dim dt As New DataTable()
          Dim query As String = "SELECT * FROM PERSONAS"
          Dim cmd As New SqlCommand(query, conn)
          Dim adap As New SqlDataAdapter(cmd)
          adap.Fill(dt)
          Return dt
      End Using
  End Function

  Public Sub Insert(ByVal nombre As String, ByVal apellido As String, ByVal foto As Byte())
      Using conn As New SqlConnection(ConfigurationManager.ConnectionStrings("default").ToString())
          Dim query As String = "INSERT INTO Personas(nombre,apellido,foto) VALUES(@nombre,@apellido,@foto)"
          Dim cmd As New SqlCommand(query, conn)

          cmd.Parameters.AddWithValue("@nombre", nombre)
          cmd.Parameters.AddWithValue("@apellido", apellido)
          cmd.Parameters.Add("@foto", System.Data.SqlDbType.Image).Value = foto
          conn.Open()
          Try
              cmd.ExecuteNonQuery()
              MessageBox.Show("Registro Ingresado con Exito...")
          Catch ex As Exception
              MessageBox.Show(ex.ToString())
          End Try
      End Using
  End Sub

En el primer método Cargar lo único que haces es devolver un datatable con los datos de nuestra tabla. Y el segundo método Insert es el que nos servirá para insertar registros en nuestra bd importante notar que el parámetro que usaremos para insertar la foto es de tipo byte.

Ahora agregaremos otra clase(modulo para el caso de vb.net) llamada ConvertImage y agregamos el siguiente código.
       public static Image ByteArrayToImage(byte[] byteArrayIn)
      {
          MemoryStream ms = new MemoryStream(byteArrayIn);
          return Image.FromStream(ms);
      }

      public static byte[] ImageToByteArray(Image imageIn)
      {
          MemoryStream ms = new MemoryStream();
          imageIn.Save(ms, ImageFormat.Jpeg);
          return ms.ToArray();
      }

   Public Function ByteArrayToImage(ByVal byteArrayIn As Byte()) As Image
      Dim ms As New MemoryStream(byteArrayIn)
      Return Image.FromStream(ms)
  End Function

  Public Function ImageToByteArray(ByVal imageIn As Image) As Byte()
      Dim ms As New MemoryStream()
      imageIn.Save(ms, ImageFormat.Jpeg)
      Return ms.ToArray()
  End Function

Tenemos 2 métodos que usaremos para convertir el array de byte en Image y viceversa.

Ahora pasemos al código de nuestra formulario, veamos como cargar los datos en el datagrid.
       private void cargar()
      {
          dataGridView1.AutoGenerateColumns = false;
          dataGridView1.DataSource = Datos.Cargar();

          foreach (DataGridViewRow row in dataGridView1.Rows)
          {
              row.Height = 100;
              DataRowView rows = row.DataBoundItem as DataRowView;
              row.Cells["Foto"].Value = ConvertImage.ByteArrayToImage((byte[])rows["Foto"]);
          }
      }

   Private Sub cargar()
      dataGridView1.AutoGenerateColumns = False
      dataGridView1.DataSource = Datos.Cargar()

      For Each row As DataGridViewRow In dataGridView1.Rows
          row.Height = 100
          Dim rows As DataRowView = TryCast(row.DataBoundItem, DataRowView)
          row.Cells("Foto").Value = ConvertImage.ByteArrayToImage(DirectCast(rows("Foto"), Byte()))
      Next
  End Sub

Primero tenemos un método cargar que sera donde se cargaran los datos de nuestra tabla en el datagrid, y recorremos el datagriedview para convertir nuestro array de byte en image y así podes visualizar la imagen en el datagriedview, cuando queramos cargar los datos en el datagrid lo único que ariamos es llamar este método.

Ahora veamos el código de nuestro botón que usaremos para buscar la imagen.
       private void btnbuscar_Click(object sender, EventArgs e)
      {
          OpenFileDialog file = new OpenFileDialog();
          file.Filter = "Archivo JPG|*.jpg";

          if (file.ShowDialog() == DialogResult.OK)
          {
              pictureBox1.Image = Image.FromFile(file.FileName);
          }
      }

   Private Sub btnbuscar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnbuscar.Click
      Dim file As New OpenFileDialog()
      file.Filter = "Archivo JPG|*.jpg"
      If file.ShowDialog() = DialogResult.OK Then
          pictureBox1.Image = Image.FromFile(file.FileName)
      End If
  End Sub

Se usa OpenFileDialog para poder buscar una imagen y luego la cargamos en el Picturebox.

Ahora veamos el código del botón para insertar registros.
       private void btnagregar_Click(object sender, EventArgs e)
      {
          Datos.Insert(txtnombre.Text,txtapellido.Text,ConvertImage.ImageToByteArray(pictureBox1.Image));
          cargar();
      }

   Private Sub btnagregar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnagregar.Click
      Datos.Insert(txtnombre.Text, txtapellido.Text, ConvertImage.ImageToByteArray(pictureBox1.Image))
      cargar()
  End Sub

Lo único que hacemos es llamar al método Insert de nuestra clase Datos y le enviamos los parámetros y luego llamamos al metodo cargar para que los datos que se inserten se vayan mostrando en el datagriedview.

Captura

Eso es todo espero les sirva mucho saludos desde El Salvador...

Descargar Proyecto C#

Descargar Proyecto VB.Net


No olvides suscribirte al blog para estar pendientes de mis últimos artículos.

Comprobar si Existe Registro en BD C# - VB.Net

jueves, 26 de julio de 2012

He notado con frecuencia en los diferentes foros de programación que hay en la web preguntar como saber si un registro existe en la bd, como también recuperar el id de un registro desde el código de nuestra aplicacion pues bien en este articulo se explicara como hacerlo.

En este articulo trataremos los siguientes puntos.
  1. Comprobar si un registro existe por medio del id.
  2. Recuperar el ultimo id ingresado e ir incrementándolo.
  3. Comprobar Datos antes de ingresar un registro.

El ejemplo esta desarrollado en visual estudio 2010 en c# y vb.net y se usa sqlexpres 2008.

Para este ejemplo uso una base de datos llamada Database que cuenta con una tabla Personas.

BD

La aplicacion tiene el siguiente diseño.

Diseño

Ahora a programar agreguemos una clase(modulo en el caso de vb.net) a nuestro proyecto llamado Datos aquí tendremos todos los métodos que usaremos para que desde el código de nuestro formulario solo los llamemos.

Veamos primeramente el método que se encargara de cargar todos los datos de nuestra bd.
       public static DataTable Cargar()
     {
         using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ToString()))
         {
             DataTable dt = new DataTable();
             string query = "SELECT * FROM PERSONAS ORDER BY Id ASC";
             SqlCommand cmd = new SqlCommand(query, conn);
             SqlDataAdapter adap = new SqlDataAdapter(cmd);
             adap.Fill(dt);
             return dt;
         }
     }

    Public Function Cargar() As DataTable
     Using conn As New SqlConnection(ConfigurationManager.ConnectionStrings("default").ToString())
         Dim dt As New DataTable()
         Dim query = "SELECT * FROM PERSONAS ORDER BY Id ASC"
         Dim cmd As New SqlCommand(query, conn)
         Dim adap As New SqlDataAdapter(cmd)
         adap.Fill(dt)
         Return dt
     End Using
 End Function

Este código ya es conocido por todos ya que en casi todos mis artículos los uso para cargar los datos de la bd, es un método que retorna un datatable con todos los datos de la bd.

Ahora veamos el método que nos servirá para comprobar si un registro existe o no.
      public static bool Existe(int id)
     {
         using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ToString()))
         {
             string query = "SELECT COUNT(*) FROM PERSONAS WHERE ID=@Id";
             SqlCommand cmd = new SqlCommand(query, conn);
             cmd.Parameters.AddWithValue("Id", id);
             conn.Open();

             int count = Convert.ToInt32(cmd.ExecuteScalar());
             if (count == 0)
                 return false;
             else
                 return true;
         }
     }

    Public Function Existe(ByVal id As Integer) As Boolean
     Using conn As New SqlConnection(ConfigurationManager.ConnectionStrings("default").ToString())
         Dim query = "SELECT COUNT(*) FROM PERSONAS WHERE ID=@Id"
         Dim cmd As New SqlCommand(query, conn)
         cmd.Parameters.AddWithValue("Id", id)
         conn.Open()

         Dim count As Integer = Convert.ToInt32(cmd.ExecuteScalar())
         If count = 0 Then
             Return False
         Else
             Return True
         End If
     End Using
 End Function

Tenemos el método Existe que es de tipo bool y que también recibe un parámetro en este caso sera el id que sera por el cual comprobaremos si el registro existe, vemos que en la consulta a la bd usamos la instrucción COUNT que devuelve el numero de registros que existe con ese id, también usamos el método ExecuteScalar() para comprobar si encontró registro con el id si el valor es cero es porque no existe el registro entonces retornamos false y retornamos true si ya existe el registro es decir que si encontró registro con ese id.

Ahora veamos como recuperar el ultimo id ingresado, esto lo aremos porque el campo id no es autonumerico por eso necesitamos obtener por medio de código cual sera el próximo valor a ingresar.
      public static int RecuperarId()
     {
         using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ToString()))
         {
             string query = "SELECT  MAX(Id) FROM PERSONAS";
             SqlCommand cmd = new SqlCommand(query, conn);
             conn.Open();

             return Convert.ToInt32(cmd.ExecuteScalar());
         }
     }

    Public Function RecuperarId() As Integer
     Using conn As New SqlConnection(ConfigurationManager.ConnectionStrings("default").ToString())
         Dim query = "SELECT  MAX(Id) FROM PERSONAS"
         Dim cmd As New SqlCommand(query, conn)
         conn.Open()

         Return Convert.ToInt32(cmd.ExecuteScalar())
     End Using
 End Function

Tenemos el método RecuperarId que retorna un valor numérico que sera el valor del ultimo id, vemos que en la query a nuestra bd usamos la función MAX de sql que devuelve el valor máximo de un campo de nuestra tabla en este caso el id y por ultimo retornamos ese valor usando nuevamente el método ExecuteScalar.

Por ultimo tenemos el método Insert que nos servirá para insertar un nuevo registro.
      public static void Insert(int id, string nombre, string apellido, int edad)
     {
         using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["default"].ToString()))
         {
             string query = "INSERT INTO PERSONAS(Id,Nombre,Apellido,Edad) VALUES(@Id,@Nombre,@Apellido,@Edad)";
             id = RecuperarId() + 1;
             SqlCommand cmd = new SqlCommand(query, conn);
             cmd.Parameters.AddWithValue("Id", id);
             cmd.Parameters.AddWithValue("Nombre", nombre);
             cmd.Parameters.AddWithValue("Apellido", apellido);
             cmd.Parameters.AddWithValue("Edad", edad);
             conn.Open();
             try
             {
                 cmd.ExecuteNonQuery();
                 MessageBox.Show("Registro Ingresado con Exito...");
             }
             catch (Exception)
             {
                 MessageBox.Show("Error no se Pudo Ingresar el Registro...");
             }
         }
     }

    Public Sub Insert(ByVal id As Integer, ByVal nombre As String, ByVal apellido As String, ByVal edad As Integer)
     Using conn As New SqlConnection(ConfigurationManager.ConnectionStrings("default").ToString())
         Dim query = "INSERT INTO PERSONAS(Id,Nombre,Apellido,Edad) VALUES(@Id,@Nombre,@Apellido,@Edad)"
         id = RecuperarId() + 1
         Dim cmd As New SqlCommand(query, conn)
         cmd.Parameters.AddWithValue("Id", id)
         cmd.Parameters.AddWithValue("Nombre", nombre)
         cmd.Parameters.AddWithValue("Apellido", apellido)
         cmd.Parameters.AddWithValue("Edad", edad)
         conn.Open()
         Try
             cmd.ExecuteNonQuery()
             MessageBox.Show("Registro Ingresado con Exito...")
         Catch ex As Exception
             MessageBox.Show("Error no se Pudo Ingresar el Registro...")
         End Try
     End Using
 End Sub

creamos el método Insert y le pasamos los parámetros para insertar un nuevo registro, luego hacemos la query a la bd para hacer el insert y le pasamos los parámetros de cada campo, algo importante de mencionar es que antes de enviar el parámetro del id calculamos su valor haciendo uso del método RecuperarId que como dijimos devuelve el valor máximo de id entonces a este solo le sumamos 1 para que siempre se vaya incrementado en 1.

Eso seria todo en nuestra clase Datos.

Ahora en el evento load de nuestro formulario cargamos todos los datos.
       private void Form1_Load(object sender, EventArgs e)
     {
         dataGridView1.DataSource = Datos.Cargar();
     }

    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
     DataGridView1.DataSource = Datos.Cargar()
 End Sub

Lo unico que hacemos es cargar todos los datos de nuestro tabla llamando el método.
Cargar.

Ahora en el evento del botón que usaremos para comprobar si existe el registro tendremos el siguiente código.
      private void btncomprobar_Click(object sender, EventArgs e)
     {
         if (!Datos.IsNumeric(txtcomprobar.Text))
             MessageBox.Show("Ingres un Valor Numerico...");
         else
         {
             if (!Datos.Existe(Convert.ToInt32(txtcomprobar.Text)))
                 MessageBox.Show("Registro No Existe...");
             else
                 MessageBox.Show("Registro Ya Existe...");
         }
     }

    Private Sub btncomprobar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btncomprobar.Click
     If (Not IsNumeric(txtcomprobar.Text)) Then
         MessageBox.Show("Ingres un Valor Numerico...")
     Else
         If (Not Datos.Existe(Convert.ToInt32(txtcomprobar.Text))) Then
             MessageBox.Show("Registro No Existe...")
         Else
             MessageBox.Show("Registro Ya Existe...")
         End If
     End If
 End Sub

Antes de comprobar si existe el registro por medio del id comprobamos que el dato ingresado sea numerico si lo es entonces llamamos al metodo Existe y le pasamos el valor ingresado y mostramos los respectivos mensajes si el id ya existe o no.

Ahora en el evento del boton que usaremos para agregar un nuevo registro tendremos lo siguiente.
      private void btnagrear_Click(object sender, EventArgs e)
     {
         if (!Datos.IsNumeric(txtid.Text) | !Datos.IsNumeric(txtedad.Text))
         {
             MessageBox.Show("Ingres un Valor Numerico...");
         }
         else
         {
             if (!Datos.Existe(Convert.ToInt32(txtid.Text)))
             {
                 Datos.Insert(Convert.ToInt32(txtid.Text), txtnombre.Text, txtapellido.Text, Convert.ToInt32(txtedad.Text));
                 dataGridView1.DataSource = Datos.Cargar();
             }
             else
             {
                 MessageBox.Show("Id Ya Existe...");
             }
         }
     }

    Private Sub btnagrear_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnagrear.Click
     If (Not IsNumeric(txtid.Text) Or Not IsNumeric(txtedad.Text)) Then
         MessageBox.Show("Ingres un Valor Numerico...")
     Else
         If (Not Datos.Existe(Convert.ToInt32(txtid.Text))) Then
             Datos.Insert(Convert.ToInt32(txtid.Text), txtnombre.Text, txtapellido.Text, Convert.ToInt32(txtedad.Text))
             DataGridView1.DataSource = Datos.Cargar()
         Else
             MessageBox.Show("Id Ya Existe...")
         End If
     End If
 End Sub

Antes de ingresar hacemos 2 validaciones primero comprobamos que el los datos del id y la edad sean numericos y tambien validamos que el id ingresado no exista si pasa las 2 validaciones agregamos el registro si no mostramos un mensaje que no se pudo agregar.

comprobar


agregar

Eso es todo espero les sirva de algo saludos desde El Salvador.

Descargar Proyecto C#

Descargar Proyecto VB.Net

Formulario de Contacto con Recaptcha Asp.Net

jueves, 19 de julio de 2012

Siempre que desarrollamos una aplicacion web algo que nunca debe faltar es un formulario de contacto para que los usuarios que visitan o usan nuestra aplicacion web puedan ponerse en contacto con nosotros.

Pues bien ahora veremos como hacer un formulario de contacto en asp.net y ademas le agregaremos recaptcha para evitar spam.

Aspectos a considerar
El ejemplo esta desarrollado en visual estudio 2010 con c# y vb.net
Tener una cuenta de correo gmail(que sera donde recibirás los mensajes).

Lo primero sera descargar la librería de recaptcha para asp.net (el ejemplo ya incluirá la librería).

El diseño de nuestro formulario de contacto sera el siguiente(lo pueden personalizar como quieran)

Diseño


Como pueden observar el formulario tiene 4 textbox que ademas están validados con los controles de validación para que el usuario rellene todos los datos e ingrese un correo valido, también tiene el control recaptcha, tenemos un botón y abajo del botón tenemos un label que nos servirá para mostrar un mensaje al usuario para que sepa si se envió o no el mensaje.

Ahora en nuestro web.config tendremos que agregar lo siguiente.











Lo que hacemos es agregar los datos de nuestro servidor de correo en este caso utilizamos smtp de gmail, lo que esta en mayúscula lo tienen que remplazar por sus credencias(correo y password) de gmail lo medas no lo toquen.

Ahora nos vamos al código de nuestro formulario y empezamos a programar, creemos los siguientes métodos.
private void Limpiar()
{
txttitulo.Text = "";
txtnombre.Text = "";
txtcorreo.Text = "";
txtmensaje.Text = "";
lblaviso.Text = "";
}

private void Enviar(string titulo, string nombre, string correo, string mensaje)
{

if (Page.IsValid)
{
string to = ConfigurationManager.AppSettings["To"];
MailMessage mail = new MailMessage();
mail.To.Add(new MailAddress(to));
mail.From = new MailAddress(correo, nombre);
mail.Subject = titulo + " " + correo;
mail.Body = mensaje + "\n\n" + nombre + "\n" + correo;

SmtpClient smtp = new SmtpClient();
smtp.Send(mail);

Limpiar();
lblaviso.Text = "Mensaje Enviado gracias por tomarse el tiempo de escribir...!";
}
else
{
lblaviso.Text = "No has escrito correctamente el codigo de verificacion";

}
}

    Private Sub Limpiar()
txttitulo.Text = ""
txtnombre.Text = ""
txtcorreo.Text = ""
lblaviso.Text = ""
End Sub
Private Sub Enviar(ByVal titulo As String, ByVal nombre As String, ByVal correo As String, ByVal mensaje As String)
If (Page.IsValid) Then
Dim t As String = ConfigurationManager.AppSettings("To")
Dim mail As New MailMessage()
mail.To.Add(New MailAddress(t))
mail.From = New MailAddress(correo, nombre)
mail.Subject = titulo + " " + correo
mail.Body = mensaje + vbLf & vbLf + nombre + vbLf + correo

Dim smtp As New SmtpClient()
smtp.Send(mail)

Limpiar()
lblaviso.Text = "Mensaje Enviado gracias por tomarse el tiempo de escribir...!"
Else
lblaviso.Text = "No has escrito correctamente el codigo de verificacion"
End If
End Sub

El primer método Limpiar lo único que ara es limpiar los textbox.
El método Enviar es el que nos servirá para enviar el mensaje podemos ver que recibe 4 parámetros que son los que necesitamos para que se envié el mensaje, luego comprobamos que la pagina se valide correctamente y dentro leemos los datos del web.config y armamos el correo haciendo uso de la clase MailMessage y luego enviamos el correo usando la clase SmtpClient y mostramos los mensajes que el mensaje se envió correctamente, y si la pagina no se valida correctamente mostramos mensajes que no se pudo enviar el correo mensaje.

Por ultimo dentro del evento click del botón hacemos lo siguiente.
Enviar(txttitulo.Text,txtnombre.Text,txtcorreo.Text,txtmensaje.Text);

Enviar(txttitulo.Text, txtnombre.Text, txtcorreo.Text, txtmensaje.Text)

Lo único que hacemos es llamar al método Enviar y le pasamos los datos correspondientes.

Captura

Captura


Eso seria todo por ahora espero les sirva a alguien saludos desde El Salvador.

Descargar Proyecto C#

Descargar Proyecto VB.Net