Desarrollo de Aplicaciones Windows Forms en

Desarrollo de
aplicaciones con
Windows Forms
Empezando con .NET
En este documento comparto informacin que ayude a los
estudiantes que empiezan a trabajar con Windows Forms en
.NET partiendo desde el diseo de formularios hasta la
manipulacin de una base de datos utilizando ADO. Net Entity
Framework a travs de consultas LINQ y generar reportes,
adems de agregar seguridad a las aplicaciones desarrolladas
con Windows Forms.
Alfonso Felipe Lima Corts
13/06/2012
Desarrollo de aplicaciones con Windows Forms en .NET

Contenido
Diseo y desarrollo de aplicaciones ................................................................................................................... 3
Introduccin ....................................................................................................................................................... 3
Controles ............................................................................................................................................................ 3
Uso de controles ............................................................................................................................................ 4
Algunas propiedades generales de los controles............................................................................... 4
Asignar nombres a los controles ........................................................................................................... 4
Ejercicio ..................................................................................................................................................... 5
Cuadros de dilogo............................................................................................................................................. 5
Mens................................................................................................................................................................. 6
Proyecto con mltiples formularios ................................................................................................................... 8
Manejo de excepciones...................................................................................................................................... 8
Programacin Orientada a Objetos en C#........................................................................................................ 11
Clases............................................................................................................................................................ 11
Crear objetos ................................................................................................................................................ 12
Miembros de clase ....................................................................................................................................... 12
Ejemplo: crear una clase ms completa ................................................................................................... 15
Colecciones de objetos................................................................................................................................. 16
LINQ .................................................................................................................................................................. 22
Documentar cdigo fuente .............................................................................................................................. 23
Qu debe documentarse? ...................................................................................................................... 23
Qu utilizamos en la documentacin? ................................................................................................... 24
Ejemplo: ................................................................................................................................................... 24
Controles creados por el usuario (Controles de usuario) ................................................................................ 26
Controles de usuario como biblioteca de controles .................................................................................... 28
Creacin de distribuciones (Instaladores) ........................................................................................................ 31
Publicar el proyecto: ................................................................................................................................ 32
Crear un proyecto de instalacin. ............................................................................................................ 34
Manipular una base de datos local .................................................................................................................. 38
Modos de conexin a Base de Datos ........................................................................................................... 38
Ejemplo de creacin de BD, conexin y manipulacin de datos ............................................................. 39
Crear la base de datos .................................................................................................................................. 40
www.afelipelc.mx
A. Felipe Lima Corts
Pgina 1 de 77

Crear el modelo conceptual de datos .......................................................................................................... 44
Manejo de datos. ......................................................................................................................................... 48
Creacin de reportes .................................................................................................................................... 59
Crear los informes en Visual Studio. ........................................................................................................ 61
Roles y usuarios ................................................................................................................................................ 71
Roles ......................................................................................................................................................... 71
Usuarios.................................................................................................................................................... 72
Autentificacin. ........................................................................................................................................ 72
Seguridad en aplicaciones Windows. ....................................................................................................... 72
Conclusin ........................................................................................................................................................ 77
www.afelipelc.mx
Pgina 2 de 77

Diseo y desarrollo de aplicaciones
Introduccin
Los formularios son la unidad bsica de una aplicacin, es importante realizar algunas
consideraciones sobre su funcin y su diseo. Un formulario es una hoja en blanco que el
desarrollador rellena con controles, para crear una interfaz de usuario, y con cdigo, para procesar
los datos. Para ese fin, Visual Studio proporciona un entorno de desarrollo integrado que ayuda a
escribir el cdigo. La funcionalidad de estos controles se complementa con el cdigo escrito por el
desarrollador, lo que permite desarrollar fcil y rpidamente las soluciones deseadas.
Controles
La interfaz de usuario de una aplicacin visual est diseada a partir de controles, siendo estos la
base de desarrollo rpido de aplicaciones.
El entorno de desarrollo elegido para trabajar en esta asignatura (Microsoft Visual Studio 2010)
presenta muchos controles integrados listos para ser utilizado en nuestros proyectos.
En el cuadro de herramientas se encuentran todos
los controles disponibles para el tipo de proyecto, en
el cual se encuentran agrupados por funcionalidad.
La lista completa de controles que pueden utilizarse
en aplicaciones de Windows Forms se encuentra en
la documentacin oficial del entorno de desarrollo
http://msdn.microsoft.com/eses/library/xfak08ea.aspx la documentacin tcnica
para cada control tambin se encuentra disponible
haciendo clic sobre el nombre del control.
Img. 1.- Cuadro de herramientas.
www.afelipelc.mx
Pgina 3 de 77

Uso de controles
Para utilizar cualquier control del cuadro de herramientas en
el diseo de formularios, debe seleccionarse y colocarse en
el diseador de formularios.
En la documentacin tcnica de cada control encontramos
la descripcin, propiedades, mtodos y eventos,
informacin que debe conocer el desarrollador a su vez que
esta le permita utilizar adecuadamente y sacar el mximo
provecho a cada uno de los controles.
Img. 2.- Agregando controles al
formulario.
Al agregar controles al diseador de formularios, el

desarrollador procede a configurar las propiedades para
cada uno, por lo general, el desarrollador configura las propiedades:
Algunas propiedades generales de los controles
Name: Obtiene o establece el nombre del control. El nombre del control es el nombre del
objeto al cual el desarrollador deber invocar para obtener y establecer informacin del
control al momento de codificar.
Text: Obtiene o establece el texto actual del control. El texto de un control es el texto que
es visible para el usuario, los controles ms comunes que muestran texto a los usuarios
son las etiquetas (label) y cuadros de texto (textbox).
TabIndex: Obtiene o establece el orden de tabulacin del control en su contenedor. Esta
propiedad permite definir el orden de navegacin entre los controles al presionar la tecla
Tab, ya que muchos de los usuarios finales utilizan la mayor parte del tiempo para navegar
en una aplicacin, por lo tanto, debe haber un orden para facilitarle el uso e interaccin con
la interfaz.
Anchor: Obtiene o establece los bordes del contenedor al que est enlazado un control y
determina cmo se cambia el tamao de un control con su elemento primario. Propiedad
importante en los controles que permite definir como un control debe cambiar su tamao y
ubicacin cuando la ventana que lo contiene cambia su tamao.
Consulte la lista completa de controles y acceda a toda la documentacin de cada control
http://msdn.microsoft.com/es-es/library/xfak08ea.aspx
Asignar nombres a los controles

Cada control en un formulario debe tener un nombre independiente que hace referencia al dato
que se obtendr o mostrara a travs de este, al asignar el nombre a un control debemos agregar
un sufijo o prefijo, donde el prefijo o sufijo es la abreviatura del tipo de control (clase);
Ejemplos:
NombreTxt o TxtNombre; el sufijo y prefijo Txt hace referencia al tipo de control TextBox.
www.afelipelc.mx
Pgina 4 de 77

AceptarBtn, CancelarBtn; donde Btn hace referencia a Button, esto indica que el control es un
botn.
LocalidadCmb, EstadoCmb; donde Cmb hace referencia a ComboBox, esto indica que el control
es una lista desplegable.
Ejercicio
Cree un proyecto de Windows Forms y en el diseador de formularios, arrastre los controles
correspondientes de forma que obtenga un resultado similar.
El formulario incluye los controles Label,
TextBox, y Button.
Asigne nombres a los controles y
especifique el texto a mostrar en la etiqueta.
Especifique el orden (TabIndex) de los
controles.
Img. 3.- Vista previa del ejemplo a disear.
Cuadros de dilogo
Recuperar datos de los controles y mostrarlos en mensajes:
Nota: Es muy importante inducir e introducir al alumno a familiarizarse con el cdigo escrito en C#:
palabras clave, tipos de datos, sentencias de control, sintaxis, interfaces, clases, propiedades,
mtodos, etc. y trabajar con ejemplos de cdigo.
Genere el cdigo para el botn que contiene la leyenda Aceptar presionando doble clic sobre el
botn en el formulario (para ver el cdigo fuente del formulario, presione la tecla F7 o utilizando el
men contextual sobre el formulario o desde el explorador de soluciones).
private void AceptarBtn_Click(object sender, EventArgs e)

{
//Instrucciones que deber ejecutar el botn al hacer clic sobre el
MessageBox.Show("Hola " + this.NombreTxt.Text);
}
Ejemplo1.- Cdigo escrito en C#.
Para recuperar o establecer informacin a un control (invocar propiedades, mtodos y eventos)

invocamos al nombre del control seguido de. punto ms el nombre de la propiedad, mtodo u
evento, ejemplo:
this.NombreTxt.Text o NombreTxt.Text
Se est invocando a la propiedad Text del control.
www.afelipelc.mx
Pgina 5 de 77

this.NombreTxt.Focus() NombreTxt.Focus()
Se est invocando al mtodo Focus del control.
En el cdigo mostrado en Ejemplo1, la instruccin MessageBox.Show("Hola " + this.NombreTxt.Text);

emite un mensaje al usuario a travs del mtodo Show de la clase MessageBox, en el mensaje
se incluye el texto Hola concatenndose con el texto escrito por el usuario en el cuadro de texto
llamado NombreTxt.
Al ejecutar el ejemplo, ingresar un nombre en el cuadro de texto y hacer clic en aceptar, el
resultado es:
Img. 5.- Resultado del

mensaje.
Img. 4.- Ejecutando el ejemplo.
Para ms informacin y detalles sobre la clase MessageBox, consulte la documentacin oficial de

la clase
http://msdn.microsoft.com/es-es/library/system.windows.forms.messagebox.aspx
El alumno debe practicar con ms ejercicios que le permitan manipular los controles del
formulario.
Mens
Usar una barra de mens en una aplicacin permite agrupar y ordenar los comandos de la
aplicacin facilita la accesibilidad por parte del usuario a estos.
En una aplicacin de Windows Forms para
crear una barra de mens, utilizamos el
control
MenuStrip
(http://msdn.microsoft.com/eses/library/ms171649%28v=VS.100%29.asp
x ).
Img. 6.- Formulario con el control MenuStrip y contenedor

MDI.
www.afelipelc.mx
Utilizar este control es bastante sencillo,

agregamos el control y empezamos a
agrupar los comandos que implementa o
se implementarn en la aplicacin.
Pgina 6 de 77

Realice un ejercicio, para ello agregue un nuevo formulario al proyecto y agregue el control
MenuStrip y genere la estructura que se muestra en la imagen anterior.
El control MenuStrip agregado y todos sus elementos se les debe asignar un nombre.
El formulario tiene una propiedad llamada MainMenuStrip (Especifica el MenuStrip principal para
el formulario.).
El formulario que contiene el MenuStrip puede ser utilizado como contenedor MDI para mostrar
dentro de l las ventanas y acciones que resultan por cada uno de los comandos.
Para establecer el formulario como contenedor Mdi, debe habilitarse la propiedad IsMDIContainer
y el resultado es el mostrado en la imagen anterior.
Para ms informacin acerca de los formularios MDI
http://msdn.microsoft.com/eses/library/7aw8zc76%28v=VS.100%29.aspx
Genere el cdigo para el primer elemento (Primer ejemplo) del men Ver.
private void primerEjemploTsmi_Click(object sender, EventArgs e)
{
//Crear instancia del formulario a mostrar
PrincipalFrm principal = new PrincipalFrm();
//asignar el contenedor principal para la nueva ventana a mostrar (la ventana
que contiene el )
principal.MdiParent = this;
//mostrar la ventana
principal.Show();
}
Ejemplo2.- Cdigo del evento clic del elemento Ver / Primer Ejemplo.
En el cdigo del elemento, agregamos las instrucciones necesarias que permitan cargar la
ventana correspondiente dentro del contenedor.
Debe cambiarse el formulario principal del proyecto (primer formulario que debe mostrarse al
ejecutar el ejemplo.)
En el explorador de soluciones, abra el archivo Program.cs, en el mtodo Main, cambie el
formulario de inicio.
static void Main()

{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MenuFrm()); //formulario de inicio
}
Ejecute el ejemplo, haga clic sobre Ver / Primer ejemplo.
www.afelipelc.mx
Pgina 7 de 77
Img. 7.- Formulario con el control MenuStrip y

contenedor MDI mostrando una nueva ventana.
Proyecto con mltiples formularios

