introduccion al desarrollo de aplicaciones en c#

Curso C# por Eduardo Carrillo Salvatierra

Contenidos
Introducción al desarrollo de aplicaciones de Windows form en c# .................................................. 2
Capítulo 1: introducción c#. ........................................................................................................... 2
Capítulo 2: propiedades de diseños de formularios .................................................................. 4
Capítulo 3 Formularios MDI ............................................................................................................. 7
Capítulo 4: variables y Constantes. ............................................................................................ 12
Capítulo 4: estructuras de control. ............................................................................................. 14
Capítulo 5: conexión a base de datos. ....................................................................................... 20
Capítulo 6. Tareas comunes con gestión de tablas (insert,update,delete)....................................... 24
Capítulo 7.Generacion de reportes en c# y crystal reports. ............................................................. 33

Eduardo Carrillo Salvatierra
Enseñanza de desarrollo Invenio


Introducción al desarrollo de aplicaciones de Windows form en c#
Capítulo 1: introducción c#.
Creación de nuestra primer aplicación de Windows form en c#.





Abrimos visual estudio 2012 y en la parte superior izquierda damos en archivo>nuevo->proyecto->visual c# y seleccionamos aplicación de Windows form en el
lado derecho y le ponemos como nombre hola_mundo.
se nos abrirá un formulario, ahora necesitamos visualizar las herramientas que
tenemos disponibles para el desarrollo.
En las opciones del menú superior damos en ver->cuadro de herramientas
(clt+alt+x).
Arrastramos un botón a nuestro formulario y en las propiedades del botón le
cambiaremos el texto a mostrar (propiedad text) como por ejemplo primer
botón.

Ahora damos doble clic sobre el botón para dirigirnos a su método disparado en el
evento clic del mismo. Nos aparecerá un código parecido a al siguiente.
private void button1_Click(object sender, EventArgs e)
{
}

Este es el método que se dispara cuando se da clic en el botón y como vemos recibe dos
parámetros el primero es un objeto y se refiere al objeto que disparo el evento el cual
contiene todas las propiedades del objeto en este caso el botón, el segundo se refiere al
evento en si en este caso el evento clic del botón.
Ahora agregaremos un simple mensaje de tipo alerta y un mensaje de consola al dar clic
en el botón quedando de la siguiente manera.
private void button1_Click(object sender, EventArgs e)
{
MessageBox.Show("hola mundo desde C#");
Console.WriteLine("mi primer mensaje en consola c#");
}

Como verán en el contexto anterior me referí un mensaje de tipo alerta y es que las
aplicaciones tienes diferentes tipos de mensajes como alerta, advertencia, error,
información.
Ahora corremos nuestra aplicación presionando la tecla f5 o bien en la opción iniciar
con un icono verde.
Para poder ver el mensaje en consola vamos a la parte inferior y damos clic en
resultados.


Ahora agregaremos a nuestra aplicación un mensaje de advertencia indicando al usuario
si en realidad desea cerrar la aplicación.
Habiendo ya detenido la ejecución de nuestra aplicación en la opción detener
depuración o bien presionando f5 nuevamente. Damos clic en el formulario
asegurándonos de no dar clic en ningún otro objeto sino en el formulario.
Nos dirigimos a la derecha y damos clic en el icono de un rayito el cual hace referencia a
los eventos del objeto.

Y de las propiedades de comportamiento damos doble clic al lado derecho de
FormClosing esto automáticamente nos creara el método que será disparado en el
evento close del formulario, mostrándonos un código como el siguiente.
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
}

Ahora nuestro método nos quedara con el siguiente código para que pregunte al usuario
si desea cerrar el formulario.

private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
const string message =
"Esta seguro que desea cerrar el formulario?";
const string caption = "cerrar formulario";



var result = MessageBox.Show(message, caption,
MessageBoxButtons.YesNo,
MessageBoxIcon.Question);
if (result == DialogResult.No)
{
e.Cancel = true;
}
}

Corremos nuestra aplicación y damos clic en la x para disparar el evento y vemos que
nos pregunta si en realidad deseamos cerrar el formulario.
Y como vemos en la estructura de control que hemos agregado si damos clic en la
opción no el evento no ejecutara su acción por defecto ya que lo estamos cancelando.

Capítulo 2: propiedades de diseños de formularios
En todo tipo de aplicación existen propiedades tanto de diseño como lógicas, en este
capítulo veremos algunas de las propiedades comunes de diseño en formularios C#.
Creamos una nueva aplicación de Windows form c#, nos crea un formulario inicial por
defecto ahora vamos a ver->cuadro de herramientas, para mostrar las herramientas que
tenemos disponibles para usar en nuestros formulario.



Para este ejemplo y mostrar algunas propiedades básicas agregamos un botón desde el
cuadro de herramientas.

Entre las propiedades principales están la apariencia del mismo: color de fondo, imagen
de fondo tipo de letra, estilo de bordes y colores de los mismos, cursor a mostrar el
evento hover del elemento, color de texto, alineación de texto, padding(espacio entre
texto y borde del control) ,tamaño mínimo y tamaño máximo, entre otras propiedades
más.
Una de las propiedades muy comunes es Anchor por ejemplo si le asignamos al botón un
archor top left cuando redimensionemos nuestro formulario él se acomodara arriba a la
izquierda tomando como referencia el elemento padre.
La siguiente es Dock la cual permite que un control abarque todo el ancho o el largo de
su contenedor dependiendo de la posición que escojamos



