Desarrollo de Aplicaciones Windows Forms en PDF

Desarrollo de
aplicaciones con
Windows Forms
Empezando con .NET
En este documento comparto información que ayude a los

estudiantes que empiezan a trabajar con Windows Forms en
.NET partiendo desde el diseño de formularios hasta la
manipulación de una base de datos utilizando ADO. Net Entity
Framework a través de consultas LINQ y generar reportes,
además de agregar seguridad a las aplicaciones desarrolladas
con Windows Forms.
Alfonso Felipe Lima Cortés

13/06/2012
Desarrollo de aplicaciones con Windows Forms en .NET
Contenido
Diseño y desarrollo de aplicaciones ................................................................................................................... 3
Introducción ....................................................................................................................................................... 3
Controles ............................................................................................................................................................ 3
Uso de controles ............................................................................................................................................ 4
Algunas propiedades generales de los controles............................................................................... 4
Asignar nombres a los controles ........................................................................................................... 4
Ejercicio ..................................................................................................................................................... 5
Cuadros de diálogo............................................................................................................................................. 5
Menús................................................................................................................................................................. 6
Proyecto con múltiples formularios ................................................................................................................... 8
Manejo de excepciones...................................................................................................................................... 8
Programación Orientada a Objetos en C#........................................................................................................ 11
Clases............................................................................................................................................................ 11
Crear objetos ................................................................................................................................................ 12
Miembros de clase ....................................................................................................................................... 12
Ejemplo: crear una clase más completa ................................................................................................... 15
Colecciones de objetos................................................................................................................................. 16
LINQ .................................................................................................................................................................. 22
Documentar código fuente .............................................................................................................................. 23
¿Qué debe documentarse? ...................................................................................................................... 23
¿Qué utilizamos en la documentación? ................................................................................................... 24
Ejemplo: ................................................................................................................................................... 24
Controles creados por el usuario (Controles de usuario) ................................................................................ 26
Controles de usuario como biblioteca de controles .................................................................................... 28
Creación de distribuciones (Instaladores) ........................................................................................................ 31
Publicar el proyecto: ................................................................................................................................ 32
Crear un proyecto de instalación. ............................................................................................................ 34
Manipular una base de datos local .................................................................................................................. 38
Modos de conexión a Base de Datos ........................................................................................................... 38
Ejemplo de creación de BD, conexión y manipulación de datos ............................................................. 39
Crear la base de datos .................................................................................................................................. 40
www.afelipelc.mx A. Felipe Lima Cortés Página 1 de 77

Crear el modelo conceptual de datos .......................................................................................................... 44

Manejo de datos. ......................................................................................................................................... 48
Creación de reportes .................................................................................................................................... 59
Crear los informes en Visual Studio. ........................................................................................................ 61
Roles y usuarios ................................................................................................................................................ 71
Roles ......................................................................................................................................................... 71
Usuarios.................................................................................................................................................... 72
Autentificación. ........................................................................................................................................ 72
Seguridad en aplicaciones Windows. ....................................................................................................... 72
Conclusión ........................................................................................................................................................ 77

Diseño y desarrollo de aplicaciones
Introducción
Los formularios son la unidad básica de una aplicación, es importante realizar algunas
consideraciones sobre su función y su diseño. Un formulario es una hoja en blanco que el
desarrollador rellena con controles, para crear una interfaz de usuario, y con código, para procesar
los datos. Para ese fin, Visual Studio proporciona un entorno de desarrollo integrado que ayuda a
escribir el código. La funcionalidad de estos controles se complementa con el código escrito por el
desarrollador, lo que permite desarrollar fácil y rápidamente las soluciones deseadas.
Controles
La interfaz de usuario de una aplicación visual está diseñada a partir de controles, siendo estos la
base de desarrollo rápido 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 documentación oficial del entorno de desarrollo
http://msdn.microsoft.com/es-
es/library/xfak08ea.aspx la documentación técnica
para cada control también se encuentra disponible
haciendo clic sobre el nombre del control.
Img. 1.- Cuadro de herramientas.

Uso de controles
Para utilizar cualquier control del cuadro de herramientas en
el diseño de formularios, debe seleccionarse y colocarse en
el diseñador de formularios.
En la documentación técnica de cada control encontramos

la descripción, propiedades, métodos y eventos,
información que debe conocer el desarrollador a su vez que
esta le permita utilizar adecuadamente y sacar el máximo
provecho a cada uno de los controles.
Img. 2.- Agregando controles al
Al agregar controles al diseñador de formularios, el
formulario.
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 información 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 más comunes que muestran texto a los usuarios
son las etiquetas (label) y cuadros de texto (textbox).
• TabIndex: Obtiene o establece el orden de tabulación del control en su contenedor. Esta
propiedad permite definir el orden de navegación 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 aplicación, por lo tanto, debe haber un orden para facilitarle el uso e interacción con
la interfaz.
• Anchor: Obtiene o establece los bordes del contenedor al que está enlazado un control y
determina cómo se cambia el tamaño de un control con su elemento primario. Propiedad
importante en los controles que permite definir como un control debe cambiar su tamaño y
ubicación cuando la ventana que lo contiene cambia su tamaño.
Consulte la lista completa de controles y acceda a toda la documentación 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 través 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.

AceptarBtn, CancelarBtn; donde Btn hace referencia a Button, esto indica que el control es un
botón.
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 diseñador 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 diseñar.
Cuadros de diálogo
Recuperar datos de los controles y mostrarlos en mensajes:
Nota: Es muy importante inducir e introducir al alumno a familiarizarse con el código escrito en C#:
palabras clave, tipos de datos, sentencias de control, sintaxis, interfaces, clases, propiedades,
métodos, etc. y trabajar con ejemplos de código.
Genere el código para el botón que contiene la leyenda “Aceptar” presionando doble clic sobre el
botón en el formulario (para ver el código 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 botón al hacer clic sobre el
MessageBox.Show("Hola " + this.NombreTxt.Text);
}
Ejemplo1.- Código escrito en C#.
Para recuperar o establecer información a un control (invocar propiedades, métodos y eventos)