Una aplicacin de visual puede estar compuesta por una o ms ventanas, emitir mensajes
visuales para el usuario y permitir la interaccin con la interfaz grfica navegando entre las
distintas ventanas.
Para
agregar
nuevas
ventanas
(formularios) al proyecto, en el explorador de
soluciones presione clic derecho sobre el
nombre del proyecto / Agregar / Nuevo elemento
(o directamente Windows Forms).
Especifique el nombre del formulario y

seleccione Agregar.
Nota: se recomienda agregar el sufijo o prefijo
Frm al nombre del formulario, refirindose a
que es un elemento de la clase Form.
Img. 3.5.1.- Agregar nuevo formulario.
Creados los formularios, procedemos a la
personalizacin o configuracin de estos donde, y trabajamos en su diseo.
Manejo de excepciones
El cdigo de una aplicacin escrito por el desarrollador aun bien diseado puede afrontarse a
situaciones inesperadas durante la ejecucin de la aplicacin, dado que si el desarrollador no
considera las posibilidades de que ocurra un suceso que pueda afectar al correcto funcionamiento
de la aplicacin, esta podra terminar de funcionar provocando un mal proceso de la informacin y
afectando la usabilidad por parte del usuario.
A este tipo de sucesos que ocurren en tiempo de ejecucin se les llama excepciones.
www.afelipelc.mx
Pgina 8 de 77
Img. 8.- Excepcin generada en tiempo de ejecucin, No se puede

dividir entre 0.
Los programadores utilizan bloques try para aislar el cdigo que puede ser afectado por una
excepcin, y bloques catch para aislar el cdigo que debe ejecutarse cuando resulte una
excepcin, al bloque catch se le denomina bloque para controlar excepciones.
Los bloques catch pueden especificar el tipo de excepcin que debe controlarse, o controlar
excepciones de forma general.
Controlar excepciones de forma general.

private void EjemploControlExcepciones()
{
try
{
int a = 5;
int b = 0;
int c;
c = a / b;
MessageBox.Show("El resultado es: " + c.ToString());
}
catch
{
MessageBox.Show("Ha ocurrido un error.");
}
}
El bloque de cdigo anterior controla la excepcin y muestra un mensaje al usuario informando

que ha ocurrido un error, aun generndose la excepcin, el programa contina ejecutndose
correctamente.
www.afelipelc.mx
Pgina 9 de 77
Img. 9.- Mensaje mostrado al

generarse la excepcin.
Controlar por tipo de excepcin.

private void EjemploControlExcepciones()
{
try
{
int a = 5;
int b = 0;
int c;
c = a / b;
MessageBox.Show("El resultado es: " + c.ToString());
}
//controlar excepcin de divisin entre cero.
catch(DivideByZeroException)
{
MessageBox.Show("No se puede dividir entre cero.");
}
}
El bloque de cdigo anterior controla la excepcin de tipo DivideByZeroException en el mtodo

EjemploControlExcepciones() y muestra un mensaje al usuario informando que no se puede
dividir entre cero, y el programa contina ejecutndose correctamente.
Img. 10.- Mensaje mostrado al generarse la

DivideByZeroException.
Pero si se produjera otra excepcin, esta nueva no sera controlada, ya que no se controlan
excepciones de forma general.
Para controlar otros tipos de excepcin, agregue ms bloques catch que controlen el tipo que
pudiera producirse en su cdigo.
Para ver ms detalles sobre excepciones y control de excepciones, visite la documentacin oficial
http://msdn.microsoft.com/es-es/library/ms173160%28v=VS.100%29.aspx
www.afelipelc.mx
Pgina 10 de 77

Para ver la jerarqua de excepciones y toda su documentacin tcnica, visite la documentacin
oficial
http://msdn.microsoft.com/es-es/library/z4c5tckx%28v=VS.100%29.aspx
Programacin Orientada a Objetos en C#
Clases
Una clase es una plantilla que define una estructura, agrupa comportamientos (mtodos) y
estados (atributos) de los futuros objetos que deriven de esta.
Los objetos que derivan de una clase se les llaman instancia de clase, las clases tambin admiten
herencia como ya lo sabemos en la poo.
Las clases se definen con la palabra reservada class
La sintaxis para definir una clase es:
<modificador de acceso> class <nombre de la clase>
{
<miembros de la clase como campos, propiedades, mtodos y eventos>
}
<modificador de acceso>: determina el nivel de acceso a la clase o miembro de clase como:
private, public, protected.
Ejemplo:
public class Persona
{
}
Herencia de clase
La herencia se realiza a travs de la derivacin, lo que significa que una clase se declara
utilizando una clase base de la cual hereda los datos y el comportamiento.
En c# la herencia se especifica con : dos puntos seguidos del nombre de la clase base (clase
heredada).
Ejemplo:
public class Empleado : Persona
{
}
www.afelipelc.mx
Pgina 11 de 77