Dock Bottom

Algunas propiedades de textbox:
Unas de las propiedades de las cajas de texto es el texto multilinea propiedad la cual
nos permite escribir múltiples líneas en un textbox, esta viene deshabilitada por
defecto, cuando trabajamos con esta propiedad también podemos agregar un scrollbar
al textox para cundo el contenido excede el tamaña del contenedor.
Para habilitar la opción multilinea en un textbox en propiedades en las opciones de
comportamiento encontramos la opción multilinea la pasamos a true y en las
propiedades de apariencia la opción scrollbar la pasamos a both para que se agregue
cuando el texto exceda el contenido. Esta opción nos puede ser útil para cuando un
campo de un formulario requiere de mucho texto.


Algunas propiedades de Combobox:
Una de las propiedades generales de un combobox es la que su contenido no sea editable
esto para que por ejemplo cuando lo llenamos desde una base de datos no sea editable
para eso vamos a su propiedad dropDownStyle y lo pasamos a dropDownList.

Capítulo 3 Formularios MDI
Que son formularios MDI: Un formulario MDI es un formulario el cual es padre de otros.


Para crear una aplicación MDI crearemos nuestro formulario principal en
visual estudio 2012 y vamos a la propiedad del formulario llamada
isMdiContainer y la pasamos a true. Ahora vemos como la apariencia del
formulario cambia un poco, buscamos la propiedad WindowStrate y
seleccionamos Maximized esta propiedad nos abre el formulario
maximizado cuando lo iniciamos.





A continuación crearemos el menú principal buscamos en la barra de
herramientas un menuStrip y lo arrastramos hacia el formulario le agregamos
unas cuantas opciones, como opción principal creamos la opción inicio y como
sub opción de ella form2 y form3 agregamos la opción ventana como
independiente quedándonos de la siguiente manera.


El fin de este menú es que cuando escojamos la opción form2 nos habrá un segundo
formulario y un tercero con la opción3 y en la opción ventana se agreguen las ventanas
que se encuentran abiertas.
A continuación le indicaremos al formulario cual es el menú principal esto con el fin de
agregar los menús hijos al menú padre de manera dinámica.


Entonces seleccionamos el formulario principal y buscamos la propiedad
MainMenuStrip y seleccionamos menuStrip1 o bien el nombre que tenga asignado
nuestro menú principal.



Ahora seleccionamos el menustrip y vamos a su propiedad MdiWindowListItem y
seleccionamos ventana para que se agreguen las ventanas abiertas de manera
dinámica.



Esto hará que las ventanas se agreguen en el menú ventana y así navegar sobre ellas.



Ahora vamos a proyecto->agregar Windows form y agregamos dos form2 y form3
Nos dirigimos al primer formulario y damos doble clic en la opción de menú
form3.

Agregamos el siguiente fragmento de código para abrir al tercer formulario
Form3 f3 = new Form3();
f3 = this;
f3.Show();



Hacemos el mismo paso para para el segundo formulario
f2.MdiParent = this;
f2.Show();



Ya podemos correr nuestra aplicación y en el menú del formulario principal
seleccionar form2 y después form3 y ver como se abren respectivamente. Y si
damos clic en ventana vemos como se agregaron las ventanas abiertas al menú.




En el form3 agregamos un menustrip y asignamos unas cuantas opciones.
Seleccionamos el menuStrip y en la propiedad layoutStiyle asignamos flow.



Recuerden que esto lo hacemos en el menú del formulario 3 esto es para que el espacio
que el menú ocupa desaparezca cuando abrimos el formulario y ese menú se agregue al
del formulario principal.








Corremos nuestra aplicación
Ahora cuando abrimos el formulario 3 vemos como el menú del formulario 3 se
agregó al menú del formulario principal al final.
Si deseamos que el menú no se integre al final sino en cierto índice modificamos
su propiedad mergeAction pasándola a insert y en merge index seleccionamos el
índex deseado.
Como podemos notar nuestros formularios salen arriba a la izquierda lo que
haremos cera centrarlos con respecto a su contenedor.
Usaremos el siguiente método para que centre los formularios.

protected Point center_element(Control parent, Control child) {
int x=((int)parent.Location.X) + ((parent.Width - child.Width) / 2);
int y=((int)parent.Location.Y) + ((parent.Height - child.Height) / 2);
return new Point(x,y);
}



Ahora después de la última línea agregamos el siguiente fragmento.

Quedando de la siguiente manera.
f2.MdiParent = this;
f2.Show();
f2.Location = center_element(this, f2);

Hacemos lo mismo para el tercer formulario.



Capítulo 4: variables y Constantes.
¿Qué es una variable?
Es un espacio en el sistema que almacena un valor.
Tipos de variables:
A continuación unos de los tipos de variables más comunes en c#.
String,int,double.
Ámbito de las variables:
El ámbito de una variable en si es el tipo de acceso que tiene o bajo que circunstancias
puede ser accedida.
Ejemplos:
Variables