invocamos al nombre del control seguido de. “punto” más el nombre de la propiedad, método u
evento, ejemplo:
this.NombreTxt.Text o NombreTxt.Text Se está invocando a la propiedad Text del control.

this.NombreTxt.Focus() NombreTxt.Focus() Se está invocando al método Focus del control.
En el código mostrado en Ejemplo1, la instrucción MessageBox.Show("Hola " + this.NombreTxt.Text);

emite un mensaje al usuario a través del método Show de la clase MessageBox, en el mensaje
se incluye el texto “Hola ” concatenándose 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. 4.- Ejecutando el ejemplo. Img. 5.- Resultado del

mensaje.
Para más información y detalles sobre la clase MessageBox, consulte la documentación oficial de
la clase http://msdn.microsoft.com/es-es/library/system.windows.forms.messagebox.aspx
El alumno debe practicar con más ejercicios que le permitan manipular los controles del
formulario.
Menús
Usar una barra de menús en una aplicación permite agrupar y ordenar los comandos de la
aplicación facilita la accesibilidad por parte del usuario a estos.
En una aplicación de Windows Forms para

crear una barra de menús, utilizamos el
control MenuStrip
(http://msdn.microsoft.com/es-
es/library/ms171649%28v=VS.100%29.asp
x ).
Utilizar este control es bastante sencillo,

agregamos el control y empezamos a
Img. 6.- Formulario con el control MenuStrip y contenedor
agrupar los comandos que implementa o
MDI.
se implementarán en la aplicación.

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 más información acerca de los formularios MDI http://msdn.microsoft.com/es-
es/library/7aw8zc76%28v=VS.100%29.aspx
Genere el código 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.- Código del evento clic del elemento Ver / Primer Ejemplo.
En el código 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 método 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.

Img. 7.- Formulario con el control MenuStrip y

contenedor MDI mostrando una nueva ventana.
Proyecto con múltiples formularios
Una aplicación de visual puede estar compuesta por una o más ventanas, emitir mensajes
visuales para el usuario y permitir la interacción con la interfaz gráfica 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, refiriéndose a
que es un elemento de la clase Form.
Img. 3.5.1.- Agregar nuevo formulario.
Creados los formularios, procedemos a la
personalización o configuración de estos donde, y trabajamos en su diseño.
Manejo de excepciones
El código de una aplicación escrito por el desarrollador aun bien diseñado puede afrontarse a
situaciones inesperadas durante la ejecución de la aplicación, dado que si el desarrollador no
considera las posibilidades de que ocurra un suceso que pueda afectar al correcto funcionamiento
de la aplicación, esta podría terminar de funcionar provocando un mal proceso de la información y
afectando la usabilidad por parte del usuario.
A este tipo de sucesos que ocurren en tiempo de ejecución se les llama excepciones.

Img. 8.- Excepción generada en tiempo de ejecución, “No se puede

dividir entre 0”.
Los programadores utilizan bloques try para aislar el código que puede ser afectado por una
excepción, y bloques catch para aislar el código que debe ejecutarse cuando resulte una
excepción, al bloque catch se le denomina “bloque para controlar excepciones”.
Los bloques catch pueden especificar el tipo de excepción 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 código anterior controla la excepción y muestra un mensaje al usuario informando
que ha ocurrido un error, aun generándose la excepción, el programa continúa ejecutándose
correctamente.

Img. 9.- Mensaje mostrado al

generarse la excepción.
Controlar por tipo de excepción.
private void EjemploControlExcepciones()

{
try
{
int a = 5;
int b = 0;
int c;
c = a / b;
MessageBox.Show("El resultado es: " + c.ToString());
}
//controlar excepción de división entre cero.
catch(DivideByZeroException)
{
MessageBox.Show("No se puede dividir entre cero.");
}
}
El bloque de código anterior controla la excepción de tipo DivideByZeroException en el método

EjemploControlExcepciones() y muestra un mensaje al usuario informando que “no se puede
dividir entre cero”, y el programa continúa ejecutándose correctamente.
Img. 10.- Mensaje mostrado al generarse la

DivideByZeroException.
Pero si se produjera otra excepción, esta nueva no sería controlada, ya que no se controlan
excepciones de forma general.
Para controlar otros tipos de excepción, agregue más bloques catch que controlen el tipo que
pudiera producirse en su código.
Para ver más detalles sobre excepciones y control de excepciones, visite la documentación oficial
http://msdn.microsoft.com/es-es/library/ms173160%28v=VS.100%29.aspx

Para ver la jerarquía de excepciones y toda su documentación técnica, visite la documentación

oficial http://msdn.microsoft.com/es-es/library/z4c5tckx%28v=VS.100%29.aspx
Programación Orientada a Objetos en C#
Clases
Una clase es una plantilla que define una estructura, agrupa comportamientos (métodos) 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 también 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, métodos 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 través de la derivación, 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

{
}

Donde Empleado hereda todos los datos de la clase Persona.
Crear objetos
Un objeto es una entidad basada en una clase también 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 más información y ejemplos, consulte la documentación oficial

