introduccion al desarrollo de aplicaciones en c#

Curso C# por Eduardo Carrillo Salvatierra

Eduardo Carrillo Salvatierra Enseñanza de desarrollo Invenio

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



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

Form2 f2 = new Form2(); 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.

Form2 f2 = new Form2(); 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 System; using System.Collections.Generic; using System.Linq; using System.Text; using 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: Console.WriteLine("el numero ingresado es 2"); break; case 3: Console.WriteLine("el numero ingresado es 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_name\\SQLEXPRESS;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_name\\SQLEXPRESS;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 { this.InitConnection(); 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 { this.close_connection();



} } public void update_from_datos_table(int new_tel,string new_correo,int new_id,int tel, int id) { try { this.InitConnection(); string sql = "update datos set tel=@new_tel,correo=@new_correo,id=@new_id where tel=@tel and id=@id;"; SqlCommand cmd = new SqlCommand(sql.ToString(), conn); cmd.CommandType = CommandType.Text; cmd.Parameters.AddWithValue("@new_tel", new_tel); cmd.Parameters.AddWithValue("@new_correo", new_correo); cmd.Parameters.AddWithValue("@new_id", new_id); cmd.Parameters.AddWithValue("@tel", tel); cmd.Parameters.AddWithValue("@id", id); cmd.ExecuteNonQuery(); } catch (Exception ex) { MessageBox.Show(ex.Message); } finally { this.close_connection(); } } public void insert_into_datos_table(int tel, string correo, int id) { try { this.InitConnection(); string sql = "insert into datos (tel,correo,id) values(@tel,@correo,@id);"; SqlCommand cmd = new SqlCommand(sql.ToString(), conn); cmd.CommandType = CommandType.Text; cmd.Parameters.AddWithValue("@tel", tel); cmd.Parameters.AddWithValue("@correo",correo); cmd.Parameters.AddWithValue("@id", id); cmd.ExecuteNonQuery(); } catch (Exception ex) { MessageBox.Show(ex.Message); } finally { this.close_connection(); }

}

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.fill_the_dt_grid(); 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.fill_the_dt_grid(); 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.ToString()); int tel = Convert.ToInt32(dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[0].Value.ToString()); DialogResult dialogResult = MessageBox.Show("desea borrar el registro seleccionado", "pregunta", MessageBoxButtons.YesNo); if (dialogResult == DialogResult.Yes) { this.m.delete_from_datos_table(id, tel); } this.fill_the_dt_grid(); } 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 = dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[1].Value.ToString();



this.modal_frm.txt_id_val = dataGridView1.Rows[dataGridView1.CurrentRow.Index].Cells[2].Value.ToString(); 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:\Users\eduardo\Documents\Visual Studio 2012\Projects\mdi2\mdi2\CrystalReport1.rpt”); ReportDocument crystal_rpt = new ReportDocument(); crystal_rpt.Load(rpt_path); crystal_rpt.SetDatabaseLogon(“chama”, “1234”, “EDUARDOCARRILLO\\SQLEXPRESS”, “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:\Users\eduardo\Documents\Visual Studio 2012\Projects\mdi2\mdi2\CrystalReport1.rpt"); ReportDocument crystal_rpt = new ReportDocument(); crystal_rpt.Load(rpt_path); crystal_rpt.SetDatabaseLogon("user", "1234", "SERVERNAME\\SQLEXPRESS", "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#

Technology