public: Son accesibles y modificables en toda la clase y desde una instancia o
herencia
Private: Son accesibles en toda la clase pero no pueden ser accesibles desde una
instancia ni herencia.
protected: Son accesibles solo a una instancia de la clase directamente:
static: Son accesibles sin necesitad de instanciar la clase ni heredarla y su ideal
es asignarle valores que no cambien en toda la aplicación. Un ejemplo de una
variable estática puede ser un string de conexión.

¿Qué es una constante?
Es un valor en memoria que se declara y asigna un valor una única vez y su valor no
puede cambiar más. Las contantes tienen tipos al igual que las variables ejemplo string
doublé int dependiendo del tipo de valor que valla a almacenar.
Un muy buen uso de una constante pueden ser las configuraciones de la aplicación de no
deben cambiar en toda la ejecución del programa, por ejemplo podríamos almacenar el


nombre de nuestra aplicación en una constante o podríamos almacenar rutas en una
constante.
Ejemplo de uso creamos una nueva aplicación de consola en c# y le ponemos el nombre
deseado agregamos dos clases una la llamaremos example y la otra la llamaremos
secondary.
A continuación el código de la clase example.
using
using
using
using
using

System;
System.Collections.Generic;
System.Linq;
System.Text;
System.Threading.Tasks;

namespace ConsoleApplication1
{
class example
{
public static int age = 0;
private string _name = "";
protected string last_name="";
//constructor de la clase recibe tres parametros opcionales y asigna a las
variables de la clase el
//valor de los parametros que recibe.
public example(int age=0,string name="",string last_name="") {
example.age = age;
this._name = name;
this.last_name = last_name;
}
//establesca y obtenga el valor de la variable privada name
public string name { get; set; }
public string lastname { get { return this.last_name; } set { this.last_name
= value; } }
}
}

En la clase secondary agregamos el siguiente método solamente.
public

string get_last_name(){
return this.last_name;
}