http://msdn.microsoft.com/es-es/library/x9afc042(v=VS.100).aspx
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 numérico integrado o una instancia de otra clase.
o Constantes: Las constantes son campos o propiedades cuyo valor se establece en tiempo
de compilación y no se puede cambiar.
o Propiedades: Las propiedades son métodos de una clase a los que se obtiene acceso
como si fueran campos de esa clase. Una propiedad puede proporcionar protección a un
campo de clase con el fin de evitar que se cambie sin el conocimiento del objeto.
o Métodos: Los métodos definen las acciones que una clase puede realizar. Los métodos
pueden aceptar parámetros que proporcionan datos de entrada y devolver datos de salida
a través de parámetros. Los métodos también pueden devolver un valor directamente, sin
utilizar ningún parámetro.
o Constructores: Los constructores son métodos 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:

{

//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
cálculo el valor de un campo privado. Las propiedades pueden utilizarse como si fuesen miembros
de datos públicos, aunque en realidad son métodos 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 métodos.
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;}
}
Dónde:
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; }
}

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 públicos.
Img. 11.- Trabajando con objetos.

La imagen anterior muestra que al tratar un objeto puede accederse a todos sus miembros
públicos, las propiedades se presentan con un icono que muestra una tarjeta sostenida por una
mano, los métodos 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, …, parámetron)

{
<operaciones con los parámetros>
}
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:

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 automáticamente la sugerencia de los elementos de
la clase que pueden estar tratándose de invocar, donde nos muestra la estructura de los
elementos.
Donde el objeto inicializado por un constructor que toma argumentos quedaría:
Persona otrapersona = new Persona("Juan", "Pérez Torres");
Ejemplo: crear una clase más completa.

Una clase completa quedaría como nuestro ejemplo:

{
private int edad;
//constructores
public Persona()
{
}

{
}
//propiedades
{
}
public string Apellidos

{
get { return this.apellidos; }

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, además, 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 genéricas porque se obtiene la ventaja inmediata

de la seguridad de tipos sin necesidad de derivar de un tipo de colección base e implementar

miembros específicos de los tipos. Además, por lo general los tipos de colección genéricos tienen
un mejor rendimiento que los tipos de colección no genéricos correspondientes (y mejor que el de
los tipos derivados de tipos de colección base no genéricos) cuando los elementos de la colección
son tipos de valor, porque con los genéricos 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 métodos para buscar, ordenar y
manipular listas. http://msdn.microsoft.com/es-es/library/6sh2ey19.aspx
La sintaxis para crear una nueva colección genérica es:

List<[Tipo de dato]> [nombre de la colección] = new List<[Tipo de dato]>();
Ejemplo:
Crear una lista de objetos de la clase Persona, podría decirse que representa una “lista de
personas”.
List<Persona> listadepersonas = new List<Persona>();
Agregar elementos a la colección.

Para agregar nuevos elementos a la colección presentamos 2 formas.
1.- Crear un nuevo objeto de la clase Persona y agregarlo a la colección:

nuevapersona.Nombre = "Juan";
nuevapersona.Apellidos = "Pérez Torres";
nuevapersona.FechaNacimiento = DateTime.Parse("01/01/1990");
nuevapersona.Edad = 21;
nuevapersona.EstadoCivil = "Soltero";
nuevapersona.Calle = "Independencia";
nuevapersona.Numero = "350";
nuevapersona.Municipio = "Izúcar 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 instrucción listadepersonas.Add(nuevapersona); agrega el nuevo objeto creado a la
colección de objetos de la clase Persona.
2.- Agregar un nuevo objeto directamente a la colección.
listadepersonas.Add(
new Persona {
Nombre = "Juan",
Apellidos = "Pérez Torres",
FechaNacimiento = DateTime.Parse("01/01/1990"),
Sexo = "Hombre",
Edad = 21,
EstadoCivil = "Soltero",
Calle = "Independencia",

Numero = "350",
Municipio = "Izúcar de Matamoros",
Estado = "Puebla"
}
);
En este ejemplo no se crea el objeto por separado, sino que se crea directamente dentro del
método Add(), consulte la documentación de la clase List<> donde encontrará como manipular
colecciones.
Crear un ejemplo donde se cargue una colección 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 diseño 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 diseño sea similar al de la imagen.
Img. 13.- Formulario que deberá

llenarse para crear o editar objetos.

• Vaya al código del formulario ListaPersonas donde:

o Cree una colección de objetos de la clase Persona.
List<Persona> listadepersonas = new List<Persona>();
o Genere el evento Click() del botón “Nuevo” que abrirá la ventana donde el usuario deberá
ingresar los datos de la nueva persona, el código 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 método cargamos la lista de objetos al control DataGridView a través de su

propiedad DataSource (Recurso de datos), para más información acerca de este
control, visite http://msdn.microsoft.com/es-
es/library/system.windows.forms.datagridview%28v=VS.100%29.aspx
En este método también se invoca al método IngresoDatos() que debe
implementarse en la ventana PersonaFrm, incluida también la propiedad
DatosPersonales.
o Genere el evento clic para el botón “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 verán 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
//después 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 través de la propiedad

ventanadatospersonales.DatosPersonales = objetorecuperado;
ventanadatospersonales.ShowDialog();
//al cerrar la ventana de datos, actualizar el datagridview

ListaDtg.Refresh();
}
o Generar el evento Click() del botón “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 código de la ventana PersonaFrm donde:

o Cree un campo donde se almacene un objeto de la clase Persona.
private Persona persona;
o 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();
}
}
o Implementar un método 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";
}
o Implementar el método 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;

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;
}
o Crear un método público que devuelva un valor que indique si el usuario presionó el
botón Aceptar (true) o el botón Cancelar (false).
//campo que almacene el valor que indique si el usuario ingreso datos
private bool ingresodatos;
//Método que devuelva el valor del campo ingresodatos

public bool IngresoDatos()
{
return ingresodatos;
}
o Finalmente en esta misma ventana, genere el evento clic para el botón Aceptar
donde debe invocarse el método 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 Img. 14.- Comprobando funcionalidad del
objeto seleccionado se eliminará
ejemplo.
automáticamente sin poder volverse a
recuperar.