Donde Empleado hereda todos los datos de la clase Persona.
Crear objetos
Un objeto es una entidad basada en una clase tambin denominada instancia de clase.
La sintaxis para crear un objeto es:
<nombre de la clase> <nombre del objeto> = new <nombre de la clase>();
Ejemplo:
Persona nuevapersona = new Persona();
Para
ms
informacin
y
ejemplos,
consulte
la
http://msdn.microsoft.com/es-es/library/x9afc042(v=VS.100).aspx
documentacin
oficial
Miembros de clase
Las clases tienen miembros que representan sus datos y comportamiento, los tipos de miembros
son:
o Campos: Los campos son variables declaradas en el mbito de clase. Un campo puede
ser un tipo numrico integrado o una instancia de otra clase.
o Constantes: Las constantes son campos o propiedades cuyo valor se establece en tiempo
de compilacin y no se puede cambiar.
o Propiedades: Las propiedades son mtodos de una clase a los que se obtiene acceso
como si fueran campos de esa clase. Una propiedad puede proporcionar proteccin a un
campo de clase con el fin de evitar que se cambie sin el conocimiento del objeto.
o Mtodos: Los mtodos definen las acciones que una clase puede realizar. Los mtodos
pueden aceptar parmetros que proporcionan datos de entrada y devolver datos de salida
a travs de parmetros. Los mtodos tambin pueden devolver un valor directamente, sin
utilizar ningn parmetro.
o Constructores: Los constructores son mtodos a los que se llama cuando el objeto se
crea por primera vez. Se utilizan a menudo para inicializar los datos de un objeto.
Para ver la lista completa de los miembros de clase y estructuras, consulte el sitio
http://msdn.microsoft.com/es-es/library/ms173113.aspx
Campos
Un campo es una variable de cualquier tipo que se declara directamente en una clase.
Ejemplo:
{
www.afelipelc.mx
Pgina 12 de 77

//campos que almacenan los datos de la persona
private string nombre;
private string apellidos;
private DateTime fechanacimiento;
private int edad;
private string edo_civil;
private string sexo;
private string calle;
private string numero;
private string estado;
private string municipio;
Propiedades
Una propiedad es un miembro que proporciona un mecanismo flexible a la lectura, escritura o
clculo el valor de un campo privado. Las propiedades pueden utilizarse como si fuesen miembros
de datos pblicos, aunque en realidad son mtodos especiales denominados descriptores de
acceso. De este modo, se puede obtener acceso a los datos con facilidad, a la vez que se
promueve la seguridad y flexibilidad de los mtodos.
La sintaxis para definir una propiedad es:
<modificador de acceso> <tipo de dato> <nombre de la propiedad>
{
get { return <valor o campo a devolver>;}
set { <campo donde se almacenara el valor> = value;}
}
Dnde:
get: se utiliza para devolver el valor de la propiedad que puede ser un campo.
set: se utiliza para asignar un nuevo valor a la propiedad, este nuevo valor es almacenado en un
campo.
return: palabra clave que representa el retorno.
value: palabra clave que se utiliza para representar el valor asignado al descriptor de acceso set.
Ejemplo:
public string Nombre
{
get { return nombre; }
set { this.nombre = value; }
}
public int Edad
{
get { return edad; }
set { this.edad = value; }
}
www.afelipelc.mx
Pgina 13 de 77

Cuando se est trabajando con objetos, se invocan a sus propiedades para leer su valor o asignar
un nuevo valor o a cualquier otro de sus miembros, solo miembros pblicos.
Img. 11.- Trabajando con objetos.
La imagen anterior muestra que al tratar un objeto puede accederse a todos sus miembros
pblicos, las propiedades se presentan con un icono que muestra una tarjeta sostenida por una
mano, los mtodos son representados por un rombo color rosa y cualquier otro objeto miembro de
la clase es representado con un rombo azul.
Constructores
Cada vez que se crea una nueva instancia de una clase se invoca a un constructor, una clase
puede tener uno o varios constructores que tomen argumentos diferentes.
Si al crear una nueva clase en c# no se define un constructor, c# crear uno de forma
predeterminada que permitir crear objetos de esta clase.
Sintaxis:
public <nombre de la clase>(parametro1 ,parametro2, , parmetron)
{
<operaciones con los parmetros>
}
Ejemplo:
public Persona()
{
}
public Persona(string Nombre, string Apellidos)
{
this.nombre = Nombre;
this.apellidos = Apellidos;
}
Para invocar a un constructor al crear un objeto seria:

www.afelipelc.mx
Pgina 14 de 77

Se invoca al constructor que toma 0 argumentos.
public Persona() {}
Al invocar a un constructor que toma argumentos, deben especificarse los valores al momento de
inicializar el objeto, visual studio nos muestra automticamente la sugerencia de los elementos de
la clase que pueden estar tratndose de invocar, donde nos muestra la estructura de los
elementos.
Donde el objeto inicializado por un constructor que toma argumentos quedara:

Persona otrapersona = new Persona("Juan", "Prez Torres");
Ejemplo: crear una clase ms completa.

Una clase completa quedara como nuestro ejemplo:
{
private int edad;
//constructores
public Persona()
{
}
{
}
//propiedades
{
}
public string Apellidos
{
get { return this.apellidos; }
www.afelipelc.mx
Pgina 15 de 77

set { this.apellidos = value; }
}
public int Edad
{
}
public string EstadoCivil
{
get { return edo_civil; }
set { this.edo_civil = value; }
}
public string Sexo

{
get { return sexo; }
set { this.sexo = value; }
}
public string Calle
{
get { return this.calle; }
set { this.calle = value; }
}
public DateTime FechaNacimiento
{
get { return this.fechanacimiento; }
set { this.fechanacimiento = value; }
}
public string Estado
{
get { return this.estado; }
set { this.estado = value; }
}
public string Municipio
{
get { return this.municipio; }
set { this.municipio = value; }
}
Colecciones de objetos
Trabajar con colecciones es trabajar con listas o arreglos de objetos, similar a los registros
almacenados en una tabla de una base de datos, adems, pueden utilizarse como fuente de
datos para mostrarlos al usuario en forma de tabla o imprimirlos en un reporte.
En general, es recomendable utilizar colecciones genricas porque se obtiene la ventaja inmediata
de la seguridad de tipos sin necesidad de derivar de un tipo de coleccin base e implementar
www.afelipelc.mx
Pgina 16 de 77

miembros especficos de los tipos. Adems, por lo general los tipos de coleccin genricos tienen
un mejor rendimiento que los tipos de coleccin no genricos correspondientes (y mejor que el de
los tipos derivados de tipos de coleccin base no genricos) cuando los elementos de la coleccin
son tipos de valor, porque con los genricos no hay necesidad de realizar conversiones boxing de
los elementos.
En este caso, utilizaremos la clase List<>: Representa una lista fuertemente tipada de objetos a
los que se puede obtener acceso por el ndice. Proporciona mtodos para buscar, ordenar y
manipular listas.
http://msdn.microsoft.com/es-es/library/6sh2ey19.aspx
La sintaxis para crear una nueva coleccin genrica es:
List<[Tipo de dato]> [nombre de la coleccin] = new List<[Tipo de dato]>();
Ejemplo:
Crear una lista de objetos de la clase Persona, podra decirse que representa una lista de
personas.
List<Persona> listadepersonas = new List<Persona>();
Agregar elementos a la coleccin.

Para agregar nuevos elementos a la coleccin presentamos 2 formas.
1.- Crear un nuevo objeto de la clase Persona y agregarlo a la coleccin:
nuevapersona.Nombre = "Juan";
nuevapersona.Apellidos = "Prez Torres";
nuevapersona.FechaNacimiento = DateTime.Parse("01/01/1990");
nuevapersona.Edad = 21;
nuevapersona.EstadoCivil = "Soltero";
nuevapersona.Calle = "Independencia";
nuevapersona.Numero = "350";
nuevapersona.Municipio = "Izcar de Matamoros";
nuevapersona.Estado = "Puebla";
listadepersonas.Add(nuevapersona);
En este ejemplo se crea un nuevo objeto de la clase persona, al cual se le asignan valores
a sus propiedades.
La instruccin listadepersonas.Add(nuevapersona); agrega el nuevo objeto creado a la
coleccin de objetos de la clase Persona.
2.- Agregar un nuevo objeto directamente a la coleccin.
listadepersonas.Add(
new Persona {
Nombre = "Juan",
Apellidos = "Prez Torres",
FechaNacimiento = DateTime.Parse("01/01/1990"),
Sexo = "Hombre",
Edad = 21,
EstadoCivil = "Soltero",
Calle = "Independencia",
www.afelipelc.mx
Pgina 17 de 77

Numero = "350",
Municipio = "Izcar de Matamoros",
Estado = "Puebla"
}
);
En este ejemplo no se crea el objeto por separado, sino que se crea directamente dentro del
mtodo Add(), consulte la documentacin de la clase List<> donde encontrar como manipular
colecciones.
Crear un ejemplo donde se cargue una coleccin de objetos en una ventana y se agreguen
y editen elementos.
Para empezar con el ejemplo, puede crear un nuevo proyecto de Windows forms o utilice
uno existente, en el cual, implemente la clase Persona tratada anteriormente.
Agregue un nuevo formulario [ListaPersonas] cuyo diseo sea similar al de la imagen:
Img. 12.- Formulario donde se mostrar la lista de objetos.
Asigne nombres a los controles.

Agregue otro nuevo formulario [PersonaFrm] cuyo diseo sea similar al de la imagen.
Img. 13.- Formulario que deber

llenarse para crear o editar objetos.
www.afelipelc.mx
Pgina 18 de 77
Vaya al cdigo del formulario ListaPersonas donde:

o Cree una coleccin de objetos de la clase Persona.
List<Persona> listadepersonas = new List<Persona>();
Genere el evento Click() del botn Nuevo que abrir la ventana donde el usuario deber
ingresar los datos de la nueva persona, el cdigo quedar as:
private void NuevoBtn_Click(object sender, EventArgs e)

{
//crear instancia de la clase (formulario) PersonaFrm
PersonaFrm ventanadatospersonales = new PersonaFrm();
ventanadatospersonales.ShowDialog();
//Recuperar los datos del formulario
//Almacenar el objeto en la lista de objetos Persona
//antes debemos comprobar que el usuario ingreso datos
if(ventanadatospersonales.IngresoDatos())
listadepersonas.Add(ventanadatospersonales.DatosPersonales);
//Antes de volver a cargar la lista, debemos
//limpiar el DataSource del DataGridView
this.ListaDtg.DataSource = null;
//cargar nuevamente la lista en el datagridview
this.ListaDtg.DataSource = listadepersonas;
}
En este mtodo cargamos la lista de objetos al control DataGridView a travs de su

propiedad DataSource (Recurso de datos), para ms informacin acerca de este
control, visite
http://msdn.microsoft.com/eses/library/system.windows.forms.datagridview%28v=VS.100%29.aspx
En este mtodo tambin se invoca al mtodo IngresoDatos() que debe
implementarse en la ventana PersonaFrm, incluida tambin la propiedad
DatosPersonales.
o
Genere el evento clic para el botn Editar el cual al ser presionado, deber cargar
los datos del elemento seleccionado en la lista a la ventana de datos donde el
usuario podr modificar y aceptar nos nuevos cambios que se vern reflejados en
la lista.
private void EditarBtn_Click(object sender, EventArgs e)
{
//crear la instancia de la ventana a mostrar
PersonaFrm ventanadatospersonales = new PersonaFrm();
//antes de mandar a mostrarla, debemos recuperar el objeto
//seleccionado en el datagridview
//despus pasarlo a la ventana para mostrar sus datos
//creamos un nuevo objeto temporal de la clase Persona

Persona objetorecuperado =
(Persona)this.ListaDtg.SelectedRows[0].DataBoundItem;
//pasar el objeto a la ventana de datos a travs de la propiedad
ventanadatospersonales.DatosPersonales = objetorecuperado;
ventanadatospersonales.ShowDialog();
//al cerrar la ventana de datos, actualizar el datagridview
www.afelipelc.mx
Pgina 19 de 77

ListaDtg.Refresh();
}
Generar el evento Click() del botn Eliminar que al ser presionado, deber
eliminar de la lista el objeto seleccionado en el datagridview.
private void EliminarBtn_Click(object sender, EventArgs e)

{
listadepersonas.Remove((Persona)this.ListaDtg.SelectedRows[0].DataBoundItem);
this.ListaDtg.DataSource = listadepersonas;
}
Vaya al cdigo de la ventana PersonaFrm donde:

o Cree un campo donde se almacene un objeto de la clase Persona.
private Persona persona;
Implemente la propiedad para el campo persona.

//propiedad que acepta y devuelva un objeto de la clase Persona
public Persona DatosPersonales
{
get { return persona; }
set {
this.persona = value;
//cargar los datos a los controles cuando
//se reciba un objeto
CargarDatos();
}
}
Implementar un mtodo privado que llene el objeto persona con los datos
ingresados por el usuario (ser invocado cuando el usuario haga clic en Aceptar ).
private void LlenarDatos()
{
//inicializar el objeto de la clase Persona
//si no se est editando.
if(persona==null)
persona = new Persona();
//asignar los valores de los controles a las
//propiedades del objeto
persona.Nombre = this.NombreTxt.Text;
persona.Apellidos = this.ApellidosTxt.Text;
persona.FechaNacimiento = this.FechaNacimientoDtp.Value;
persona.Calle = this.CalleTxt.Text;
persona.Estado = this.EstadoCmb.Text;
persona.Municipio = this.MunicipioCmb.Text;
if (this.SexoHombreRbtn.Checked)
persona.Sexo = "H";
if (this.SexoMujerRbtn.Checked)
persona.Sexo = "M";
}
Implementar el mtodo privado que cargue llene los controles con los datos del
objeto (ser invocado cuando el usuario edite un objeto).
private void CargarDatos()
{
this.NombreTxt.Text = this.persona.Nombre; //cargar el nombre
this.ApellidosTxt.Text = this.persona.Apellidos;
www.afelipelc.mx
Pgina 20 de 77

this.FechaNacimientoDtp.Value = this.persona.FechaNacimiento;
this.CalleTxt.Text = this.persona.Calle;
this.NumeroTxt.Text = this.persona.Numero;
this.EstadoCmb.Text = this.persona.Estado;
this.MunicipioCmb.Text = this.persona.Municipio;
if (this.persona.Sexo == "H")
this.SexoHombreRbtn.Checked = true;
if (this.persona.Sexo == "M")
this.SexoMujerRbtn.Checked = true;
}
Crear un mtodo pblico que devuelva un valor que indique si el usuario presion el
botn Aceptar (true) o el botn Cancelar (false).
//campo que almacene el valor que indique si el usuario ingreso datos
private bool ingresodatos;
//Mtodo que devuelva el valor del campo ingresodatos
public bool IngresoDatos()
{
return ingresodatos;
}
Finalmente en esta misma ventana, genere el evento clic para el botn Aceptar
donde debe invocarse el mtodo que llena el objeto y cierre la ventana.
{
LlenarDatos(); //invocar al metodo que llena el objeto
this.ingresodatos = true;
this.Close();
}
o
Ejecutamos nuestro ejemplo:
o Hacemos
clic
en
Nuevo,
ingresamos los datos de la nueva
persona, hacemos clic en aceptar y
vemos que nuestro registro ya se
encuentra en la lista, volvemos a
agregar nuevos registros.
o Seleccionamos un elemento de la
lista, hacemos clic en Editar y
vemos la ventana de datos donde
se muestran los datos a editar,
realizamos
y
aceptamos
los
cambios.
o Seleccionamos un elemento de la
lista y hacemos clic en Eliminar, el
objeto seleccionado se eliminar
automticamente sin poder volverse a
recuperar.
www.afelipelc.mx
Img. 14.- Comprobando funcionalidad del

ejemplo.
Pgina 21 de 77

LINQ
Language-Integrated Query (LINQ) es un conjunto de caractersticas que agrega capacidades de
consulta eficaces a la sintaxis de los lenguajes C# y Visual Basic. LINQ incluye patrones estndar
y de fcil aprendizaje para consultar y actualizar datos, y su tecnologa se puede extender para
utilizar potencialmente cualquier tipo de almacn de datos. Visual Studio incluye ensamblados de
proveedores para LINQ que habilitan el uso de LINQ con colecciones de .NET Framework, bases
de datos SQL Server, conjuntos de datos de ADO.NET y documentos XML.
Toda la informacin acerca del LINQ se encuentra en http://msdn.microsoft.com/eses/library/bb397926.aspx la cual debe consultarse para familiarizarse con el tema.
Para ver algunos ejemplos acerca de cmo escribir consultas LINQ para colecciones, visite la url
http://msdn.microsoft.com/en-us/vcsharp/aa336746 donde se muestran ejemplos para la mayora
de los operadores de consulta en los cuales tambin se incluyen expresiones lambda
http://msdn.microsoft.com/es-es/library/bb397687.aspx
Consultas LINQ en colecciones de objetos.
Img. 15.- Tablas de ejemplo relacionadas que se tratarn colecciones.
Para crear nuestra coleccin de la clase cliente:

List<Cliente> Clientes = new List<Cliente>();
Realizar consultas sobre la coleccin Clientes utilizando consultas LINQ y expresiones Lambda.
1. Filtrar todos los clientes del Grupo A:
SQL: Select * from Clientes Where Grupo = A;
LINQ: var ClientesGrupoA = from c in Clientes where c.Grupo == "A" select c;
Lambda: var ClientesGrupoA = Clientes.Where(c => c.Grupo == "A");
2. Filtrar todos los clientes que sean activos:
LINQ: var ClientesActivos = from c in Clientes where c.Activo == "Si" select c;
Lambda: var ClientesActivos = Clientes.Where(c => c.Activo == "Si");
3. Todos los clientes del grupo B y que sean activos:
www.afelipelc.mx
Pgina 22 de 77

LINQ: var ClientesActivosB = from c in Clientes where c.Grupo == "A" && c.Activo ==
"Si" select c;
Lambda: var ClientesActivosB = Clientes.Where(c => c.Grupo == "A" && c.Activo ==
"Si");
4. Sumar Todos los ahorros de los clientes:
Lambda: var AhorroTotal = Clientes.Sum(c => c.Ahorro);
5. Solo devolver el nombre completo de los clientes (usar tipos annimos):
Lambda: var nombrescompletos = Clientes.Select(c => new { NombreCompleto = c.Nombre +
" " + c.Apellidos });
6. Devolver todos los clientes tipo VIP (Utilizar colecciones combinadas [tablas
relacionadas]);
Lambda: var clientesVIP = Clientes.Where(c => c.Tipo == TiposCliente.Where(t =>
t.Nombre == "VIP");
Para ver un ejemplo funcional donde se aplican estos conceptos, visite el tutorial en lnea
http://afelipelc.wordpress.com/2011/06/21/filtrar-elementos-de-una-coleccion-list-por-un-campoespecificado/
Documentar cdigo fuente

Documentar el cdigo fuente escrito por el programador no significa que tenga que agregar
comentarios abundantes en el cdigo.
Documentar el cdigo fuente de un programa escrito es aadir suficiente informacin que explique
de forma clara lo que este hace cada una de sus funcionalidades, de esta manera, no solamente
el procesador sabr lo que el programa hace, sino que tambin el usuario pueda saberlo y por qu
lo hace.
Documentar un programa significa que el programador terminar una obra bien hecha, siendo
tambin esta una necesidad que se aprecia cuando en el futuro se encuentren errores que
corregir (mantenimiento) o tengan que ampliarse algunas funcionalidades.
Un programa documentado debe permitir la lectura y compresin al ser revisado y modificado por
el programador original u otro programador.
En la documentacin se incluyen explicaciones a todo lo que es evidente.
Qu debe documentarse?
Clases
De qu se encarga la clase?
Mtodos Propiedades
Qu hace un mtodo?, Cul es el uso esperado del mtodo?
Para qu se usa una variable o campo?
Qu podra mejorarse?
www.afelipelc.mx
Pgina 23 de 77

Qu utilizamos en la documentacin?
Los comentarios son una forma de documentar el cdigo fuente, los comentarios debe agregarse:
Al principio de la clase.
Al principio de un mtodo.
Antes de cada variable o campo de la clase.
Agregar notas cuando el programa se modifique.
Pueden usarse comentarios por conveniencia o por si acaso algo no pudiera entenderse en el
cdigo.
Algunos entornos de desarrollo ofrecen herramientas que permiten al programador documentar un
programa, por ejemplo, javadoc en java donde se utilizan etiquetas en la documentacin.
Visual Studio ofrece una herramienta para documentar cdigo en C# mediante comentarios XML
llamados
comentarios
de
documentacin
XML
http://msdn.microsoft.com/eses/library/b2s063f7%28v=VS.100%29.aspx
Las etiquetas para documentar cdigo en c# las encontramos en la direccin
http://msdn.microsoft.com/es-es/library/5ast78ax.aspx
Para documentar un miembro de una clase, interfaz, etc. en C#, se ubica el cursor antes de la
declaracin del mtodo a documentar, se presiona /// (tres veces diagonal), automticamente se
agregar la etiqueta <sumary> </sumary> donde escribiremos la descripcin corta acerca del
miembro.
Al documentar un constructor o mtodo, automticamente agregara las partes para especificar
cada uno de los parmetros.
Ejemplo:
/// <summary>
/// Representa los datos generales de una persona.
/// </summary>
/// <remarks>
/// La clase Persona implementa las propiedades ms generales de una persona
/// como: nombre, apellidos, fecha de nacimiento, edad, estado civil, sexo,
/// domicilio, nmero, estado y municipio.
/// </remarks>
{
private int edad;
public Persona()
{
www.afelipelc.mx
Pgina 24 de 77

}
/// <summary>
/// Constructor que inicializa un objeto de la clase Persona con
/// solo 2 parmetros
/// </summary>
/// <param name="Nombre">Nombre de la persona.</param>
/// <param name="Apellidos">Apellidos de la persona.</param>
{
}
/// <summary>
/// Nombre de la persona.
/// </summary>
{
}
/// <summary>
/// Apellidos de la persona.
/// </summary>
public string Apellidos
{
get { return this.apellidos; }
set { this.apellidos = value; }
}
/// <summary>
/// Edad de la persona.
/// </summary>
public int Edad
{
}
/// <summary>
/// Estado civil de la persona.
/// </summary>
public string EstadoCivil
{
get { return edo_civil; }
set { this.edo_civil = value; }
}
/// <summary>
/// Sexo de la persona.
/// </summary>
public string Sexo
{
get { return sexo; }
set { this.sexo = value; }
www.afelipelc.mx
Pgina 25 de 77

}
/// <summary>
/// Domicilio donde vive la persona.
/// </summary>
public string Calle
{
get { return this.calle; }
set { this.calle = value; }
}
/// <summary>
/// Fecha de nacimiento de la persona.
/// </summary>
public DateTime FechaNacimiento
{
get { return this.fechanacimiento; }
set { this.fechanacimiento = value; }
}
/// <summary>
/// Estado de la repblica donde vive la persona.
/// </summary>
public string Estado
{
get { return this.estado; }
set { this.estado = value; }
}
/// <summary>
/// Municipio donde vive la persona.
/// </summary>
public string Municipio
{
get { return this.municipio; }
set { this.municipio = value; }
}
}
Controles creados por el usuario (Controles de usuario)

Los controles de usuario proporcionan un medio para crear y reutilizar interfaces grficas de
usuario. Un control de usuario es esencialmente un componente con una representacin visual.
Como tal, puede constar de uno o ms controles de formularios Windows Forms, componentes o
bloques de cdigo, que pueden extender su funcionalidad. Los controles de usuario pueden
incluirse en formularios Windows Forms de la misma manera que los dems controles.
Para crear un control de usuario en el proyecto actual, agregue un control de usuario como nuevo
elemento del proyecto (clic derecho sobre el nombre del proyecto / Agregar / Control de usuario).
www.afelipelc.mx
Pgina 26 de 77

Agregue los controles que se ven en la siguiente imagen: Label, TextBox (NombreTxt), Button
(AceptarBtn).
Img. 16.- Diseo de control de usuario.
Genere el cdigo del evento clic para el botn AceptarBtn:

{
MessageBox.Show("Hola " + NombreTxt.Text);
}
Para utilizar el control de usuario, agregamos un nuevo formulario.

Al generar el proyecto, en el cuadro de herramientas se crea una nueva ficha llamada
Componentes [Nombre del proyecto] donde se muestran los controles que existen en el proyecto
actual.
Seleccione el nuevo control y agrguelo al formulario.
Img. 17.- utilizando el control de usuario.
Observamos que el control de usuario agregado al formulario es tratado como cualquier otro
control, pero conserva el diseo y tamao como fue creado.
Establecer el nuevo formulario como formulario de inicio, ejecutar el programa y probar la
funcionalidad.
Img. 18.- Probando la funcionalidad del control

de usuario.
www.afelipelc.mx
Pgina 27 de 77
Controles de usuario como biblioteca de controles

Crear una biblioteca de controles es crear un proyecto por separado donde se incluyan distintos
controles de usuario, pueden incluirse controles personalizados que amplen la funcionalidad de
controles existentes en el entorno de desarrollo.
Cree un nuevo proyecto de Biblioteca de Controles de Windows Forms (c#)
Img. 19.- Crear proyecto de biblioteca de controles.
Al crear el proyecto, por default crea un control de usuario, cambien el nombre a primercontrol y
agregue los elementos que se muestran en la siguiente imagen.
Img. 20.- Disee el control de usuario.
Agregue funcionalidades al control de usuario como el control creado anteriormente, solo para
utilizarlo como prueba.
{
MessageBox.Show("Hola " + NombreTxt.Text);
}
www.afelipelc.mx
Pgina 28 de 77
Al generar la solucin, el ensamblado generado es un archivo .dll el cual podr utilizar para
agregar como referencia en otros proyectos y utilizar los controles incluidos en la biblioteca.
Agregue otro proyecto de Windows Forms en la misma solucin.
Automticamente encontrar el control en el cuadro de herramientas, utilice el control en el
proyecto de prueba.
Img. 21.- Agregue el control de usuario al formulario.
Establezca el nuevo proyecto como proyecto de inicio para la solucin.
Img. 22.- Establezca el nuevo proyecto de inicio.
www.afelipelc.mx
Pgina 29 de 77

Ejecute el programa y compruebe la
funcionalidad.
Img. 23.- Comprobando funcionalidad.
Agregar el nuevo control al cuadro de herramientas.

En el cuadro de herramientas cree una nueva ficha como prueba.
Img. 24.- Agregar nueva ficha.
Presione botn derecho sobre el contenido de la ficha y selecciona Elegir elementos.

Localice el ensamblado generado por la biblioteca de controles creada, seleccinelo.
Img. 25.- Localizar biblioteca de control (DLL).
Se mostrar la lista de controles que contiene, seleccione los elementos a agregar y seleccione
Aceptar.
www.afelipelc.mx
Pgina 30 de 77
Img. 26.- Controles incluidos en la biblioteca (seleccionados).
Los controles seleccionando aparecern en el cuadro de herramientas y estarn siempre

disponibles para todos los proyectos de Windows Forms.
Img. 27.- Control agregado al cuadro de herramientas.
Pueden complementarse los controles de usuario agregando ms informacin como descripcin

del control, icono, y documentar las funcionalidades implementadas.
Para informacin sobre crear controles personalizados de formularios de Windows, consulte la
direccin
http://msdn.microsoft.com/es-es/library/6hws6h2t%28v=VS.100%29.aspx
Para ver un ejemplo de desarrollo de un control personalizado, consulte la direccin
http://afelipelc.wordpress.com/2011/05/29/crear-controles-personalizados-windows-forms/
Y http://afelipelc.wordpress.com/2011/05/29/crear-controles-personalizados-windows-forms-2/
Creacin de distribuciones (Instaladores)

Despus de haber implementado la aplicacin de Windows y lista para su entrega final, debe
empaquetarse, durante el proceso de empaquetado se obtiene un instalador, el cual contiene
todos los archivos y bibliotecas necesarios para que la aplicacin funcione correctamente, a esto
tambin se le conoce como crear una distribucin.
www.afelipelc.mx
Pgina 31 de 77

En Visual Studio se tienen 2 formas de crear la distribucin, 1).- Mediante la publicacin y 2
).- Creando un proyecto de instalacin.
Publicar el proyecto:
El primer paso es Generar el proyecto o solucin (Men Generar / Generar Solucin F6 o
Generar / Generar [Nombre del proyecto] Shift + F6), si durante este proceso no se
encontr ningn error, pasamos al siguiente paso, caso contrario debemos solucionar los
errores de codificacin.
Ir a Generar / Publicar [Nombre del proyecto], se abrir el asistente de publicacin donde:
o Seleccione la ruta donde se publicar el proyecto que puede ser una carpeta local,
IIS local, Sitio FTP o sitio web remoto.
Img. 28.- Asistente de publicacin especificar ubicacin.
Seleccionar desde donde se instalar la aplicacin.
Img. 29.- Asistente de publicacin.
www.afelipelc.mx
Pgina 32 de 77

o
Configurar actualizaciones.
Img. 30.- Configurar actualizaciones.
Finalizar el asistente.
Img. 31.- Finalizar el asistente.
Generada la distribucin, mostrar automticamente la carpeta donde se almaceno el instalador,

el cual podemos ejecutar para su instalacin, instalada la aplicacin puede ya empezar a
utilizarse.
www.afelipelc.mx
Pgina 33 de 77
Img. 32.- Ejecutando el instalador.
Crear un proyecto de instalacin.

Cree un nuevo proyecto de instalacin de Windows, en la ventana para crear proyecto,
seleccione Otros tipos de proyectos / Instalacin e implementacin / Instalador de Visual
Studio.
Img. 33.- Crear proyecto de instalacin.
Al crear el proyecto, el entorno de desarrollo mostrar el sistema o estructura de archivos

para el programa de instalacin.
Img. 34.- Estructura del programa de instalacin.
www.afelipelc.mx
Pgina 34 de 77

Donde los elementos representan:
Carpeta de instalacin: representa la carpeta donde se instalar la aplicacin, en este
elemento deben agregarse todos los archivos necesarios para el funcionamiento de la
aplicacin.
Escritorio del usuario: En este elemento deben agregarse los accesos directos o archivos
que sern colocados en el escritorio del usuario.
Men Programas del usuario: En este elemento deben agregarse los accesos directos,
carpetas o archivos que sern agregados en el men inicio del usuario.
Agregar archivos y otros elementos a la estructura:
Img. 35.- Agregar archivos a la carpeta de instalacin.
Para agregar archivos a la carpeta de instalacin, sitese en Carpeta de aplicacin, en el

rea de contenido agregue todos los archivos necesarios para que la aplicacin funcione
(ensamblados, manual de ayuda, archivos de base de datos, etc.)
Para crear accesos directos al escritorio, sitese en escritorio del usuario, en el rea de
contenido, haga clic derecho y seleccione crear nuevo acceso directo.
Seleccione el archivo hacia el cual estar vinculado el acceso directo.
Img. 36.- Seleccionar el destino del acceso directo.
Modifique o especifique el nombre del acceso directo.
Img. 37.- Acceso directo creado.
De igual forma, cree la estructura para el men inicio (programas) del usuario.
www.afelipelc.mx
Pgina 35 de 77

El explorador de soluciones muestra la estructura del
proyecto, pero muestra tambin las dependencias
detectadas
para
que
la
aplicacin
funcione
correctamente, uno de ellos es el Microsoft .NET
Framework que corresponde a la versin para la cual se
cre el proyecto. Esto har que cuando se ejecute el
instalador, este comprobar que el usuario tenga
instalado este componente, de lo contrario se lo
notificar dndole la opcin de descargarlo e instalarlo.
Img. 38.- Explorador de soluciones.
Configurar los datos o propiedades del instalador.

En el explorador de soluciones seleccione el nombre del proyecto y abra la ventana de
propiedades donde:
Establezca la informacin correspondiente como nombre del autor, Descripcin, Detectar
versiones instaladas, empresa desarrolladora, web de la empresa desarrolladora, Nombre
del producto, etc.
Img. 39.- Ventana de propiedades.
Terminado el proyecto, genere el proyecto (Men Generar / Generar Solucin F6 o

Generar / Generar [Nombre del proyecto] Shift + F6), vaya a la carpeta donde se
encuentra almacenado el proyecto (explorador de windows), ingrese en la carpeta Bin /
Debug donde encontrar el instalador de la aplicacin.
Ejecute el instalador y saltar el asistente de instalacin para nuestra nueva aplicacin.
www.afelipelc.mx
Pgina 36 de 77
Img. 40.- Asistente de instalacin de nuestra aplicacin.
www.afelipelc.mx
Pgina 37 de 77

Manipular una base de datos local
OBJETIVO: El alumno desarrollar aplicaciones que permitan la conexin a BD, manipulacin y
generacin de reportes utilizando asistentes para la administracin y uso de la informacin.
Un sistema de software que fomente la solucin a las necesidades de una organizacin, esta
principalmente enfocada a la manipulacin y administracin de los datos.
Modos de conexin a Base de Datos

La plataforma .NET incluye un conjunto de clases a travs del ADO.NET que ofrecen servicios de
acceso a diferentes fuentes de datos, servicios que cuyas caractersticas y funcionalidades
http://msdn.microsoft.com/espueden variar con respecto al tratamiento de los datos.
es/library/e80y5yhx(v=VS.100).aspx
En esta ocasin en la materia de desarrollo de aplicaciones utilizaremos el ADO.NET Entity
Framework http://msdn.microsoft.com/es-es/library/bb399572.aspx
ADO.NET Entity Framework permite a los desarrolladores crear aplicaciones de acceso a datos
programando con un modelo de aplicaciones conceptuales en lugar de programar directamente
con un esquema de almacenamiento relacional. El objetivo es reducir la cantidad de cdigo y el
mantenimiento necesarios para las aplicaciones orientadas a datos. Las aplicaciones de Entity
Framework ofrecen las siguientes ventajas:
Las aplicaciones pueden funcionar en trminos de un modelo conceptual ms centrado en la
aplicacin, que incluye tipos con herencia, miembros complejos y relaciones.
Las aplicaciones estn libres de dependencias de codificacin rgida de un motor de datos o
de un esquema de almacenamiento.
Las asignaciones entre el modelo conceptual y el esquema especfico de almacenamiento
pueden cambiar sin tener que cambiar el cdigo de la aplicacin.
Los desarrolladores pueden trabajar con un modelo de objeto de aplicacin coherente que se
puede asignar a diversos esquemas de almacenamiento, posiblemente implementados en
sistemas de administracin de base de datos diferentes.
Se pueden asignar varios modelos conceptuales a un nico esquema de almacenamiento.
La compatibilidad con Language Integrated Query (LINQ) proporciona validacin de la
sintaxis en el momento de la compilacin para consultas en un modelo conceptual.
El alumno debe consultar la informacin proporcionada por Microsoft para familiarizarse con el
tema consultando:
Introduccin: http://msdn.microsoft.com/es-es/library/bb386876.aspx
Tutorial rpido: http://msdn.microsoft.com/es-es/library/bb399182.aspx
Para empezar a trabajar con Entity Framework, nos basaremos en un ejemplo partiendo desde
cero.
www.afelipelc.mx
Pgina 38 de 77
Ejemplo de creacin de BD, conexin y manipulacin de datos

Crearemos un proyecto que se centre en 3 tablas relacionadas con la siguiente estructura:
Img. 41.- Modelo relacional para el ejemplo.
Cree un proyecto de Windows Forms (C#) llamado EjemploDEM cuyo diseo sea similar al
formulario de la siguiente imagen, establezca el nombre del formulario a ListaAutosFrm.
Img. 42.- Diseo del primer formulario y estructura del proyecto.
El formulario incluye:
1 DataGridView llamado ListaDtg: Mostrar la lista de autos cargada desde la BD.
1 Etiqueta - Label (con el texto Mostrar por marca).
1 ComboBox llamado PorMarcaCmb: Permitir al usuario mostrar solo los autos de la
marca seleccionada, la lista de marcas se cargar de forma predeterminada desde la BD.
1 Button llamado NuevoBtn con el texto Nuevo: Mostrar la ventana para dar de alta un
nuevo auto.
1 Button llamado EliminarBtn con el texto Elimina: Eliminara el auto seleccionado.
1 Button llamado CerrarBtn con el texto Cerrar: terminar la aplicacin.
Agregue otro nuevo formulario llamado DatosAutoFrm cuyo diseo ser similar a:
www.afelipelc.mx
Pgina 39 de 77
Img. 43.- Diseo del formulario de datos generales.
El formulario incluye:
2 GroupBox: con los textos Datos del auto y Datos del propietario que contiene cada
uno los controles correspondientes.
Datos del auto incluye:
o 4 etiquetas Label con los textos correspondientes Nmero de serie, Marca,
Modelo y Color.
o 1 TextBox llamado NumeroSerieTxt donde se ingresar el nmero de serie del
auto.
o 1 ComboBox llamado MarcaCmb donde se cargar la lista de marcas desde la BD
y el usuario seleccionar una.
o 1 TextBox llamado ModeloTxt donde se ingresar el modelo del auto.
Datos del propietario incluye:
o 1 ComboBox llamado NombreCmb que se utilizar para mostrar la lista de nombres
que coincidan con el nombre que este escribiendo el usuario y seleccionar el
nombre correspondiente (autocomplementar) y se cargarn los datos del
propietario si este ya est registrado en la BD.
o 1 TextBox llamado ApellidosTxt donde se ingresarn los apellidos del propietario.
o 1 TextBox llamado EdadTxt donde se ingresar la edad del propietario.
1 Button llamado AceptarBtn que al ser presionado cargar los datos ingresados en un
objeto.
1 Button llamado CancelarBtn que cerrar la ventana.
El tamao actual del formulario establzcalo como tamao mnimo (MinimunSize) y tamao
mximo (MaximunSize), establezca el botn predeterminado para aceptar el botn AceptarBtn
(AcceptButton) y el botn predeterminado para cancelar el botn CancelarBtn (CancelButton).
Crear la base de datos

En este ejemplo, utilizaremos una base de datos basada en servicio que agregaremos como
un elemento ms de nuestro proyecto, para ello:
www.afelipelc.mx
Pgina 40 de 77

En el nombre proyecto, haga clic derecho, seleccione Agregar / Nuevo Elemento, en la
ventana para agregar el elemento, seleccione las plantillas Datos, ah seleccione el elemento
Base de Datos basada en servicio y asigne el nombre BaseDatos.
Img. 44.- Agregar una base de datos al proyecto.
VS agregar el elemento BaseDatos.mdf y mostrar el asistente de configuracin de orgenes

datos el cual debemos cancelar ya que la base de datos an est vaca.
En el explorador de soluciones, presione doble clic sobre la base de datos BaseDatos.mdf, abrir
el explorador de servidores donde trabajaremos en la base de datos, ver que es muy similar al
administrador de base de datos SQL Management Studio, de hecho, puede crear la base de datos
en el administrador SQL Management Studio y al finalizar, extraer el archivo .mdf de la carpeta
DATA que se encuentra en la carpeta de instalacin del SQL Server.
Img. 45.- Abrir la base de datos.
www.afelipelc.mx
Pgina 41 de 77
Agregar tablas a la base de datos.

Para agregar tablas a la base de datos, haga clic derecho sobre el nodo Tablas (en el explorador
de servidores) y seleccione Agregar nueva tabla, esto abrir el diseador de tablas, de la misma
forma disearemos las tablas especificadas en el modelo relacional.
Img. 46.- Diseo de la tabla Marca.
Establezca la clave primaria para cada tabla, si se necesita crear un campo de tipo entero como
auto incremento, seleccione el campo, en la ventana Propiedades de columna expanda el nodo
Especificacin de identidad y cambie a S en Identidad, se autodefinir el auto incremento en 1.
Img. 47.- Diseo de la tabla Propietarop.
www.afelipelc.mx
Pgina 42 de 77
Img. 48.- Diseo de la tabla Auto.
Crear las relaciones.

Solo la tabla Auto tiene 2 claves forneas, para crear las relaciones, estando en el diseo de la
tabla Auto, haga clic en el botn Relaciones en la barra Diseador de tablas.
Se abrir la ventana Relaciones de clave externa sin ninguna relacin, haga clic sobre el botn
Agregar, crear una nueva relacin, en la parte lateral derecha seleccione especificacin de
consultas y haga clic sobre el botn sealado con el puntero del ratn en la siguiente imagen.
Img. 49.- Ventana de relaciones externas.
Abrir la ventana donde especificaremos la relacin, donde:

Tabla de clave principal: debe seleccionar la tabla donde se encuentra la clave primaria (Marca,
Propietario), seleccione el campo que es la clave primaria.
Tabla de clave externa: es la tabla actual (Auto) que contiene las claves externas, seleccione el
campo clave fornea a relacionar como se muestra en la imagen de ejemplo.
www.afelipelc.mx
Pgina 43 de 77
Img. 50.- Crear la relacin Auto.IdMarca a Marca.IdMarca.
Cree tambin la relacin hacia la tabla Propietario y guarde todos los cambios realizados.
Crear el modelo conceptual de datos

Utilizaremos la herramienta ORM (Object Relational Mapping) ADO.NET Entity Data Model
proporcionada por el ADO.NET Entity Framework mencionado al principio de este tema.
Para crear el modelo de datos, agregue un nuevo elemento al proyecto.
Seleccione las plantillas de Datos, y seleccione el elemento ADO.NET Entity Data Model y asigne
el nombre de Modelo.
Img. 51.- Agregar el ADO.NET Entity Data Model.
www.afelipelc.mx
Pgina 44 de 77

Abrir el asistente de configuracin del origen de datos.
Seleccione Generar desde la base de datos.
Img. 52.- Seleccionar el origen de los datos.
Seleccione la base de datos (automticamente reconoce la base de datos existente en el

proyecto), si la fuente de datos proviniera de otra fuente de datos como un servidor u otro archivo
de datos (SQL Server, MySQL Server, Oracle, Excel, Access, etc.), deber crear una nueva
conexin utilizando el asistente.
En esta ventana de configuracin de la cadena de conexin, especificamos el nombre de la
cadena de conexin BaseDatosEntities cuyo resultado final ser una clase con el mismo
nombre, a la que debemos instanciar para utilizar la fuente de datos.
www.afelipelc.mx
Pgina 45 de 77
Img. 53.- Configurar la cadena de conexin.
Haga clic en siguiente y seleccione los elementos de la base de datos que desea incluir en el
modelo (pueden incluirse tablas, vistas y procedimientos almacenados).
Img. 54.- Seleccionar elementos a incluir en el modelo.
Finalice el asistente, como resultado tendremos el modelo de datos en nuestro proyecto.
www.afelipelc.mx
Pgina 46 de 77
Img. 55.- Modelo conceptual creado desde la base de datos.
Como ver, el modelo contiene los elementos de la base de datos seleccionados en el asistente,
las relaciones son reflejadas tal y como se definieron en el modelo relacional.
Al crearse el modelo, automticamente agrega elementos como Propiedades de navegacin que
representan a los objetos a los cuales se tiene relacin.
Ejemplo:
La entidad Auto tiene las propiedades de navegacin Marca y Propietario, para lo cual, un objeto
de la clase Auto est relacionado a un objeto de la clase Marca, objeto al que puede accederse a
travs de la propiedad de navegacin Marca.
Supongamos que, se tiene el objeto llamado unauto y quiere saberse cul es el nombre de su
marca, para ello se invoca:
unauto.Marca.Nombre;
De igual forma si se quiere saber cul es el nombre de su propietario:
unauto.Propietario.Nombre;
Los campos IdPropietario e IdMarca solo almacenan los valores de las claves primarias a las que
estn relacionados.
De esta forma se estn utilizando las propiedades de navegacin; para relacionar dos objetos a
travs de una propiedad de navegacin.
Supongamos que tenemos el objeto unauto y unamarca y queremos relacionarlos, la relacin se
realizara de esta forma:
unauto.Marca = unamarca;
O almacenando el valor de la clave primaria en el campo correspondiente:
unauto.IdMarca = unamarca.IdMarca;
www.afelipelc.mx
Pgina 47 de 77

Manejo de datos.
Antes de empezar a trabajar con el modelo, necesitamos agregar algunas marcas a nuestra tabla
correspondiente:
Img. X.- Tabla de marcas.
Img. 56.- Tabla de marcas.
Ya con datos en nuestra tabla, agregaremos un registro en la tabla de Propietarios y crearemos

manualmente el registro de un auto asignando los valores de las claves primarias en IdPropietario
(id del propietario agregado manualmente) e IdMarca (id correspondiente a alguna de nuestras
marcas).
Img. 57.- Propietario registrado manualmente.
Img. 58.- Registro de auto creado manualmente.
Manipular la fuente de datos a travs de nuestras ventanas.

Empezaremos a programar nuestro primer formulario ListaAutosFrm el cual a cargar la ventana
deber mostrar la lista de autos registrados y cargar en el combobox la lista de marcas de nuestra
tabla.
Antes necesitamos utilizar la conexin en para poder manipular la fuente de datos.
Nos situamos en el cdigo de nuestro formulario y crearemos una instancia de nuestra clase
conexin (BaseDatosEntities).
www.afelipelc.mx
Pgina 48 de 77

public partial class ListaAutosFrm : Form
{
BaseDatosEntities BD = new BaseDatosEntities();
Creamos un mtodo llamado CargarLista() cuya funcin sea cargar la lista de autos a nuestro
datagridview cada vez que sea invocado.
private void CargarLista()
{
//sincronizar nuestro modelo de datos cargado en memoria
//con la base de datos volviendo a inicializar el objeto
BD = new BaseDatosEntities();
//limpiar la fuente de datos del datagridview
//cargar todos los registros de la tabla Auto a nuestro datagridview
//utilizando nuestro objeto conexin
this.ListaDtg.DataSource = BD.Auto;
}
Generamos el evento Load de nuestro formulario en el cual llamaremos al mtodo CargarLista() y

cargaremos la lista de marcas al combobox.
private void ListaAutosFrm_Load(object sender, EventArgs e)
{
//llamar al metodo CargarLista()
CargarLista();
//crear una lista de objetos Marca
//que contenga la lista de marcas cargada desde la BD
List<Marca> listademarcas = BD.Marca.ToList();
//agregar un objeto al principio de la lista
//objeto cuya propiedad Nombre sea "Todos" para mostrarlo como
//predeterminado en la lista
listademarcas.Insert(0, new Marca { IdMarca = 0, Nombre = "Todas" });
//cargar la lista de marcas al combo
this.PorMarcaCmb.DataSource = listademarcas;
//especificar el la propiedad de Marca que debe mostrarse como opciones
this.PorMarcaCmb.DisplayMember = "Nombre";
this.PorMarcaCmb.ValueMember = "IdMarca";
}
Ejecutamos nuestro ejemplo y obtenemos un resultado satisfactorio.
www.afelipelc.mx
Pgina 49 de 77
Img. 59.- Ejemplo ejecutndose y mostrando los resultados.
Como resultado observamos que nos carga todas las propiedades de la entidad Auto incluyendo
las propiedades de navegacin que muestran el nombre del objeto relacionado.
Para cargar solo los datos: Nmero de serie, Nombre de la Marca, Modelo, Color, Nombre del
propietario necesitamos trabajar con tipos annimos vistos en LINQ. Modificaremos nuestro
mtodo CargarLista() que quedar as:
{
//cargar todos los registros de la tabla Auto a nuestro datagrid
//utilizando nuestro objeto conexin
this.ListaDtg.DataSource = BD.Auto.Select(a =>
new
{
NoSerie = a.NoSerie,
Marca = a.Marca.Nombre,
Modelo = a.Modelo,
Color = a.Color,
Propietario = a.Propietario.Nombre.Trim() + " " +
a.Propietario.Apellidos.Trim()
});
}
El resultado obtenido es:
www.afelipelc.mx
Pgina 50 de 77
Img. 60.- Resultado de utilizar tipos annimos.
Ahora procedemos a programar el botn Nuevo para que el usuario pueda crear un nuevo
registro.
Para ello generamos el evento Clic que quedara as:
private void NuevoBtn_Click(object sender, EventArgs e)
{
//crear instancia de la ventana de datos a mostrar
DatosAutoFrm ventanadatos = new DatosAutoFrm();
ventanadatos.ShowDialog();
//volver a cargar la lista en el data grid
CargarLista();
}
Ejecute la aplicacin y compruebe la funcionalidad, a presionar Nuevo, abrir la ventana de datos.

Codificar el formulario de Datos (que permita editar y crear un registro).
Crear las variables y campos necesarios para almacenar el objeto a editar o crear, la conexin a la
bd y propiedad que permita establecer la clave del objeto a editar.
public partial class DatosAutoFrm : Form
{
//conexin a la BD
//objeto de la clase Auto
private Auto auto;
//campo que almacene el id del auto a editar (nmero de serie)
private string idauto;
//propiedad que reciba el nmero de serie del auto a editar
public string IdAuto
{
get { return idauto; }
set { idauto = value;
//llamar al mtodo que cargue los datos del objeto
www.afelipelc.mx
Pgina 51 de 77

//en los controles
CargarDatos();
}
}
Implementar el mtodo que cargue los datos del objeto en los controles del formulario.
//mtodo que cargue los datos del objeto a los controles
private void CargarDatos()
{
//recuperar el objeto desde la base de datos
//cuyo nmero de serie sea el que el usuario selecciono.
auto = BD.Auto.Where(a => a.NoSerie == idauto).FirstOrDefault();
//comprobar que el objeto devuelto no sea nulo
if(auto != null)
{
//cargar los datos del objeto a los controles
this.NumeroSerieTxt.Text = auto.NoSerie;
this.MarcaCmb.Text = auto.Marca.Nombre;
this.ColorTxt.Text = auto.Color;
this.ModeloTxt.Text = auto.Modelo.ToString();
this.NombreCmb.Text = auto.Propietario.Nombre;
this.ApellidosTxt.Text = auto.Propietario.Apellidos;
this.EdadTxt.Text = auto.Propietario.Edad.ToString();
}
}
Al cargar el formulario de datos, debe cargar la lista de marcas en el combobox correspondiente.

private void DatosAutoFrm_Load(object sender, EventArgs e)
{
//crear una lista de objetos Marca
//que contenga la lista de marcas cargada desde la BD
List<Marca> listademarcas = BD.Marca.ToList();
//agregar un objeto al principio de la lista
//objeto cuya propiedad Nombre sea "Todos" para mostrarlo como
//predeterminado en la lista
listademarcas.Insert(0, new Marca { IdMarca = 0, Nombre = "" });
//cargar la lista de marcas al combo
this.MarcaCmb.DataSource = listademarcas;
this.MarcaCmb.DisplayMember = "Nombre";
this.MarcaCmb.ValueMember = "IdMarca";
}
Implementar un mtodo que cargue los datos de los controles al objeto y guarde o actualice el
registro en la base de datos.
private void LlenarObjeto()
{
//si el objeto auto es nulo, es porque se est creando un nuevo registro
if (auto == null)
www.afelipelc.mx
Pgina 52 de 77

auto = new Auto(); //debemos inicializar el objeto
//llenar las propiedades del objeto
//los datos del auto
auto.NoSerie = this.NumeroSerieTxt.Text;
auto.Modelo = Convert.ToInt32(this.ModeloTxt.Text);
auto.Color = this.ColorTxt.Text;
//obtener el Id de la marca seleccionada y almacenarla en IdMarca
auto.IdMarca = (int)this.MarcaCmb.SelectedValue;
//comprobar si no tiene ningn objeto Propietario asociado
//si es as, inicializarlo con un nuevo objeto Propietario
if (auto.Propietario == null)
auto.Propietario = new Propietario();
//llenar los datos del propietario
auto.Propietario.Nombre = this.NombreCmb.Text;
auto.Propietario.Apellidos = this.ApellidosTxt.Text;
auto.Propietario.Edad = Convert.ToInt32(this.EdadTxt.Text);
//si el id del auto es 0, es porque se est creando el registro
//debe agregarse a la base de datos
if(idauto == "")
BD.AddToAuto(auto);
//guardar los cambios en la base de datos.
BD.SaveChanges();
}
Programar el botn Aceptar para que guarde los datos ingresados.

{
//llamar al mtodo que almacena los datos en el objeto
//y los guarda el objeto en la base de datos
LlenarObjeto();
//cerrar la ventana
this.Close();
}
Programar el botn Cancelar para que solo cierre la ventana.

private void CancelarBtn_Click(object sender, EventArgs e)
{
this.Close(); //cerrar sin realizar otra accin
}
Editar el elemento seleccionado en el DataGridView.

Si desea que al hacer clic en alguna celda de la tabla se seleccione la fila completa, modifique las
propiedades del control, establezca:
SelectionMode a FullRowSelect
MultiSelect = False
www.afelipelc.mx
Pgina 53 de 77

Codificaremos el DataGridView para que al presionar doble clic sobre un elemento de la lista se
muestre la ventana para editar sus datos.
Genere el evento CellDoubleClick del control DataGridView.
private void ListaDtg_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
{
//recuperar el nmero de serie del auto seleccionado
//y limpiar los espacios en blanco si tuviera.
string noserie = this.ListaDtg.CurrentRow.Cells[0].Value.ToString().Trim();
//crear instancia de la ventana de datos a mostrar
DatosAutoFrm ventanadatos = new DatosAutoFrm();
//indicar a la nueva ventana del id del auto a editar
ventanadatos.IdAuto = noserie;
ventanadatos.ShowDialog();
//volver a cargar la lista en el datagrid
CargarLista();
}
Al ejecutar el ejemplo, presione doble clic sobre el elemento a editar.
Img. 61.- Edicin de datos funcionando ejemplo funcionando.
Puede verificar que al mostrar la ventana de datos, pueden modificarse los datos y al hacer clic en
Aceptar los cambios son guardados en la BD.
Eliminar Registros
www.afelipelc.mx
Pgina 54 de 77

Cuando el usuario presione el botn Eliminar, el registro seleccionado debe eliminase, para ello,
genere el evento Clic del botn:
private void EliminarBtn_Click(object sender, EventArgs e)
{
//comprobar que el datagridview tiene registros
if (this.ListaDtg.Rows.Count > 0)
{
//obtener el id del auto seleccionado
string idauto = this.ListaDtg.CurrentRow.Cells[0].Value.ToString().Trim();
//recuperar el objeto a eliminar
var auto = BD.Auto.Where(a => a.NoSerie.Trim() == idauto).FirstOrDefault();
//comprobar que se encontr el objeto
if (auto != null)
Img.{X.- Edicin de datos funcionando ejemplo funcionando.
//eliminar el objeto
BD.DeleteObject(auto);
//guardar los cambios
BD.SaveChanges();
}
CargarLista();
}
}
Comprobando la funcionalidad obtenemos:
Img. 62.- Ejemplo con un registro ms.
www.afelipelc.mx
Pgina 55 de 77
Img. 63.- Ejemplo despus de eliminar el registro seleccionado.
Filtrar los elementos por nombre de marca.

Cuando se asigna un datasource a un combobox sufre cambios durante los cuales se produce el
evento SelectedIndexChanged y SelectedValueChanged y el cdigo que se encuentra dentro de
los mtodos asociados a estos eventos. Lo mismo sucede cuando se especifica la propiedad de la
clase que debe mostrarse como opcin (texto en el combobox).
Por lo cual, debemos crear una variable que indique que la lista de elementos se ha cargado en el
combo.
Entonces declaramos una variable de tipo bool la cual debemos cambiar su valor a true en el
evento Load del formulario despus de asignar los valores de las propiedades del combo.
Variable como miembro de la clase
private bool datoscargados;
En el Load del form

.
.
.
this.PorMarcaCmb.DisplayMember = "Nombre";
this.PorMarcaCmb.ValueMember = "IdMarca";
datoscargados = true;
Generamos el evento SelectedValueChanged donde:

private void PorMarcaCmb_SelectedValueChanged(object sender, EventArgs e)
{
if (datoscargados)
{
if(this.PorMarcaCmb.Text.Trim() == "Todas")
{
CargarLista();
}
www.afelipelc.mx
Pgina 56 de 77

else
{
//cargar los registros de la tabla Auto que estn relacionados
//con la marca seleccionada.
this.ListaDtg.DataSource = BD.Auto.
Where(a => a.Marca.Nombre.Trim() == this.PorMarcaCmb.Text.Trim()).
Select(a =>
new
{
NoSerie = a.NoSerie,
Marca = a.Marca.Nombre,
Modelo = a.Modelo,
Color = a.Color,
Propietario = a.Propietario.Nombre.Trim() + " " +
a.Propietario.Apellidos.Trim()
});
}
}
}
Comprobamos la funcionalidad, antes podemos agregar nuevos registros.
Img. 64.- Ejemplo con diferentes registros.
Seleccione el nombre de la marca que desea filtrar.
www.afelipelc.mx
Pgina 57 de 77
Img. 65.- Resultado al seleccionar una marca.
Al final se obtiene el ejemplo funcionando, el cdigo de este ejemplo ha sido adjuntado a la

carpeta Ejemplos incluida en la carpeta de este manual.
www.afelipelc.mx
Pgina 58 de 77

Creacin de reportes
Cuando una organizacin desarrolladora de software implementa una solucin a una necesidad
especifica de un cliente. Entrega un producto final como resultado del proyecto que cumple los
requerimientos del cliente.
Uno de los requerimientos del cliente es que el sistema software tenga la capacidad de arrojar
informacin relevante y relativamente til proveniente de una fuente de datos y tenerla disponible
en el momento requerido.
Esta informacin por lo general suele ser informacin estadstica.
La informacin arrojada debe convertirse en un documento llamado Reporte o informe.
La funcin del usuario final es realizar su labor cotidiana apoyndose en la nueva herramienta que
se le ha proporcionado.
Img. 66.- Aplicacin funcional con la que interacta el usuario.
Durante la interaccin con la aplicacin, el usuario elige guardar la informacin para continuar con
su labor.
Img. 67.- Aplicacin funcional con la que interacta el usuario.
www.afelipelc.mx
Pgina 59 de 77
La informacin es almacenada en la fuente de datos del sistema, desde

la cual podr ser recuperada y reutilizada.
La informacin almacenada est organizada en distintas tablas relacionadas.
Img. 68.- Tabla Pacientes de la aplicacin.
Img. 69.- Tabla Estudios de la aplicacin.
Img. 70.- Tabla ServiciosRegistrados de la aplicacin.
Sin importar como el sistema almacena, organiza y procesa la informacin para generar el
resultado final, lo que quiere el usuario es visualizar la informacin lista para ser impresa o
guardada como documento.
www.afelipelc.mx
Pgina 60 de 77
Img. 71.- Visualizacin de reportes.
Qu hacen los desarrolladores?

La organizacin desarrolladora de software utiliza herramientas e implementa mecanismos que le
permitan obtener los datos y generar el informe.
Consultas.
Vistas
Procedimientos almacenados.
Mtodos
Herramientas para Disear y generar informes.
o Crystal Reports (pago).
o Report Document (Visual Studio)
o JasperReport (libre)
Crear los informes en Visual Studio.
Microsoft Visual Studio 2010 incluye la funcionalidad de diseo de informes y los controles
ReportViewer, que le permiten agregar informes con todas las caractersticas a las aplicaciones
personalizadas. Los informes pueden contener datos tabulares, agregados y multidimensionales.
Los controles ReportViewer le permitirn procesar y mostrar el informe en la aplicacin. Hay dos
versiones del control.
Para utilizar un control ReportViewer en la aplicacin, debe saber cmo agregar el control al
formulario del proyecto, configurar el control para utilizar una definicin de informe local o informe
de servidor, actualizar las referencias de orgenes de datos y comprobar e implementar los
informes y el control en la aplicacin. Para obtener toda la informacin referente a la creacin y
visualizacin
de
informes,
consulte
http://msdn.microsoft.com/eses/library/ms251671%28v=VS.100%29.aspx
Modificaremos el ejemplo de autos, propietarios y marcas, para lo cual queremos imprimir en un

reporte el contenido del datagridview (los datos que se muestran como resultado de crear tipos
annimos).
Pero para nuestra suerte, los reportes no aceptan tipos annimos y mucho menos las propiedades
de navegacin que tenemos en el modelo, eso impedir que nuestro informe muestre los datos
que deseamos.
www.afelipelc.mx
Pgina 61 de 77

La solucin es crear Vistas y Procedimientos almacenados en nuestra base de datos e importarlos
a nuestro modelo.
La vista podemos utilizarla tambin para cargar los datos en el datagridview y llenar el informe al
mismo tiempo, y el procedimiento almacenado para recuperar datos especficos y utilizarlo para
llenar el informe.
Otra solucin para llenar el informe sera crear nuestras propias clases con las propiedades
necesarias y crear colecciones de objetos de estas clases y pasarlas al datasource del informe.
Crear una vista en la BD desde visual studio.
Abra la base de datos en el explorador de servidores y sobre vistas, haga clic derecho y
seleccione agregar nueva vista.
La vista debe devolver Nmero de Serie del auto, nombre de la Marca, Modelo, Color y nombre
del Propietario.
El cdigo SQL de la vista creada es el siguiente:
SELECT
dbo.Auto.NoSerie, dbo.Marca.Nombre AS Marca, dbo.Auto.Modelo, dbo.Auto.Color,
dbo.Propietario.Nombre + ' ' + dbo.Propietario.Apellidos AS Propietario
FROM
dbo.Auto INNER JOIN
dbo.Marca ON dbo.Auto.IdMarca = dbo.Marca.IdMarca INNER JOIN
dbo.Propietario ON dbo.Auto.IdPropietario = dbo.Propietario.Id
Guarde la vista como vAuto.
Crear un procedimiento almacenado en la BD desde visual studio.
En el explorador de servidores y sobre procedimientos almacenados, haga clic derecho y
seleccione agregar nuevo procedimiento almacenado.
El cdigo sql para campos a devolver por el procedimiento almacenado sern los mismos que los
de la vista.
El cdigo SQL quedar as:
CREATE PROCEDURE dbo.SPAutos
(
@marca varchar(50)
)
AS
SELECT
Auto.NoSerie, Marca.Nombre AS Marca, Auto.Modelo, Auto.Color,
Propietario.Nombre + ' ' + Propietario.Apellidos AS Propietario
FROM
Auto INNER JOIN
Marca ON Auto.IdMarca = Marca.IdMarca INNER JOIN
Propietario ON Auto.IdPropietario = Propietario.Id
WHERE
(Marca.Nombre = @marca)
RETURN
www.afelipelc.mx
Pgina 62 de 77

Guarde el procedimiento almacenado y cierre las pestaas correspondientes.
Actualizar el modelo.
Los nuevos elementos deben ser agregados a nuestro modelo, para ello, en el explorador de
soluciones abra el archivo Modelo.edmx, visualizara el diseo del modelo.
Haga clic derecho sobre cualquier rea del modelo y seleccione Actualizar modelo desde base
de datos.
Aparecer el asistente, seleccione los nuevos elementos a agregar (en la pestaa Agregar, utilice
Actualizar o Eliminar para realizar las acciones correspondientes) y seleccione Finalizar.
Img. 72.- Actualizar modelo.
El modelo actualizado quedar de esta forma:
Img. 73.- Modelo actualizado.
www.afelipelc.mx
Pgina 63 de 77

En el modelo observamos que la vista es agregada como una nueva entidad (nueva clase), pero
el procedimiento almacenado no aparece; los procedimientos almacenados no crean nuevas
entidades, los procedimientos almacenados deben importarse como funciones en el modelo.
Importar procedimientos almacenados como funcin.
Abra el explorador de modelos (botn derecho sobre cualquier rea del modelo / Explorador de
modelos).
Expanda el nodo Procedimientos almacenados.
Haga clic derecho sobre el procedimiento almacenado a importar y seleccione Agregar
importacin de funcin.
Img. 74.- Explorador de modelos.
En la ventana que se muestra:

En Nombre de la importacin de funcin: nombre de la funcin que existir en el modelo,
nombre con el cual deber ser invocado el procedimiento almacenado.
Para ver los campos que devuelve el procedimiento almacenado, haga clic en Obtener
informacin de funcin de columna.
En la ventana aparecern los datos de los campos que devuelve el SP.
Puede crear una nueva clase con las propiedades especificadas como campos del SP, para ello
haga clic en Crear nuevo tipo complejo, el nombre especificado en Complejo ser el nombre de
la nueva clase.
Para terminar la importacin, haga clic en Finalizar.
www.afelipelc.mx
Pgina 64 de 77
Img. 75.- Importar procedimiento almacenado como funcin.
Ya con la vista y el procedimiento almacenado en nuestro modelo, guarde los cambios y cierre el
modelo, ahora procedemos a disear nuestros informes.
Crear formulario donde se mostrar el informe.
Agregue un nuevo formulario llamado InformeFrm al cual debe agregar el control ReportViewer.
www.afelipelc.mx
Pgina 65 de 77
Img. 76.- Formulario que mostrar el informe.
Agregue un nuevo elemento Informe al proyecto.
Img. 77.- Agregar un elemento Informe al proyecto.
Se mostrar el diseador de informes donde

empezaremos a agregar elementos al diseo.
Se debe configurar la fuente de datos del informe, para
ello, en la ventana Datos del informe elija Nuevo /
Conjunto de datos.
Img. 78.- Datos de informe.
www.afelipelc.mx
Pgina 66 de 77

Se abrir la ventana de configuracin de la fuente de datos, en la cual especificamos el nombre
del DataSet para nuestro informe, en origen de datos, mostrar como nica opcin el nombre de
nuestra conexin de base de datos BaseDatosEntities, al seleccionarla en conjunto de datos
disponibles localizaremos el nombre de la clase que contiene las propiedades que deseamos
incluir en nuestro informe.
Si en origen de datos se encuentra vaco o el nombre de la clase que buscamos no se encuentra,
deberemos configurar un nuevo origen de datos, para ello:
Haga clic en nuevo, se mostrar el asistente de origen de datos.
Seleccionamos Objeto y damos clic en Siguiente.
Expanda el nombre del proyecto.
o Expanda el espacio de nombres en el que se encuentra la clase.
o Seleccione la clase que contiene las propiedades que deseamos incluir en nuestro
informe (El nombre de nuestra vista vAuto).
Img. 79.- Localizar la clase para utilizar como origen de datos.
Haga clic en Finalizar.

Veremos ahora el conjunto de datos seleccionado y el nombre de la clase como conjunto de
datos.
Haga clic en Finalizar.
www.afelipelc.mx
Pgina 67 de 77
Img. 80.- Localizar la clase para utilizar como origen de datos.
Agregue una nueva tabla al diseo del informe, arrastre los campos de Datos informe a las
columnas de la tabla.
Img. 81.- Disear el informe.
Puede agregar encabezado y pi de pgina para el informe, agregar ttulo, y campos especiales
en el informe.
Guarde los cambios en el diseo y cierre el diseo del informe.
Vuelva al formulario que contiene el ReportViewer y asigne el informe creado.
www.afelipelc.mx
Pgina 68 de 77
Img. 82.- Asignar el informe al ReportViewer.
Al asignar el informe, en el formulario se crear un nuevo elemento vAutoBindingSource el cual

contiene una propiedad DataSource al cual debemos asignar la lista de elementos que deben
cargarse en el informe.
Para acceder al elemento vAutoBindingSource desde cualquier clase, cambie su nivel de
accesibilidad a pblico.
Img. 83.- Cambiar el modificador de acceso.
Ahora en nuestro formulario ListaAutosFrm, agregaremos un botn llamado ImprimirBtn.
Img. 84.- Agregar botn imprimir al formulario.
En nuestra clase ListaAutosFrm, debemos crear un campo que almacene un objeto de la clase
InformeFrm (Formulario que mostrar el informe)
public partial class ListaAutosFrm : Form
{
private InformeFrm informe = new InformeFrm();
Modificar nuestro mtodo llamado CargarLista() para que deje de utilizar tipos annimos y ahora
utilice nuestra vista vAuto y la misma vista llene el informe.
www.afelipelc.mx
Pgina 69 de 77

{
//cargar los resultados de la vista al grid
this.ListaDtg.DataSource = BD.vAuto;
//limpiar los datos del informe
this.informe.vAutoBindingSource.DataSource = null;
//volver a cargar la lista al informe
this.informe.vAutoBindingSource.DataSource = BD.vAuto.ToList();
}
Modificar tambin el cdigo de nuestro combobox, pero este debe cargar la lista de autos
correspondientes a la marca seleccionada con los resultados del procedimiento almacenado.
private void PorMarcaCmb_SelectedValueChanged(object sender, EventArgs e)
{
if (datoscargados)
{
if(this.PorMarcaCmb.Text.Trim() == "Todas")
{
CargarLista();
}
else
{
//cargar la lista de los autos de la marca seleccionada
//invocando al procedimiento almacenado
this.ListaDtg.DataSource = BD.SPAutos(this.PorMarcaCmb.Text.Trim());
//limpiar los datos del informe
this.informe.vAutoBindingSource.DataSource = null;
//cargar tambien la lista al informe
this.informe.vAutoBindingSource.DataSource =
BD.SPAutos(this.PorMarcaCmb.Text.Trim()).ToList();
}
}
}
Los resultados del SP son pasados tambin al informe ya que los campos devueltos por la vista y
el sp son los mismos, de lo contrario se tendra un error.
Ahora solo nos falta programar el botn ImprimirBtn para que muestre el reporte.
private void ImprimirBtn_Click(object sender, EventArgs e)
{
informe.ShowDialog();
}
www.afelipelc.mx
Pgina 70 de 77

Comprobando la funcionalidad.
Agregue nuevos registros, y pruebe con Imprimir seleccionando alguna marca o todas las marcas.
Img. 85.- Resultado final del informe.
Roles y usuarios
Roles
Los roles estn diseados para permitir que el administrador del sistema controle lo que los
usuarios pueden hacer o no en el sistema.
El administrador gestiona los permisos de los usuarios en relacin con las operaciones como:
Altas, Bajas, Editar, etc.
Cada ROL o perfil se identifica con un nombre y se define por los permisos para ejecutar un
conjunto de tareas dentro del sistema.
Por ejemplo; Roles llamados:
Administrador: Tiene acceso a todas las operaciones del sistema.
Consultas: Solo tiene permiso para consultar informacin y generar reportes.
Captura: Solo tiene permisos para registrar Altas y Editar.
A continuacin se presenta una tabla de ejemplo donde se especifican con ms detalles los
permisos de cada rol.
Permisos / ROL Administrador Captura

Administrar
usuarios
X
Crear Registros
X
X
Editar Registros
X
X
www.afelipelc.mx
Consultas
Pgina 71 de 77

Eliminar Registros
Realizar Consultas
Generar Reportes
X
X
X
X
X
Usuarios
Los usuarios se identifican con un nombre y una contrasea para tener acceso a una aplicacin.
A los usuarios se les asignan roles dentro del sistema.
A continuacin se presenta una tabla de ejemplo donde se especifican con ms detalles los roles
de cada usuario.
Roles / Usuarios
Pepe
Pedro
Captura
Consultas
Administrador
Pablito
Petra
X
X
Implementar Roles y Usuarios en una aplicacin.

Autentificacin.
La autentificacin es uno de los conceptos clave que deben implementarse en aplicaciones
seguras.
La autentificacin es un proceso para verificar y asegurar que el usuario es quien dice ser.
Generalmente un sistema de software puede dividirse en 2 niveles de seguridad como usuarios
que no necesitan identificarse (annimos) y usuarios que necesiten identificarse.
Seguridad en aplicaciones Windows.
Visual Studio no incluye herramientas que permitan al desarrollador agregar seguridad a las
aplicaciones de Windows Forms como cualquier otro elemento de proyecto o como en
aplicaciones de ASP.NET donde incluye Membership.
Para implementar la seguridad en una aplicacin de Windows debe realizarse utilizando clases
que interactan con el sistema operativo (API).
Con la API pueden utilizarse las credenciales de usuario del sistema operativo Windows.
O crear un mtodo propio de autentificacin de usuarios en la aplicacin a travs de una ventana
de inicio de sesin (login).
En una aplicacin el usuario autentificado se le denomina Principal.
www.afelipelc.mx
Pgina 72 de 77

Para implementar la seguridad en nuestras aplicaciones de windows forms utilizaremos los
espacios de nombres:
System.Security.Principal;
System.Threading;
Que proporcionan las clases a utilizar.
Por ejemplo, si se quiere saber el nombre del usuario actual de windows, invocamos:
WindowsIdentity.GetCurrent().Name;
Consulte toda la informacin correspondiente al espacio de nombres System.Security.Principal en
http://msdn.microsoft.com/es-es/library/system.security.principal(v=VS.100).aspx
Implementar roles y usuarios en nuestro ejemplo de Autos proyecto llamado EjemploEDM que
manipula una base de datos.
Antes de empezar, trabajaremos con usuarios que solo tienen un rol, para ello, cree una nueva
tabla en la base de datos llamada Usuario, que contenga los campos NombreUsuario, Password
y Rol donde NombreUsuario sea la clave primaria.
Img. 86.- Tabla Usuario.
Agregue uno o ms registros a la tabla.
Img. 87.- Agregar algunos registros a la tabla
Agregue la tabla Usuario al Modelo.

Disee un formulario de inicio de sesin en el proyecto.
www.afelipelc.mx
Pgina 73 de 77
Img. 88.- Diseo del formulario de inicio de sesin.
Genere el cdigo del formulario donde el cdigo del formulario empiece:

//agregar espacios de nombre necesarios
using System.Security.Principal;
using System.Threading;
namespace EjemploEDM
{
public partial class LoginFrm : Form
{
//conexin a la BD
//variables necesarias para la sesin
GenericIdentity Identidad; //Crear una identidad genrica (credencial)
//si se quiere utilizar la identidad de Windows se utiliza la clase
//WindowsIdentity
//crear una lista donde guardaremos los roles
List<string> Roles = new List<string>();
//Crear el Principal
GenericPrincipal usuario;
Genere el evento clic para el botn Aceptar donde se comprobaran los datos ingresados por el
usuario con los almacenados en la base de datos, si son vlidos, se crear la sesin y se asociara
el usuario con el proceso (aplicacin).
{
//recuperar el objeto desde la bd que contenga los datos
//proporcionados por el usuario
var datosusuario = BD.Usuario.Where(u =>
u.NombreUsuario.Trim() == this.NombreUsuarioTxt.Text &&
u.Password.Trim() == this.PasswordTxt.Text).FirstOrDefault();
//comprobar si el objeto recuperado es diferente de nulo
if (datosusuario != null)
{
//Si se agregara un campo Activo en la tabla Usuario
//aqui podria validarse para dar o no acceso al usuario
www.afelipelc.mx
Pgina 74 de 77

//if(datosusuario.Activo == true)
//{
//inicializar el usuario (sesin)
//crear la credencial con el nombre del usuario
Identidad = new GenericIdentity(datosusuario.NombreUsuario.Trim());
//cargar la lista de roles.
Roles.Add(datosusuario.Rol.Trim());
//inicializar el Principal
usuario = new GenericPrincipal(Identidad, Roles.ToArray());
//asociar el usuario con toda nuestra aplicacin.
Thread.CurrentPrincipal = usuario;
//podemos validar que el usuario actual tenga el rol llamado Administrador
//y mostrarle la ventana principal
if(usuario.IsInRole("Administrador"))
{
ListaAutosFrm ventanaprincipal = new ListaAutosFrm();
this.Hide(); //ocutar la ventana de login
//si se cierra la ventana de login, la aplicacin se termina
ventanaprincipal.ShowDialog();
//cuando el usuario cierre la ventana principal, login tambin se cierra
this.Close();
}else
MessageBox.Show("Solo los administradores tienen acceso.", "Aplicacin
de ejemplo", MessageBoxButtons.OK, MessageBoxIcon.Error);
}else
{
//si el objeto es nulo, notificar al usuario y que intente nuevamente
MessageBox.Show("Datos de acceso incorrectos.", "Aplicacin de ejemplo",
MessageBoxButtons.OK, MessageBoxIcon.Error);
//limpiar los txt
this.NombreUsuarioTxt.Text = "";
this.PasswordTxt.Text = "";
this.NombreUsuarioTxt.Focus();
}
}
En cada ventana que se cargue y se quiera comprobar el rol del usuario, debe realizarse en el
evento Load, por ejemplo:
Se quiere validar que el usuario tenga el Rol de Administrador al cargarse el formulario llamado
ListaAutosFrm, el evento load de ListaAutosFrm quedara as:
private void ListaAutosFrm_Load(object sender, EventArgs e)
{
//Comprobar si el Rol del usuario NO es Administrador
//no permitir el acceso y cerrar la aplicacion.
if (!Thread.CurrentPrincipal.IsInRole("Administrador"))
{
www.afelipelc.mx
Pgina 75 de 77

MessageBox.Show("No tiene privilegios para acceder a este modulo.",
"Aplicacin de ejemplo", MessageBoxButtons.OK, MessageBoxIcon.Error);
//finalizar aplicacion
Application.Exit();
}
//llamar al metodo CargarLista()
Establezca el formulario LoginFrm como formulario de inicio del proyecto, para eso, en el
explorador de soluciones abra el archivo Program.cs y cambie la clase de inicio en el mtodo
Main().
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new LoginFrm());
}
Ejecute la aplicacin e intente acceder con ambos usuarios creados, uno con Rol de
Administrador y otro con Rol de Invitado.
Img. 89.- Ingresando con datos incorrectos.
Img. 90.- Ingresando con usuario cuyo rol es Invitado.
www.afelipelc.mx
Pgina 76 de 77
Img. 91.- Ingresando con usuario cuyo rol es Administrador.
Conclusin
Este documento que he elaborado ha sido la base para que los estudiantes a quienes he
impartido estos temas vayan adentrndose al a veces complejo mundo de la programacin,
aunque siendo realista, no todos adquieren las competencias buscadas durante el curso, pero
siempre hay un porcentaje considerado que en un poco tiempo podr dominar estos terrenos.
Sin ms que agregar, considero que este documento ayude a ms estudiantes en su aprendizaje.
Alfonso Felipe Lima Corts
www.afelipelc.mx
@afelipelc
www.afelipelc.mx
Pgina 77 de 77

Desarrollo de Aplicaciones Windows Forms en

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Desarrollo de Aplicaciones Windows Forms en

Transféré par

Droits d'auteur :

Formats disponibles

Desarrollo de

Desarrollo de aplicaciones con Windows Forms en .NET

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

Img. 1.- Cuadro de herramientas.

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

Al agregar controles al diseador de formularios, el

Asignar nombres a los controles

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

private void AceptarBtn_Click(object sender, EventArgs e)

Ejemplo1.- Cdigo escrito en C#.

Para recuperar o establecer informacin a un control (invocar propiedades, mtodos y eventos)

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

Se est invocando al mtodo Focus del control.

En el cdigo mostrado en Ejemplo1, la instruccin MessageBox.Show("Hola " + this.NombreTxt.Text);

Img. 5.- Resultado del

Img. 4.- Ejecutando el ejemplo.

Para ms informacin y detalles sobre la clase MessageBox, consulte la documentacin oficial de

Img. 6.- Formulario con el control MenuStrip y contenedor

Utilizar este control es bastante sencillo,

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

static void Main()

Ejecute el ejemplo, haga clic sobre Ver / Primer ejemplo.

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

Img. 7.- Formulario con el control MenuStrip y

Proyecto con mltiples formularios

Especifique el nombre del formulario y

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

Img. 8.- Excepcin generada en tiempo de ejecucin, No se puede

Controlar excepciones de forma general.

El bloque de cdigo anterior controla la excepcin y muestra un mensaje al usuario informando

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

Img. 9.- Mensaje mostrado al

Controlar por tipo de excepcin.

El bloque de cdigo anterior controla la excepcin de tipo DivideByZeroException en el mtodo

Img. 10.- Mensaje mostrado al generarse la

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

Programacin Orientada a Objetos en C#

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

Img. 11.- Trabajando con objetos.

Para invocar a un constructor al crear un objeto seria:

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

Donde el objeto inicializado por un constructor que toma argumentos quedara:

Ejemplo: crear una clase ms completa.

A. Felipe Lima Corts

Desarrollo de aplicaciones con Windows Forms en .NET

public string Sexo