Y en la clase Program el siguiente código.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication1
{
class Program
{
secondary s = new secondary();
static void Main()
{
Program p = new Program();
p.run_the_example();
}
void

run_the_example() {
Console.WriteLine("ingrese su nombre ");
s.name = Console.ReadLine();
Console.WriteLine("ingrese su primer apellido ");
s.lastname = Console.ReadLine();
Console.WriteLine("ingrese su edad ");
example.age = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("su nombre es "+s.name+" su apellido es
"+s.get_last_name()+" su edad es "+example.age);
Console.ReadLine();
}
}
}

Corremos la aplicación para ver los resultados.

Capítulo 4: estructuras de control.
A continuación veremos ejemplos de estructuras de control en c#.

If: se basa en una ejecución con un condicional si se cumple se ejecuta una acción y si
no otra o bien pueden haber más evaluaciones.



Ejemplo.
static void Main()
{
int nota = 85;
if (nota >= 75) {
Console.WriteLine("usted a aprobado el curso");
}
else if (nota < 75 && nota >= 50)
{
Console.WriteLine("usted ha reprobado el curso pero puede ir a
ampliación");
}
else {
Console.WriteLine("usted no tiene derecho de ir a ampliación");
}
}

Este fragmento de código funciona de la siguiente manera.





Si el valor de la variable nota es mayor o igual a 75 la persona ha aprobado el
curso y no evalúa las demás opciones porque ya se cumplió la primera.
Si el valor de la variable nota es menor a 75 y mayor o igual que 50 el estudiante
reprobó el curso pero puede ir a ampliación. No evalúa el else porque está ya
encontró una ejecución verdadera.
De no encontrar verdadero ninguno de los primeros condicionales ejecutara la
última acción por defecto.

Practica
Realizar una aplicación en c# de validación de registro de usuario en un sistema el cual
verifique la validez de los siguientes campos: usuario, contraseña, confirmación de
contraseña, carrera (desplegadas en un combobox), correo.
Verificar que cuando el usuario de en el botón de enviar valide si los campos están
vacíos o si su contenido es válido, el ejemplo se encuentra en la siguiente imagen.



Switch: La instrucción switch es una instrucción de control que controla múltiples
selecciones y enumeraciones pasando el control a una de las instrucciones case de su
cuerpo cada instrucción debe de tener un break para que se detenga su ejecución.
Ejemplo de uso:
static void Main()
{
int numero = 0;
Console.WriteLine("ingrese un numero entre el 1 y el 3");
numero = Convert.ToInt32(Console.ReadLine());
switch (numero) {
case 1:
Console.WriteLine("el numero ingresado es 1");
break;
case 2:
break;
case 3:
break;
default:
Console.WriteLine("el numero ingresado no esta entre las opciones
disponibles");
break;
}
Console.ReadKey();
}

Practica
Cambiar la validación del formulario de login en la parte de correo y contraseña,
utilizando swith para validar si se encuentra vacío o su contenido no es válido.


While: La instrucción while ejecuta una instrucción o un bloque de instrucciones
repetidamente hasta que una expresión especificada se evalúa como false.

Ejemplo de uso: aplicación de consola que calcula la suma de compras realizadas por
una persona.
static void Main()
{
bool salir = false;
int valor_compra = 0;
int total = 0;
while(!salir){
Console.WriteLine("ingrese el valor de la compra a sumar");
valor_compra = int.Parse(Console.ReadLine());
total += valor_compra;
if (valor_compra <=0) {
Console.WriteLine("la suma de sus compras es " + total);
Console.WriteLine("para salir precione 0 para continuar
cualquier otra tecla");
if (int.Parse(Console.ReadLine()) == 0)
{
salir = true;
}
}
}
}

Practica
1. La





siguiente se llama la conjetura de ULAM en honor del matemático S. Ulam:
Comience con cualquier entero positivo
Si es par, divídalo entre 2; si es impar, multiplíquelo por 3 y agréguele 1.
Obtenga enteros sucesivamente repitiendo el proceso.
Al final, obtendrá el número 1, independientemente del entero inicial. Por
ejemplo, cuando el entero inicial es 26, la secuencia será: 26, 13, 40, 20, 10, 5,
16, 8, 4, 2, 1.

2. Haga un programa en consola que lea un entero positivo y obtenga e imprima la
sucesión de ULAM.



DO While: Su diferencia básica con el ciclo while es que la prueba de condición es hecha
al finalizar el ciclo, es decir las instrucciones se ejecutan cuando menos una vez porque
primero ejecuta las instrucciones y al final evalúa la condición.
Ejemplo:
string secreta;
string palabra;
Console.WriteLine("ingrese la palabra secreta");
secreta = Console.ReadLine();
do
{
Console.WriteLine("vuelva a introducir la palabra secreta");
palabra = Console.ReadLine();
if (palabra != secreta)
Console.WriteLine("palabra incorrecta");
} while (palabra != secreta);
Console.WriteLine("Palabra Correcta");
Console.ReadKey();

For: Es un bucle el cual funciona con un límite el cual ya se sabe.
Ejemplo.
static void Main()
{
for(int i=0;i<10;i++){
Console.WriteLine(i);
}
}

Practica
1) Hacer un programa en consola tal que dado como datos los sueldos de los 5
trabajadores de una empresa, obtenga el total de nómina de la misma.
2) Haga un programa tal que dado como datos N números enteros, obtenga el
número de ceros que hay entre estos números.
3) Se dice que un entero positivo N es un número primo si los únicos enteros
positivos que lo dividen exactamente son 1 y N. Haga un programa que admita un
número M y obtenga y cuente todos los números primos que sean menores a M

El siguiente seria el resultado si ingresáramos el número 50.
47 es primo
43 es primo
41 es primo
37 es primo
31 es primo
29 es primo
23 es primo
19 es primo
17 es primo
13 es primo
11 es primo
7 es primo
5 es primo
3 es primo
2 es primo
1 es primo

Arreglos.
Los arreglos son variables las cuales pueden almacenar múltiples valores y pueden tener
varias dimensiones cuando tienen más de una dimensión usualmente se les llama
matrices. En este caso solamente veremos arreglos unidimensionales.
Ejemplo.
1) Declarar un arreglo e inicializarlo de una vez.
string[] names = new string[3] {"Matt", "Joanne", "Robert"};
for(int i=0;i<names.Length;i++){
Console.WriteLine(names[i]);
}
2) Declarar un arreglo vacío y llenarlo.
int[] numbers = new int[10];
for(int i=0;i<numbers.Length;i++){
numbers[i]=numbers.Length-i;
Console.WriteLine(numbers[i]);
}



Practica

1) Calcule el aumento de sueldo para un grupo de empleados de una empresa
teniendo en cuenta el siguiente criterio:
 Si el sueldo es inferior a $1000: Aumento 15%
 Si el sueldo es mayor o igual a $1000: Aumento 12%
Imprima el sueldo nuevo del trabajador y el total de nómina de la empresa
considerando este nuevo aumento.

2) Realizar una aplicación en consola en c# la cual ordene el siguiente arreglo de
menor a mayor.
int[] arr = new int[] { 3,1,5,7,9,2,11,23,14,4,18};
3) Hacer un programa que lea diez valores enteros en un array desde el teclado y
Calcule y muestre: la suma, el valor medio, el mayor y el menor.
4) Hacer un programa que lea diez valores enteros en un array y los muestre en
Pantalla. Después que los ordene de menor a mayor y los vuelva a mostrar, después
que Calcule el promedio de números pares y los muestre, después crear e imprimir otro
arreglo a partir del existente pero los valores de este serán al azar y
Finalmente que ordene el arreglo principal de mayor a menor.

Capítulo 5: conexión a base de datos.
Existen varias formas para extraer datos desde nuestras bases de datos a una aplicación
en c# que en si se resumen en crear conexiones visuales con el asistente o por código
nosotros abarcaremos las más usuales pero a fin escogeremos una.


Crear la conexión desde el archivo app.config este archivo se crea
automáticamente en las aplicaciones de Windows forms y es usado para declarar
variables utilizadas en la misma aplicación por ejemplo conexiones o
configuraciones de la aplicación. La conexión la podemos crear de manera visual
para hacerlo vamos al menú proyecto->Agregar Nuevo origen de datos->base de
datos clic en siguiente->conjunto de datos clic en siguiente clic en nueva
conexión y nos aparecerá una pantalla como la siguiente en donde agregaremos
la información de nuestro servidor en este caso nos conectaremos a una base de
datos de MSSQLSERVER.