LINQ
Language-Integrated Query (LINQ) es un conjunto de características que agrega capacidades de

consulta eficaces a la sintaxis de los lenguajes C# y Visual Basic. LINQ incluye patrones estándar
y de fácil aprendizaje para consultar y actualizar datos, y su tecnología se puede extender para
utilizar potencialmente cualquier tipo de almacén 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 información acerca del LINQ se encuentra en http://msdn.microsoft.com/es-

es/library/bb397926.aspx la cual debe consultarse para familiarizarse con el tema.
Para ver algunos ejemplos acerca de cómo escribir consultas LINQ para colecciones, visite la url
http://msdn.microsoft.com/en-us/vcsharp/aa336746 donde se muestran ejemplos para la mayoría
de los operadores de consulta en los cuales también 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 tratarán colecciones.
Para crear nuestra colección de la clase cliente:

List<Cliente> Clientes = new List<Cliente>();
Realizar consultas sobre la colección 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:

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 anónimos):

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 línea
http://afelipelc.wordpress.com/2011/06/21/filtrar-elementos-de-una-coleccion-list-por-un-campo-
especificado/
Documentar código fuente
Documentar el código fuente escrito por el programador no significa que tenga que agregar
comentarios abundantes en el código.
Documentar el código fuente de un programa escrito es añadir suficiente información 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 también el usuario pueda saberlo y por qué
lo hace.
Documentar un programa significa que el programador terminará una obra bien hecha, siendo
también 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 compresión al ser revisado y modificado por
el programador original u otro programador.
En la documentación se incluyen explicaciones a todo lo que es evidente.
¿Qué debe documentarse?

Clases ¿De qué se encarga la clase?
Métodos – Propiedades ¿Qué hace un método?, ¿Cuál es el uso esperado del método?
¿Para qué se usa una variable o campo?
¿Qué podría mejorarse?

¿Qué utilizamos en la documentación?

Los comentarios son una forma de documentar el código fuente, los comentarios debe agregarse:
Al principio de la clase.
Al principio de un método.
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
código.
Algunos entornos de desarrollo ofrecen herramientas que permiten al programador documentar un

programa, por ejemplo, javadoc en java donde se utilizan etiquetas en la documentación.
Visual Studio ofrece una herramienta para documentar código en C# mediante comentarios XML
llamados comentarios de documentación XML http://msdn.microsoft.com/es-
es/library/b2s063f7%28v=VS.100%29.aspx
Las etiquetas para documentar código en c# las encontramos en la dirección
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
declaración del método a documentar, se presiona /// (tres veces diagonal), automáticamente se
agregará la etiqueta <sumary> </sumary> donde escribiremos la descripción corta acerca del
miembro.
Al documentar un constructor o método, automáticamente agregara las partes para especificar
cada uno de los parámetros.
Ejemplo:
/// <summary>
/// Representa los datos generales de una persona.
/// </summary>
/// <remarks>
/// La clase Persona implementa las propiedades más generales de una persona
/// como: nombre, apellidos, fecha de nacimiento, edad, estado civil, sexo,
/// domicilio, número, estado y municipio.
/// </remarks>
{
private int edad;
public Persona()
{

/// <summary>
/// Constructor que inicializa un objeto de la clase Persona con
/// solo 2 parámetros
/// </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; }

/// <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 república 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 gráficas de
usuario. Un control de usuario es esencialmente un componente con una representación visual.
Como tal, puede constar de uno o más controles de formularios Windows Forms, componentes o
bloques de código, que pueden extender su funcionalidad. Los controles de usuario pueden
incluirse en formularios Windows Forms de la misma manera que los demás 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).

Agregue los controles que se ven en la siguiente imagen: Label, TextBox (NombreTxt), Button
(AceptarBtn).
Img. 16.- Diseño de control de usuario.
Genere el código del evento clic para el botón 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 agréguelo 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 diseño y tamaño 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.

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 amplíen 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.- Diseñe 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);
}

Al generar la solución, 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 solución.
Automáticamente 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 solución.
Img. 22.- Establezca el nuevo proyecto de inicio.

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 botón derecho sobre el contenido de la ficha y selecciona Elegir elementos.
Localice el ensamblado generado por la biblioteca de controles creada, selecciónelo.
Img. 25.- Localizar biblioteca de control (DLL).

Se mostrará la lista de controles que contiene, seleccione los elementos a agregar y seleccione
Aceptar.

Img. 26.- Controles incluidos en la biblioteca (seleccionados).
Los controles seleccionando aparecerán en el cuadro de herramientas y estarán siempre

disponibles para todos los proyectos de Windows Forms.
Img. 27.- Control agregado al cuadro de herramientas.

Pueden complementarse los controles de usuario agregando más información como descripción
del control, icono, y documentar las funcionalidades implementadas.
Para información sobre crear controles personalizados de formularios de Windows, consulte la

dirección 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 dirección

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/
Creación de distribuciones (Instaladores)
Después de haber implementado la aplicación 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 aplicación funcione correctamente, a esto
también se le conoce como crear una distribución.

En Visual Studio se tienen 2 formas de crear la distribución, 1).- Mediante la publicación y 2

).- Creando un proyecto de instalación.
Publicar el proyecto:
• El primer paso es Generar el proyecto o solución (Menú Generar / Generar Solución “F6” o
Generar / Generar [Nombre del proyecto] “Shift + F6”), si durante este proceso no se
encontró ningún error, pasamos al siguiente paso, caso contrario debemos solucionar los
errores de codificación.
• Ir a Generar / Publicar [Nombre del proyecto], se abrirá el asistente de publicación 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 publicación – especificar ubicación.
o Seleccionar desde donde se instalará la aplicación.
Img. 29.- Asistente de publicación.

o Configurar actualizaciones.
Img. 30.- Configurar actualizaciones.
o Finalizar el asistente.
Img. 31.- Finalizar el asistente.
Generada la distribución, mostrará automáticamente la carpeta donde se almaceno el instalador,

el cual podemos ejecutar para su instalación, instalada la aplicación puede ya empezar a
utilizarse.

Img. 32.- Ejecutando el instalador.
Crear un proyecto de instalación.

• Cree un nuevo proyecto de instalación de Windows, en la ventana para crear proyecto,
seleccione Otros tipos de proyectos / Instalación e implementación / Instalador de Visual
Studio.
Img. 33.- Crear proyecto de instalación.

• Al crear el proyecto, el entorno de desarrollo mostrará el sistema o estructura de archivos
para el programa de instalación.
Img. 34.- Estructura del programa de instalación.

Donde los elementos representan:

Carpeta de instalación: representa la carpeta donde se instalará la aplicación, en este
elemento deben agregarse todos los archivos necesarios para el funcionamiento de la
aplicación.
Escritorio del usuario: En este elemento deben agregarse los accesos directos o archivos
que serán colocados en el escritorio del usuario.
Menú Programas del usuario: En este elemento deben agregarse los accesos directos,
carpetas o archivos que serán agregados en el menú inicio del usuario.
• Agregar archivos y otros elementos a la estructura:
Img. 35.- Agregar archivos a la carpeta de instalación.

Para agregar archivos a la carpeta de instalación, sitúese en Carpeta de aplicación, en el
área de contenido agregue todos los archivos necesarios para que la aplicación funcione
(ensamblados, manual de ayuda, archivos de base de datos, etc.)
Para crear accesos directos al escritorio, sitúese 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.

El explorador de soluciones muestra la estructura del

proyecto, pero muestra también las dependencias
detectadas para que la aplicación funcione
correctamente, uno de ellos es el Microsoft .NET
Framework que corresponde a la versión 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á dándole la opción 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 información correspondiente como nombre del autor, Descripción, 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 Solución “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 aplicación.
• Ejecute el instalador y saltará el asistente de instalación para nuestra nueva aplicación.

Img. 40.- Asistente de instalación de nuestra aplicación.

Manipular una base de datos local
OBJETIVO: El alumno desarrollará aplicaciones que permitan la conexión a BD, manipulación y

generación de reportes utilizando asistentes para la administración y uso de la información.
Un sistema de software que fomente la solución a las necesidades de una organización, esta
principalmente enfocada a la manipulación y administración de los datos.
Modos de conexión a Base de Datos
La plataforma .NET incluye un conjunto de clases a través del ADO.NET que ofrecen servicios de
acceso a diferentes fuentes de datos, servicios que cuyas características y funcionalidades
pueden variar con respecto al tratamiento de los datos. http://msdn.microsoft.com/es-
es/library/e80y5yhx(v=VS.100).aspx
En esta ocasión 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 código y el
mantenimiento necesarios para las aplicaciones orientadas a datos. Las aplicaciones de Entity
Framework ofrecen las siguientes ventajas:
• Las aplicaciones pueden funcionar en términos de un modelo conceptual más centrado en la

aplicación, que incluye tipos con herencia, miembros complejos y relaciones.
• Las aplicaciones están libres de dependencias de codificación rígida de un motor de datos o
de un esquema de almacenamiento.
• Las asignaciones entre el modelo conceptual y el esquema específico de almacenamiento
pueden cambiar sin tener que cambiar el código de la aplicación.
• Los desarrolladores pueden trabajar con un modelo de objeto de aplicación coherente que se
puede asignar a diversos esquemas de almacenamiento, posiblemente implementados en
sistemas de administración 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 validación de la
sintaxis en el momento de la compilación para consultas en un modelo conceptual.
El alumno debe consultar la información proporcionada por Microsoft para familiarizarse con el
tema consultando:
• Introducción: http://msdn.microsoft.com/es-es/library/bb386876.aspx
• Tutorial rápido: http://msdn.microsoft.com/es-es/library/bb399182.aspx
Para empezar a trabajar con Entity Framework, nos basaremos en un ejemplo partiendo desde
cero.

Ejemplo de creación de BD, conexión y manipulación 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 diseño sea similar al
formulario de la siguiente imagen, establezca el nombre del formulario a ListaAutosFrm.
Img. 42.- Diseño 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 aplicación.
Agregue otro nuevo formulario llamado DatosAutoFrm cuyo diseño será similar a:

Img. 43.- Diseño 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 “Número de serie”, “Marca”,
“Modelo” y “Color.”
o 1 TextBox llamado NumeroSerieTxt donde se ingresará el número 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 cargarán los datos del
propietario si este ya está registrado en la BD.
o 1 TextBox llamado ApellidosTxt donde se ingresarán 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 tamaño actual del formulario establézcalo como tamaño mínimo (MinimunSize) y tamaño
máximo (MaximunSize), establezca el botón predeterminado para aceptar el botón AceptarBtn
(AcceptButton) y el botón predeterminado para cancelar el botón CancelarBtn (CancelButton).
Crear la base de datos

En este ejemplo, utilizaremos una base de datos “basada en servicio” que agregaremos como
un elemento más de nuestro proyecto, para ello:

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 configuración de orígenes

datos el cual debemos cancelar ya que la base de datos aún está vacía.
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 instalación del SQL Server.
Img. 45.- Abrir la base de datos.

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 diseñador de tablas, de la misma
forma diseñaremos las tablas especificadas en el modelo relacional.
Img. 46.- Diseño 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
“Especificación de identidad” y cambie a Sí en Identidad, se autodefinirá el auto incremento en 1.
Img. 47.- Diseño de la tabla Propietarop.