Quedándonos como en la siguiente imagen.

De más está dar en probar conexión ya que si no hubiera conexión no cargaría las bases
de datos.


Damos clic en aceptar.







Guardamos la conexión.
Incluimos todo tablas, vistas, funciones y procedimientos almacenados.
Damos en finalizar.
Ahora agregamos una clase y la llamaremos model aquí crearemos los métodos
que nos permitirán gestionar con la base de datos.

Agregamos en siguiente código.

class model
{
private SqlConnection conn;
//local server
private const string cn_local =
"Server=server_nameSQLEXPRESS;Database=test;User Id=user;"+
"Password=****;";
//connection created with the visual helper
string cn_on_proyect_properties =
mdi2.Properties.Settings.Default.sqlexpressConnectionString;
//init the database connection
private void InitConnection()
{
this.conn = new SqlConnection();
this.conn.ConnectionString = cn_on_proyect_properties;
this.conn.Open();
}
//close the database connection
public void close_connection()
{
this.conn.Close();
}
}





Por lo pronto dejaremos nuestra clase solo con estos métodos más adelante
iremos agregando otros.
Ahora creamos una tabla en nuestra base de datos y le insertamos unos cuantos
registros.
Ahora agregamos un datagrid a nuestro formulario y en la esquina superior
derecha damos en seleccionar datasource para cargar una tabla en él y
seleccionamos la tabla que queremos mostrar, deberá de mostrar los nombres de
los campos de la tabla.






Ahora corremos nuestra aplicación y deberá de cargar los datos de esa tabla.
Ahora aremos lo mismo pero de manera manual.

Capítulo 6. Tareas comunes con gestión de tablas (insert,update,delete)
En este capítulo manejaremos una tabla de la base de datos desde nuestra aplicación de
Windows form en c#, las tareas que realizaremos en esta son las más comunes en
cualquier aplicación insertar, actualizar y eliminar registros. Pues bien empezamos de
una vez.



Creamos una nueva aplicación de Windowsform en c# y la llamaremos
insert_update_delete por ejemplo.
Primero entenderemos un poco la estructura de la aplicación:
1) la aplicación cuenta con un formulario principal el cual carga todos los datos
de una tabla en específico al datagrid en este caso le hemos insertado dos
celdas por fila las cuales contienen los enlaces para actualizar e insertar
registros.
2) El caso es que cuando el usuario de clic en el enlace de actualizar un registro
este muestre un formulario modal en el cual carga los datos del registro
seleccionado.
3) El usuario podrá modificar los datos que se cargaron en ese formulario y ellos
deberán de actualizarse en la base de datos.
4) Cuando el usuario da clic en el enlace de eliminar deberá de preguntarle si
desea eliminar el registro seleccionado en caso que si eliminarlo.
5) Y por último tenemos un botón al lado derecho superior del datagrid un botón
el cual se encarga de insertar registros mostrando un formulario modal con
los campos necesarios para insertar el registro.

Pasos


Creamos una nueva aplicación de Windows Form en c# y la llamaremos
insert_update_delete por ejemplo.






Agregamos otro formulario además del que la aplicación crea por defecto
Al segundo formulario lo llamaremos frm_add_edit haciendo alusión a su
funcionalidad la cual es insertar y actualizar un registro.
Agregamos una clase al proyecto y la llamaremos model y le agregamos el
siguiente código.

class model
{
private SqlConnection conn;
//local server
private const string cn_local =
"Server=server_nameSQLEXPRESS;Database=test;User Id=user;" +
"Password=****;";
//init the database connection
private void InitConnection()
{
this.conn = new SqlConnection();
this.conn.ConnectionString = cn_local;
this.conn.Open();
}
//close the database connection
public void close_connection()
{
this.conn.Close();
}
}




Esta se encuentra casi igual que la del ejemplo anterior pero le quitamos la
variable que cargaba la conexión que estaba en el app.config
Remplazamos la información de la variable conexión de acorde a nuestro
servidor.

En este caso utilizaremos una tabla llamada datos la cual almacena información de
usuarios esta contiene 3 columnas nada más en el siguiente order :tel,correo ,id.




El campo id es int not null, el campo tel también y el campo correo es
varchar(50) not null la llave primary son los 3 campos.
Creamos esa tabla desde el sqlserver management estudio
En la clase model agregamos el siguiente método

public void fillDataGridView(DataGridView generic_dt, string command)
{
this.InitConnection();
DataTable dt = new DataTable();
SqlCommand sql_command = new SqlCommand(command, conn);
SqlDataAdapter da = new SqlDataAdapter(sql_command);
da.Fill(dt);
generic_dt.DataSource = dt;



generic_dt.AutoGenerateColumns = false;
generic_dt.AllowUserToAddRows = false;
generic_dt.ReadOnly = true;
this.close_connection();
}






Este método se encargara de llenar el datagrid
Creamos las siguientes instancias en el formulario principal.
Agregamos un datagrid al formulario principal desde el cuadro de herramientas
Creamos las siguientes instancias en el formulario principal.

model m = new model();
frm_add_edit modal_frm= new frm_add_edit();



Creamos también el siguiente método en el formulario principal.

private void fill_the_dt_grid()
{
this.m.fillDataGridView(dataGridView1, "select * from datos");
}



Creamos también el siguiente método el cual agregara los enlaces de actualizar
y eliminar.
void add_edit_and_delete_links()
{
DataGridViewLinkColumn Editlink = new DataGridViewLinkColumn();
Editlink.UseColumnTextForLinkValue = true;
Editlink.HeaderText = "Edit";
Editlink.DataPropertyName = "lnkColumn";
Editlink.LinkBehavior = LinkBehavior.SystemDefault;
Editlink.Text = "Editar";
dataGridView1.Columns.Add(Editlink);
DataGridViewLinkColumn Deletelink = new DataGridViewLinkColumn();
Deletelink.UseColumnTextForLinkValue = true;
Deletelink.HeaderText = "delete";
Deletelink.DataPropertyName = "lnkColumn";
Deletelink.LinkBehavior = LinkBehavior.SystemDefault;
Deletelink.Text = "Borrar";
dataGridView1.Columns.Add(Deletelink);
}




Agregamos unos cuantos registros a la tabla desde el sqlserver management
studio
En el evento load del formulario principal llamamos al método de carga del
datagrid y al que agrega los links de actualizar y eliminar.



private void Form4_Load(object sender, EventArgs e)
{
this.fill_the_dt_grid();
this.add_edit_and_delete_links();
}







Le insertamos unos cuantos registros a la tabla desde el management estudio de
sqlserver para mostrarlos en la aplicación.
Hasta ahora debemos de tener Nuestro datagrid de la siguiente manera al correr
la aplicación tomando en cuenta que fueron dos registros los que insertamos.

Detenemos la ejecución del programa.
Ahora agregamos el siguiente método en el formulario principal.

private bool IsANonHeaderLinkCell(DataGridView dtv,DataGridViewCellEventArgs
cellEvent)
{
if (dtv.Columns[cellEvent.ColumnIndex] is
DataGridViewLinkColumn &&
cellEvent.RowIndex != -1)
{ return true; }
else { return false; }
}



Este método nos permite detectar si el contenido al que se dio clic en la celda es
un link.



Agregamos los siguientes métodos en nuestra clase model.

public void delete_from_datos_table(int id, int tel) {
try
{
string sql = "delete from datos where id=@id and tel=@tel";
SqlCommand cmd = new SqlCommand(sql.ToString(), conn);
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue("@id", id);
cmd.Parameters.AddWithValue("@tel", tel);
cmd.ExecuteNonQuery();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
finally {



}
}
public void update_from_datos_table(int new_tel,string new_correo,int
new_id,int tel, int id)
{
try
{
string sql = "update datos set
tel=@new_tel,correo=@new_correo,id=@new_id where tel=@tel and id=@id;";
cmd.Parameters.AddWithValue("@new_tel", new_tel);
cmd.Parameters.AddWithValue("@new_correo", new_correo);
cmd.Parameters.AddWithValue("@new_id", new_id);
}
{
}
finally
{
}
}
public void insert_into_datos_table(int tel, string correo, int id)
{
try
{
string sql = "insert into datos (tel,correo,id)
values(@tel,@correo,@id);";
cmd.Parameters.AddWithValue("@correo",correo);
}
{
}
finally
{
}
}



Estos métodos se encargaran de borrar actualizar e insertar registros
respectivamente en la tabla datos.








Ahora vamos al que será nuestro formulario modal y le agregamos los campos de
la tabla y el botón.
Los textbox tienen los siguientes nombres respectivamente: txt_tel, txt_correo,
txt_id.

Ahora en el código de este formulario agregamos los siguientes métodos para
establecer los valores a los textbox desde el formulario principal ya que son
privados por lo tanto son inaccesibles desde el formulario principal.

//getter and setter for textbox
public string txt_tel_val{
get { return this.txt_tel.Text; }
set { this.txt_tel.Text = value; }
}
public string txt_correo_val{
get { return this.txt_correo.Text; }
set { this.txt_correo.Text = value; }
}
public string txt_id_val{
get { return this.txt_id.Text; }
set { this.txt_id.Text = value; }
}



Ahora vamos a las propiedades del botón y en Modifiers lo cambiamos a public
para que así sea accesible desde el formulario principal.



Ahora vamos a proyecto->propiedades->configuración y ahí agregamos la variable
booleana modal_opened en tipo seleccionamos bool, en Ámbito seleccionamos
aplicación y en valor false.





Vamos otra vez al formulario modal y en el evento FormClosed el siguiente
código.
insert_update_delete.Properties.Settings.Default["modal_opened"] = false;



Agregamos el siguiente método en nuestro formulario principal.

public void save_data(object sender, EventArgs e)
{
if (this.modal_frm.button1.Text == "actualizar")
{
int tel =
Convert.ToInt32(dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[0].Value);
int id =
Convert.ToInt32(dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[2].Value);
this.m.update_from_datos_table(int.Parse(this.modal_frm.txt_tel_val),
this.modal_frm.txt_correo_val, int.Parse(this.modal_frm.txt_id_val), tel, id);
this.modal_frm.Dispose();
this.modal_frm.Close();
insert_update_delete.Properties.Settings.Default["modal_opened"] =
false;
}
else if (this.modal_frm.button1.Text == "Guardar")
{
this.m.insert_into_datos_table(int.Parse(this.modal_frm.txt_tel_val),
this.modal_frm.txt_correo_val, int.Parse(this.modal_frm.txt_id_val));
this.modal_frm.Close();
insert_update_delete.Properties.Settings.Default["modal_opened"] =
false;
}
}

Este método se encargara de abrir el formulario de insertar y actualizar y ejecutar la
acción respectiva ya sea actualizar o insertar un registro llamando a los métodos de la
clase model creados previamente.


Agregamos el siguiente método en el formulario principal que nos permite
centrar el formulario secundario.

protected Point center_element(Control parent, Control child)
{
int x = ((int)parent.Location.X) + ((parent.Width - child.Width) / 2);
int y = ((int)parent.Location.Y) + ((parent.Height - child.Height) / 2);



return new Point(x, y);
}



Ahora seleccionamos el datagrid y en su evento CellContentClick lo dejamos de
la siguiente manera.

private void dataGridView1_CellContentClick(object sender,
DataGridViewCellEventArgs e)
{
if (this.IsANonHeaderLinkCell(dataGridView1, e))
{
string ref_val = "";
if (e.ColumnIndex == dataGridView1.ColumnCount - 1 || e.ColumnIndex
== dataGridView1.ColumnCount - 2)
{
//get the reference value
ref_val =
dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[0].Value.ToString();
if (e.ColumnIndex == dataGridView1.ColumnCount - 1)//delete
{
int id =
Convert.ToInt32(dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[2].Value.To
String());
int tel =
Convert.ToInt32(dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[0].Value.To
String());
DialogResult dialogResult = MessageBox.Show("desea borrar el
registro seleccionado", "pregunta", MessageBoxButtons.YesNo);
if (dialogResult == DialogResult.Yes)
{
this.m.delete_from_datos_table(id, tel);
}
}
else if (e.ColumnIndex == dataGridView1.ColumnCount - 2)//edit
{
if
(!insert_update_delete.Properties.Settings.Default.modal_opened)
{
this.modal_frm = new frm_add_edit();
this.modal_frm.button1.Click += new
System.EventHandler(this.save_data);
this.modal_frm.Show();
this.modal_frm.Location = center_element(this,
this.modal_frm);
insert_update_delete.Properties.Settings.Default["modal_opened"] = true;
//set the form fields values
this.modal_frm.txt_tel_val = ref_val;
this.modal_frm.txt_correo_val =



this.modal_frm.txt_id_val =
this.modal_frm.button1.Text = "actualizar";
}
}
}
}




Ahora agregamos un botón en la parte superior del datagrid y le ponemos como
texto Insertar registro el nombre se le puede dejar el que tiene por defecto.
Le agregamos el siguiente código al evento clic del botón.

if (!insert_update_delete.Properties.Settings.Default.modal_opened)
{
{
this.modal_frm = new frm_add_edit();
this.modal_frm.Show();
this.modal_frm.Location = this.center_element(this,
this.modal_frm);
insert_update_delete.Properties.Settings.Default["modal_opened"]
= true;
this.modal_frm.button1.Text = "Guardar";
this.modal_frm.button1.Click += new
System.EventHandler(this.save_data);
}
}



Ya podemos correr nuestra aplicación y dar clic en el botón de insertar registró y
debe de verse de la siguiente manera.




Insertamos unos cuantos registro
Los editamos





Eliminamos algunos también
Nuestra aplicación ya está funcional.

Practica



Agregar dos buscadores a la aplicación anterior por id y por correo.
Validar los campos de entrada de datos en los formularios.

Capítulo 7.Generacion de reportes en c# y crystal reports.
En este capítulo crearemos reportes de los datos mostrados en los datagrid los cuales
podrán ser exportados a pdf entre otros formatos.
Usaremos la misma aplicación anterior lo que haremos será agregarle la funcionalidad de
reportes.
Pasos.





Tomando en cuenta que ya tenemos instalado crystal reports en nuestra
computadora.
Agregamos un botón en el formulario principal el cual contiene el datagrid a este
botón le ponemos como texto reporte y como nombre btn_crystal_rpt.
Agregamos un nuevo formulario a nuestro proyecto y le ponemos como nombre
frm_crystal_rpt, en su propiedad WindowState seleccionamos maximized.
Agregamos un crystalReportViewer al formulario desde el cuadro de
herramientas.









Agregamos un crystal report a nuestra aplicación proyecto->agregar Nuevo
element->CrystalReport y le dejamos el nombre por defecto.
Seleccionamos la opción que dice como informe en blanco y damos en aceptar.
Nos creara una pantalla parecida a la siguiente

En las opciones de la izquierda vamos a campos de base de datos->asistente de
base de datos si no tenemos una conexión oledb creada vamos a la carpeta que
dice crear nueva conexión y seleccionamos OLEDB(ADO) y en el proveedor
seleccionamos sqlserver native client.







Damos en siguiente y llenamos los datos de nuestro servidor de sqlserver.
Damos en siguiente y luego en finalizar
Agregamos la tabla correspondiente al reporte como en la siguiente imagen.







Damos en Ok.
Ahora vamos a la parte superior izquierda y desplegamos el nodo de campos de la
base de datos y nos deberá de aparecer la tabla.
Desplegamos el nodo de la tabla y nos deberán de aparecer los campos de la
tabla.




Arrastramos cada uno de los campos de la tabla hacia la sección 3 detalle.
vamos al reporte y en el campo id damos clic derecho->dar formato al objeto,
hacemos lo mismo con el campo tel.



Esto es porque crystal report por defecto le agrega un separador de miles a los
campos numéricos pero eso en este caso no nos funciona ya que los campos son
id y número de teléfono y los queremos ver exactamente como están en la base
de datos.





En el formulario que abre damos en personalizar y quitamos el check que dice
separador de miles abajo podemos ver una muestra de cómo se vería un número.




Damos clic en aceptar.
Ahora vamos al frm_crystal_rpt y en las propiedades del crystalReportViewer1 en
modifiers lo cambiamos a public para que sea accesible desde el otro formulario.
Ahora vamos al código del formulario principal y agregamos el siguiente método.



Private void reporte(int param1 = 0, string param2 = “”)
{
frm_crystal_rpt frm_rpt = new frm_crystal_rpt();
string RutaDefecto =
System.Windows.Forms.Application.StartupPath.ToString();
string rpt_path = (@”C:UserseduardoDocumentsVisual Studio
2012Projectsmdi2mdi2CrystalReport1.rpt”);
ReportDocument crystal_rpt = new ReportDocument();
crystal_rpt.Load(rpt_path);
crystal_rpt.SetDatabaseLogon(“chama”, “1234”,
“EDUARDOCARRILLOSQLEXPRESS”, “test”);
frm_rpt.Show();
frm_rpt.crystalReportViewer1.ReportSource = crystal_rpt;




}

Lo llamamos en el evento clic del botón de reporte
Ya podemos correr nuestra aplicación y dar clic en el botón para generar el
reporte.











Ahora crearemos dos filtros para el reporte haremos que filtre datos por
id y/o por correo.
Vamos al reporte damos clic sobre el para que se aparezca el menú de
crystal report arriba.
Damos clic en la opción de menú crystal reports->explorador de campos.
Para poder ver el explorador de campos.
El explorador de campos debe aparecer en la parte izquierda ahí en
campos con parámetros clic derecho->nuevo le ponemos como nombre
id_param y el tipo escogemos número.
Creamos otro parámetro para correo este será de tipo cadena.
Vamos al reporte y sobre el reporte damos clic derecho->informe>formula de selección->registro.





Eso nos abrirá una pantalla como la siguiente.



Ahí dentro agregamos el siguiente código para que filtre esto permite que los
campos sean opcionales.

If {?id_param} =0 Then
{datos.correo} like {?correo_param} + "*"
else
{datos.id} ={?id_param} and {datos.correo} like {?correo_param} + "*"


Quedándonos como en la siguiente imagen.






Damos clic en guardar y cerrar.
Agregamos las dos cajas de texto en el formulario principal y las nombramos
txt_correo y txt_id.



Ahora el código del evento clic del botón de reporte queda de la siguiente
manera.
int id = 0;
if (txt_id.Text != "") {
id = int.Parse(txt_id.Text);



}
this.reporte(id,txt_correo.Text);




Esto permite que los campos sean opcionales.
El método reporte le remplazamos el contenido para que pase los parámetros a
la consulta.

private void reporte(int param1 = 0, string param2 = "")
{
frm_crystal_rpt frm_rpt = new frm_crystal_rpt();
string RutaDefecto =
System.Windows.Forms.Application.StartupPath.ToString();
string rpt_path = (@"C:UserseduardoDocumentsVisual Studio
2012Projectsmdi2mdi2CrystalReport1.rpt");
ReportDocument crystal_rpt = new ReportDocument();
crystal_rpt.Load(rpt_path);
crystal_rpt.SetDatabaseLogon("user", "1234", "SERVERNAMESQLEXPRESS",
"test");
CrystalDecisions.Shared.ParameterValues pval1 = new ParameterValues();
CrystalDecisions.Shared.ParameterValues pval2 = new ParameterValues();
ParameterDiscreteValue pdisval1 = new ParameterDiscreteValue();
pdisval1.Value = param1;
pval1.Add(pdisval1);
ParameterDiscreteValue pdisval2 = new ParameterDiscreteValue();
pdisval2.Value = param2;
pval2.Add(pdisval2);

crystal_rpt.DataDefinition.ParameterFields["id_param"].ApplyCurrentValues(pval1);
crystal_rpt.DataDefinition.ParameterFields["correo_param"].ApplyCurrentValues(pval2)
;
frm_rpt.Show();
frm_rpt.crystalReportViewer1.ReportSource = crystal_rpt;
}



Ya podemos correr la aplicación y probar la funcionalidad de los filtros.


introduccion al desarrollo de aplicaciones en c#

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (7)

Similar a introduccion al desarrollo de aplicaciones en c#

Similar a introduccion al desarrollo de aplicaciones en c# (20)

Último

Último (16)

introduccion al desarrollo de aplicaciones en c#