Img. 48.- Diseño de la tabla Auto.
Crear las relaciones.

Solo la tabla Auto tiene 2 claves foráneas, para crear las relaciones, estando en el diseño de la
tabla Auto, haga clic en el botón “Relaciones” en la barra “Diseñador de tablas”.
Se abrirá la ventana “Relaciones de clave externa” sin ninguna relación, haga clic sobre el botón
“Agregar”, creará una nueva relación, en la parte lateral derecha seleccione especificación de
consultas y haga clic sobre el botón “…” señalado con el puntero del ratón en la siguiente imagen.
Img. 49.- Ventana de relaciones externas.

Abrirá la ventana donde especificaremos la relación, 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 foránea a relacionar como se muestra en la imagen de ejemplo.

Img. 50.- Crear la relación Auto.IdMarca a Marca.IdMarca.

Cree también la relación 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.

Abrirá el asistente de configuración del origen de datos.
Seleccione “Generar desde la base de datos”.
Img. 52.- Seleccionar el origen de los datos.

Seleccione la base de datos (automáticamente 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
conexión utilizando el asistente.
En esta ventana de configuración de la cadena de conexión, especificamos el nombre de la

cadena de conexión “BaseDatosEntities” cuyo resultado final será una clase con el mismo
nombre, a la que debemos instanciar para utilizar la fuente de datos.

Img. 53.- Configurar la cadena de conexión.

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.

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, automáticamente agrega elementos como “Propiedades de navegación” que
representan a los objetos a los cuales se tiene relación.
Ejemplo:
La entidad Auto tiene las propiedades de navegación 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
través de la propiedad de navegación Marca.
Supongamos que, se tiene el objeto llamado “unauto” y quiere saberse cuál es el nombre de su
marca, para ello se invoca:
unauto.Marca.Nombre;
De igual forma si se quiere saber cuál 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
están relacionados.
De esta forma se están utilizando las propiedades de navegación; para relacionar dos objetos a
través de una propiedad de navegación.
Supongamos que tenemos el objeto unauto y unamarca y queremos relacionarlos, la relación se
realizaría de esta forma:
unauto.Marca = unamarca;
O almacenando el valor de la clave primaria en el campo correspondiente:
unauto.IdMarca = unamarca.IdMarca;

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 través 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 conexión en para poder manipular la fuente de datos.
Nos situamos en el código de nuestro formulario y crearemos una instancia de nuestra clase
conexión (BaseDatosEntities).

public partial class ListaAutosFrm : Form

{
BaseDatosEntities BD = new BaseDatosEntities();
Creamos un método llamado CargarLista() cuya función 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 conexión
this.ListaDtg.DataSource = BD.Auto;
}
Generamos el evento Load de nuestro formulario en el cual llamaremos al método 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.

Img. 59.- Ejemplo ejecutándose y mostrando los resultados.
Como resultado observamos que nos carga todas las propiedades de la entidad Auto incluyendo
las propiedades de navegación que muestran el nombre del objeto relacionado.
Para cargar solo los datos: Número de serie, Nombre de la Marca, Modelo, Color, Nombre del
propietario necesitamos trabajar con tipos anónimos vistos en LINQ. Modificaremos nuestro
método CargarLista() que quedará así:

{

//cargar todos los registros de la tabla Auto a nuestro datagrid

//utilizando nuestro objeto conexión
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:

Img. 60.- Resultado de utilizar tipos anónimos.

Ahora procedemos a programar el botón 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 aplicación 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 conexión a la
bd y propiedad que permita establecer la clave del objeto a editar.
public partial class DatosAutoFrm : Form

{
//conexión a la BD
//objeto de la clase Auto

private Auto auto;
//campo que almacene el id del auto a editar (número de serie)

private string idauto;
//propiedad que reciba el número de serie del auto a editar

public string IdAuto
{
get { return idauto; }
set { idauto = value;
//llamar al método que cargue los datos del objeto

//en los controles

CargarDatos();
}
}
Implementar el método que cargue los datos del objeto en los controles del formulario.
//método que cargue los datos del objeto a los controles
private void CargarDatos()
{
//recuperar el objeto desde la base de datos
//cuyo número 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 método 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)

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 ningún 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 botón Aceptar para que guarde los datos ingresados.

{
//llamar al método 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 botón Cancelar para que solo cierre la ventana.
private void CancelarBtn_Click(object sender, EventArgs e)

{
this.Close(); //cerrar sin realizar otra acción
}
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

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 número 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.- Edición 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

Cuando el usuario presione el botón Eliminar, el registro seleccionado debe eliminase, para ello,
genere el evento Clic del botón:
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.- Edición 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 más.

Img. 63.- Ejemplo después 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 código que se encuentra dentro de
los métodos asociados a estos eventos. Lo mismo sucede cuando se especifica la propiedad de la
clase que debe mostrarse como opción (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 después 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();
}

else
{
//cargar los registros de la tabla Auto que están 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.

Img. 65.- Resultado al seleccionar una marca.
Al final se obtiene el ejemplo funcionando, el código de este ejemplo ha sido adjuntado a la

carpeta “Ejemplos” incluida en la carpeta de este manual.

Creación de reportes
Cuando una organización desarrolladora de software implementa una solución 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
información relevante y relativamente útil proveniente de una fuente de datos y tenerla disponible
en el momento requerido.
Esta información por lo general suele ser información estadística.
La información arrojada debe convertirse en un documento llamado Reporte o informe.
La función del usuario final es realizar su labor cotidiana apoyándose en la nueva herramienta que
se le ha proporcionado.
Img. 66.- Aplicación funcional con la que interactúa el usuario.
Durante la interacción con la aplicación, el usuario elige guardar la información para continuar con
su labor.
Img. 67.- Aplicación funcional con la que interactúa el usuario.

La información es almacenada en la fuente de datos del sistema, desde

la cual podrá ser recuperada y reutilizada.
La información almacenada está organizada en distintas tablas relacionadas.
Img. 68.- Tabla “Pacientes” de la aplicación.
Img. 69.- Tabla “Estudios” de la aplicación.
Img. 70.- Tabla “ServiciosRegistrados” de la aplicación.
Sin importar como el sistema almacena, organiza y procesa la información para generar el
resultado final, lo que quiere el usuario es visualizar la información lista para ser impresa o
guardada como documento.

Img. 71.- Visualización de reportes.
¿Qué hacen los desarrolladores?

La organización desarrolladora de software utiliza herramientas e implementa mecanismos que le
permitan obtener los datos y generar el informe.
• Consultas.
• Vistas
• Procedimientos almacenados.
• Métodos
• Herramientas para Diseñar 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 diseño de informes y los controles
ReportViewer, que le permiten agregar informes con todas las características a las aplicaciones
personalizadas. Los informes pueden contener datos tabulares, agregados y multidimensionales.
Los controles ReportViewer le permitirán procesar y mostrar el informe en la aplicación. Hay dos
versiones del control.
Para utilizar un control ReportViewer en la aplicación, debe saber cómo agregar el control al
formulario del proyecto, configurar el control para utilizar una definición de informe local o informe
de servidor, actualizar las referencias de orígenes de datos y comprobar e implementar los
informes y el control en la aplicación. Para obtener toda la información referente a la creación y
visualización de informes, consulte http://msdn.microsoft.com/es-
es/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
anónimos).
Pero para nuestra suerte, los reportes no aceptan tipos anónimos y mucho menos las propiedades
de navegación que tenemos en el modelo, eso impedirá que nuestro informe muestre los datos
que deseamos.

La solución es crear Vistas y Procedimientos almacenados en nuestra base de datos e importarlos

a nuestro modelo.
La vista podemos utilizarla también para cargar los datos en el datagridview y llenar el informe al
mismo tiempo, y el procedimiento almacenado para recuperar datos específicos y utilizarlo para
llenar el informe.
Otra solución para llenar el informe sería 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 Número de Serie del auto, nombre de la Marca, Modelo, Color y nombre
del Propietario.
El código 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 código sql para campos a devolver por el procedimiento almacenado serán los mismos que los
de la vista.
El código 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

Guarde el procedimiento almacenado y cierre las pestañas 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 diseño 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 pestaña 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.

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 función.

Abra el explorador de modelos (botón 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
importación de función.
Img. 74.- Explorador de modelos.
En la ventana que se muestra:

En Nombre de la importación de función: nombre de la función 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
información de función de columna.
En la ventana aparecerán 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 importación, haga clic en Finalizar.

Img. 75.- Importar procedimiento almacenado como función.

Ya con la vista y el procedimiento almacenado en nuestro modelo, guarde los cambios y cierre el
modelo, ahora procedemos a diseñar nuestros informes.
Crear formulario donde se mostrará el informe.
Agregue un nuevo formulario llamado InformeFrm al cual debe agregar el control ReportViewer.

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 diseñador de informes donde
empezaremos a agregar elementos al diseño.
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.

Se abrirá la ventana de configuración de la fuente de datos, en la cual especificamos el nombre

del DataSet para nuestro informe, en origen de datos, mostrará como única opción el nombre de
nuestra conexión 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 vacío 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.

Img. 80.- Localizar la clase para utilizar como origen de datos.
Agregue una nueva tabla al diseño del informe, arrastre los campos de Datos informe a las
columnas de la tabla.
Img. 81.- Diseñar el informe.

Puede agregar encabezado y pié de página para el informe, agregar título, y campos especiales
en el informe.
Guarde los cambios en el diseño y cierre el diseño del informe.
Vuelva al formulario que contiene el ReportViewer y asigne el informe creado.

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 público.
Img. 83.- Cambiar el modificador de acceso.
Ahora en nuestro formulario ListaAutosFrm, agregaremos un botón llamado ImprimirBtn.
Img. 84.- Agregar botón 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 método llamado CargarLista() para que deje de utilizar tipos anónimos y ahora
utilice nuestra vista vAuto y la misma vista llene el informe.


{

//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 también el código 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 también al informe ya que los campos devueltos por la vista y
el sp son los mismos, de lo contrario se tendría un error.
Ahora solo nos falta programar el botón ImprimirBtn para que muestre el reporte.
private void ImprimirBtn_Click(object sender, EventArgs e)

{
informe.ShowDialog();
}

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 están diseñados 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 relación 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 información y generar reportes.
Captura: Solo tiene permisos para registrar Altas y Editar.
A continuación se presenta una tabla de ejemplo donde se especifican con más detalles los
permisos de cada rol.
Permisos / ROL Administrador Captura Consultas

Administrar
usuarios X
Crear Registros X X
Editar Registros X X

Eliminar Registros X
Realizar Consultas X X
Generar Reportes X X
Usuarios
Los usuarios se identifican con un nombre y una contraseña para tener acceso a una aplicación.
A los usuarios se les asignan roles dentro del sistema.
A continuación se presenta una tabla de ejemplo donde se especifican con más detalles los roles
de cada usuario.
Roles / Usuarios Pablito Pepe Pedro Petra
Administrador X
Captura X X
Consultas X X
Implementar Roles y Usuarios en una aplicación.
Autentificación.
La autentificación es uno de los conceptos clave que deben implementarse en aplicaciones
seguras.
La autentificación 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 (anónimos) 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 aplicación de Windows debe realizarse utilizando clases
que interactúan con el sistema operativo (API).
Con la API pueden utilizarse las credenciales de usuario del sistema operativo Windows.
O crear un método propio de autentificación de usuarios en la aplicación a través de una ventana

de inicio de sesión (login).
En una aplicación el usuario autentificado se le denomina Principal.

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 información 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 más registros a la tabla.
Img. 87.- Agregar algunos registros a la tabla
Agregue la tabla Usuario al Modelo.
Diseñe un formulario de inicio de sesión en el proyecto.

Img. 88.- Diseño del formulario de inicio de sesión.

Genere el código del formulario donde el código del formulario empiece:
//agregar espacios de nombre necesarios

using System.Security.Principal;
using System.Threading;
namespace EjemploEDM
{
public partial class LoginFrm : Form
{
//conexión a la BD
//variables necesarias para la sesión
GenericIdentity Identidad; //Crear una identidad genérica (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 botón Aceptar donde se comprobaran los datos ingresados por el
usuario con los almacenados en la base de datos, si son válidos, se creará la sesión y se asociara
el usuario con el proceso (aplicación).

{
//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

//if(datosusuario.Activo == true)
//{
//inicializar el usuario (sesión)
//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 aplicación.

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 aplicación se termina
ventanaprincipal.ShowDialog();
//cuando el usuario cierre la ventana principal, login también se cierra

this.Close();
}else
MessageBox.Show("Solo los administradores tienen acceso.", "Aplicación
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.", "Aplicación 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"))
{

MessageBox.Show("No tiene privilegios para acceder a este modulo.",

"Aplicación 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 método
Main().
static void Main()

{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new LoginFrm());
}
Ejecute la aplicación 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.

Img. 91.- Ingresando con usuario cuyo rol es Administrador.
Conclusión
Este documento que he elaborado ha sido la base para que los estudiantes a quienes he
impartido estos temas vayan adentrándose al a veces complejo mundo de la programación,
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 más que agregar, considero que este documento ayude a más estudiantes en su aprendizaje.
Alfonso Felipe Lima Cortés

www.afelipelc.mx
@afelipelc

Desarrollo de Aplicaciones Windows Forms en PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Desarrollo de Aplicaciones Windows Forms en PDF

Cargado por

Copyright:

Formatos disponibles

Desarrollo de

En este documento comparto información que ayude a los

Alfonso Felipe Lima Cortés

www.afelipelc.mx A. Felipe Lima Cortés Página 1 de 77

Crear el modelo conceptual de datos .......................................................................................................... 44

www.afelipelc.mx A. Felipe Lima Cortés Página 2 de 77

Diseño y desarrollo de aplicaciones

En el cuadro de herramientas se encuentran todos

La lista completa de controles que pueden utilizarse

Img. 1.- Cuadro de herramientas.

www.afelipelc.mx A. Felipe Lima Cortés Página 3 de 77

En la documentación técnica de cada control encontramos

Algunas propiedades generales de los controles

Consulte la lista completa de controles y acceda a toda la documentación de cada control

Asignar nombres a los controles

www.afelipelc.mx A. Felipe Lima Cortés Página 4 de 77

• El formulario incluye los controles Label,

Img. 3.- Vista previa del ejemplo a diseñar.

Recuperar datos de los controles y mostrarlos en mensajes:

private void AceptarBtn_Click(object sender, EventArgs e)

Para recuperar o establecer información a un control (invocar propiedades, métodos y eventos)

www.afelipelc.mx A. Felipe Lima Cortés Página 5 de 77

this.NombreTxt.Focus() NombreTxt.Focus() Se está invocando al método Focus del control.

En el código mostrado en Ejemplo1, la instrucción MessageBox.Show("Hola " + this.NombreTxt.Text);

Al ejecutar el ejemplo, ingresar un nombre en el cuadro de texto y hacer clic en aceptar, el

Img. 4.- Ejecutando el ejemplo. Img. 5.- Resultado del

En una aplicación de Windows Forms para

Utilizar este control es bastante sencillo,

www.afelipelc.mx A. Felipe Lima Cortés Página 6 de 77

private void primerEjemploTsmi_Click(object sender, EventArgs e)

static void Main()

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

www.afelipelc.mx A. Felipe Lima Cortés Página 7 de 77

Img. 7.- Formulario con el control MenuStrip y

Proyecto con múltiples formularios

• Para agregar nuevas ventanas

www.afelipelc.mx A. Felipe Lima Cortés Página 8 de 77

Img. 8.- Excepción generada en tiempo de ejecución, “No se puede

Controlar excepciones de forma general.

private void EjemploControlExcepciones()

www.afelipelc.mx A. Felipe Lima Cortés Página 9 de 77

Img. 9.- Mensaje mostrado al

Controlar por tipo de excepción.

private void EjemploControlExcepciones()

El bloque de código anterior controla la excepción de tipo DivideByZeroException en el método

Img. 10.- Mensaje mostrado al generarse la

www.afelipelc.mx A. Felipe Lima Cortés Página 10 de 77

Para ver la jerarquía de excepciones y toda su documentación técnica, visite la documentación

Programación Orientada a Objetos en C#

Las clases se definen con la palabra reservada class

<modificador de acceso> class <nombre de la clase>

<modificador de acceso>: determina el nivel de acceso a la clase o miembro de clase como:

public class Persona

public class Empleado : Persona

www.afelipelc.mx A. Felipe Lima Cortés Página 11 de 77

Donde Empleado hereda todos los datos de la clase Persona.

La sintaxis para crear un objeto es:

Persona nuevapersona = new Persona();

Para más información y ejemplos, consulte la documentación oficial

public class Persona

www.afelipelc.mx A. Felipe Lima Cortés Página 12 de 77

//campos que almacenan los datos de la persona

La sintaxis para definir una propiedad es: