• Author / Uploaded
• mariuxipaolazea

Citation preview

UNIVERSIDAD TÉCNICA DE MACHALA FACULTAD DE INGENIERÍA CIVIL ESCUELA DE INFORMÁTICA CARRERA DE INGENIERÍA DE SISTEMAS

PORTAFOLIO DE LA ASIGNATURA

PROGRAMACIÓN I CURSO 6TO. SEMESTRE PARALELO “A” (PROMOCION#. 11)

ESTUDIANTE RESPONSABLE

HONORES CUN JENNIFER LISSETH DOCENTE RESPONSABLE

ING. MARIUXI PAOLA ZEA ORDOÑEZ, MG. SC.

PERIODO 2013 - 2014

MACHALA – EL ORO – ECUADOR

INDICE Contenido INDICE ............................................................................................................................................................. 2 SYLLABUS DE LA ASIGNATURA ............................................................................................................... 4 AUTORRETRATO ........................................................................................................................................ 18 CURRÍCULO ................................................................................................................................................. 19 UNIVERSIDAD TÉCNICA DE MACHALA ................................................................................................ 20 MISIÓN ....................................................................................................................................................... 20 VISIÓN ....................................................................................................................................................... 20 ESCUELA DE INFORMÁTICA ................................................................................................................... 21 MISIÓN ....................................................................................................................................................... 21 VISIÓN ....................................................................................................................................................... 21 PERFIL PROFESIONAL.......................................................................................................................... 22 DIARIO METACOGNITIVO ......................................................................................................................... 23 UNIDAD I: INTRODUCCIÓN A .NET ........................................................................................................ 24 Semana N° 1 Día 1: Clase 1 ................................................................................................................... 25 Semana N° 1 Día 2: Clase 2 ................................................................................................................... 27 Semana N° 1 Día 3: Clase 3 ................................................................................................................... 29 Semana N° 2 Día 1: Clase 4 ................................................................................................................... 33 UNIDAD II: BASE DE DATOS SQL Y ADO .NET ................................................................................... 42 Semana N° 3 Día 1: Clase 5 ................................................................................................................... 43 Semana N° 4 Día 1: Clase 6 ................................................................................................................... 51 UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C# .. 60 Semana N° 4 Día 2: Clase 7 ................................................................................................................... 61 Semana N° 4 Día 3: Clase 8 ................................................................................................................... 85 Semana N° 5 Día 1: Clase 9 ................................................................................................................... 93 Semana N° 5 Día 2: Clase 10 ............................................................................................................... 128 Semana N° 6 Día 1: Clase 11 ............................................................................................................... 152 Semana N° 6 Día 2: Clase 12 ............................................................................................................... 159 Semana N° 7 Día 1: Clase 13 ............................................................................................................... 166 Semana N° 7 Día 2: Clase 14 ............................................................................................................... 167 Semana N° 8 Día 1: Clase 15 ............................................................................................................... 168 Semana N° 8 Día 2: Clase 16 ............................................................................................................... 169 Semana N° 9 Día 1: Clase 17 ............................................................................................................... 176

Semana N° 9 Día 2: Clase 18 ............................................................................................................... 204 Semana N° 10 Día 1: Clase 19 ............................................................................................................ 239 Semana N° 10 Día 2: Clase 20 ............................................................................................................ 261 Semana N° 11 Día 1: Clase 21 ............................................................................................................ 276 Semana N° 11 Día 2: Clase 22 ............................................................................................................ 289 UNIDAD IV: PRESENTACIÓN DE RESULTADOS .............................................................................. 291 Semana N° 11 Día 3: Clase 23 ............................................................................................................ 292 ACTIVIDADES DE APRENDIZAJE INTRA Y EXTRA CLASE ............................................................ 303 UNIDAD I: INTRODUCCIÓN A .NET ...................................................................................................... 304 Actividad N° 1 .......................................................................................................................................... 305 Actividad N° 2 .......................................................................................................................................... 307 Actividad N° 3 .......................................................................................................................................... 313 Actividad N° 4 .......................................................................................................................................... 316 Actividad N° 5 .......................................................................................................................................... 326 UNIDAD II: BASE DE DATOS SQL Y ADO .NET ................................................................................. 334 UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C# 335 Actividad N° 6 .......................................................................................................................................... 336 Actividad N° 7 .......................................................................................................................................... 343 Actividad N° 8 .......................................................................................................................................... 356 Actividad N° 9 .......................................................................................................................................... 357 Actividad N° 10 ........................................................................................................................................ 363 UNIDAD IV: PRESENTACIÓN DE RESULTADOS .............................................................................. 379 EVALUACIONES PARCIALES................................................................................................................. 380 EXAMEN FINAL .......................................................................................................................................... 383 PROYECTO FINAL .................................................................................................................................... 384

SYLLABUS DE LA ASIGNATURA

UNIVERSIDAD TÉCNICA DE MACHALA FACULTAD DE INGENIERÌA CIVIL CARRERA DE INGENIERÌA DE SISTEMAS

SYLLABUS ESTANDARIZADO 1.- DATOS GENERALES Asignatura:

Código de la Asignatura:

PROGRAMACIÓN I

IS502

Eje Curricular de la Asignatura:

Año:

PROFESIONAL

2013 - 2014

Horas presenciales teoría:

Ciclo/Nivel:

1 horas de clases teóricas por semana / 40 horas Semestrales.

4to. Semestre

Horas presenciales práctica:

Número de créditos:

4 horas de clase presenciales en laboratorios o en el campo por semanas / 40 horas Semestrales.

5 (CINCO)

Horas atención a estudiantes:

Horas trabajo autónomo: 5 horas semanales / 80 horas semestrales

Fecha de Inicio:

Fecha de Finalización:

6/Mayo/2013

28/Septiembre/2013

Prerrequisitos: IS405 Base de Datos Correquisitos: IS504 Diseño Orientado a Objetos

2.- JUSTIFICACION DE LA ASIGNATURA Programación I es una asignatura de aplicación práctica y técnica perteneciente al eje profesional de los Ingenieros de Sistemas, que sirve para la construcción de sistemas informáticos que permitan resolver las necesidades o requerimientos de empresas e instituciones comerciales públicas o privadas; por lo que está orientada para que el estudiante sea capaz de desarrollar sistemas informáticos tomando en cuenta la información que consta en el análisis de datos, de acuerdo a las necesidades de la empresa y los usuarios mediante el lenguaje de programación C#.

3.- OPERACIONALIZACION DE LA ASIGNATURA CON RESPECTO A LAS COMPETENCIAS DEL PERFIL PROFESIONAL 3.1 Objeto de estudio de la asignatura El Objeto de estudio de la asignatura es: programación en lenguaje C#. 3.2 Competencia de la asignatura Analizar, Diseñar e implementar Sistemas de Información. 3.3 Relación de la asignatura con los resultados de aprendizaje

ESULTADOS DEL APRENDIZAJE a) Habilidad para aplicar el conocimiento de las Ciencias Básicas de la profesión

CONTRIBUCIÓN (alta, media, baja)

BAJA

b) Pericia para diseñar y conducir experimentos, así como para analizar e interpretar datos.

BAJA

c) Destreza para el manejar procesos de Ingeniería de Sistemas

ALTA

d) Trabajo multidisciplinario.

e) Resuelve problemas de Ingeniería de Sistemas.

f) Comprensión de sus responsabilidades profesionales y éticas

MEDIA

ALTA

BAJA

EL ESTUDIANTE DEBE: Aplicar procedimientos y leyes de la lógica matemática para la implementación de código de programación para la eficiencia y la efectividad de soluciones informáticas.

Levantar e interpretar datos de los procesos de negocio, a través de encuestas, entrevistas y observación, para el modelamiento y diseño de la aplicación, así como su verificación mediante pruebas de unidad. Diseñar componentes de código reutilizables, para su implementación entre diferentes proyectos de desarrollo de software aplicables en distintos contextos de negocio. Integrar y colaborar en el desarrollo del proyecto de aplicación final donde se analizará problemática de diferente índole: financiera, comercial, médica, educativa, entre otras. Identificar problemas informáticos generales que involucren parámetros comunes y determinen subrutinas reutilizables. Asumir la participación en las actividades con responsabilidad. Demostrar su participación e innovación de únicamente los involucrados y entregarlo a tiempo

g) Comunicación efectiva

h) Impacto en profesión y en contexto social

ALTA

la el

----------

i) Aprendizaje para la vida

BAJA

j) Asuntos contemporáneos

BAJA

k) Utilización técnicas instrumentos modernos

de e

l) Capacidad para liderar, gestionar o emprender proyectos

Utilizar un lenguaje simplificado, ordenado y estructurado para explicar la factibilidad y las ventajas del producto que han desarrollado. Desarrollar manuales de usuario claros y didácticos, de tal manera que las dudas del usuario se puedan resolver fácilmente.

BAJA

BAJA

Practicar la investigación para comprender la necesidad de seguir capacitándose continuamente. Analizar problemas de actualidad y más comunes del negocio, que se resuelvan con soluciones informáticas de escritorio. Conocer nuevas metodologías y técnicas de programación que simplifiquen procesos de extracción y transformación de datos Dirigir grupos de trabajo, liderando su área de mayor competencia con empatía.

3.4 Proyecto o producto de la asignatura: Los estudiantes elaborarán un trabajo o proyecto de aplicación de la asignatura en el desarrollo de software de escritorio para una empresa de la localidad. El proyecto de investigación estará orientado hacia la utilización de las técnicas de programación en la resolución de problemas, que brinde seguridad, acceso y navegación, utilizando el lenguaje de programación C#.

4.- PROGRAMA DE ACTIVIDADES: 4.1 Estructura de la asignatura por unidades:

UNIDAD I. ―INTRODUCCIÓN A .NET‖

COMPETENCIAS

RESULTADOS DE APRENDIZAJE

1.- Identificar los objetivos 1.- Describe conceptos y terminología del lenguaje de sobre el lenguaje de programación. programación C#. 2.- Reconoce los componentes del IDE

2.Identificar los de C#. componentes del IDE de 3.- Navega y utiliza la ayuda. Visual C#. II. ―BASE DE DATOS SQL Y ADO .NET‖

1.- Conectar una Base de 1.- Escribe programas que se conectan Datos con el lenguaje de a una base de datos y muestren la programación C#. información. 2.Gestionar la 2.-Construye sistema que permiten información de la Base de realizar operaciones CRUD con Datos. integridad y seguras sobre la base de datos 3.- Utilizar funciones en C#.

II. ―CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

1.- Identificar los métodos 1.- Crea interfaces gráficas amigables y a programar en la flexibles. construcción de un sistema 2.- Utiliza nombres estandarizados, 2.- Manejar controles que comentarios, documentación y sangría se pueden utilizar para que para facilitar la posterior lectura del la interfaz gráfica sea código. amigable. 3.- Crea funciones utilizando datos por 3.- Utilizar programación valor y referencia. modular. 4.- Programa métodos que muestren 4.- Aplicar y emplear el características de bajo acoplamiento y lenguaje C# para el alta cohesión. desarrollo, implementación y mantenimiento de los 5.- Construye módulos que valida el ingreso de datos para la integridad de sistemas. la información.

IV. ―PRESENTACIÓN DE RESULTADOS‖

1.Crear y generar 1.- Crea interfaces que permiten informes necesarios para parametrizar los informes. la toma de decisiones. 2.- Presenta la información para toma de decisiones de una Base de Datos en un medio impreso.

4.2 Estructura detallada por temas: UNIDAD I: INTRODUCCIÒN A .NET SEMANA S DE ESTUDI O

TEMAS

CONTENIDOS

ESTRATEGIAS DE APRENDIZAJE

HOR AS

1.06/05/13 – 11/05/13

Principios de 1.1. Diagnó programación stico 1.2. Historia , Concepto, importanci a

Elaboración del objetivo personal para el módulo.

5

Lectura: Dos enfoques de programación Elaboración de un mapa conceptual sobre ¿Qué es programar?

Resolución de Casos de Estudio 1.3. Introdu cción a las Elaboración de línea de tiempo computado sobre evolución de los lenguajes de res y C# programación. Lectura: Quince años de innovación tecnológica. Los desafíos del programador. Nace la era .NET. C#, un lenguaje actual. Elaboración de un cuadro comparativo acerca de las características, ventajas y desventajas de los lenguajes de programación más actuales en el mercado. 2.13/05/13 – 18/05/13

Net Framework 4.0

1.4. ¿Qué es? Novedades . Composici ón. 1.5. Arquite ctura, tecnología y WPF.

Introducción Genera al IDE de 1.6. lidades, Visual C# Barra de Menú, Navegació n y Ayuda. 1.7. Nuevos proyectos y elementos de una solución. 1.8.

Asisten

Investigaciones para profundizar los temas. Lectura: Lenguaje C# y la plataforma .NET Elaboración de mapas conceptuales sobre WPF. Elaboración de un ensayo acerca de .NET Framework. Práctica de laboratorio. Elaboración de cuadro sinóptico acerca de las características que tendrá un sistema (aplicación informática) desarrollada en C#.

5

tes, Diseñador es y editores

TOTAL DE HORAS DE UNIDAD I

10

NIDAD II: BASE DE DATOS SQL Y ADO.NET SEMANAS DE ESTUDIO

TEMAS

CONTENIDOS

3.-

Conexión a 2.1. Base de Arquitectura 20/05/13 – Datos ADO 25/05/13 2.2. Crear una conexión mediante el asistente

ESTRATEGIAS DE APRENDIZAJE

HORAS

Investigaciones para profundizar los temas.

5

Elaboración de cuadro sinóptico sobre ADO.

Elaborar un cuadro comparativo acerca de los DBMS que trabajan con C# (Características, Ventajas, Crear Desventajas)

Tipos de datos por Valor y Referencia

2.3. conexión mediante programación.

Práctica de laboratorio Taller para implementar diagrama E/R en el DMBS seleccionado.

2.4. Declarando y Elaboración de mapas mentales trabajando con sobre los Tipos de datos por valor variables, y referencia. comparación Elaboración de cuadros sinópticos sobre las Funciones en C#.

4.Términos y 2.5. Investigaciones para profundizar 27/05/13 – definiciones. Funciones. los temas. 01/06/13 2.6. Nombres

1

reservados. TOTAL DE HORAS DE UNIDAD II

6

UNIDAD III: CONCEPTOS DE INTERFACE GRÀFICA DE USUARIO Y PROGRAMACIÓN EN C# SEMAN AS DE ESTUDI O 4.27/05/13 – 01/06/13

TEMAS

CONTENIDOS

Formularios Windows Forms

3.1. Principales controles

ESTRATEGIAS DE APRENDIZAJE

HOR AS

Investigaciones para profundizar los 4 temas. Práctica de laboratorio. Ensayo acerca de los objetos GUI que se pueden utilizar para crear la interface gráfica en C#.

5.03/06/13 – 08/06/12

6.10/06/13 – 15/06/13

Formularios Windows Forms

3.1. Principales controles 3.2. Propiedades

Manejo Eventos

Investigaciones para profundizar los 5 temas. Práctica de laboratorio. Elaboración de listas de verificación acerca de las características de un buen diseño de interface para el usuario.

de 3.2. Clases y Investigaciones para profundizar los 5 Métodos temas. 3.3. Programación de métodos.

Práctica de Laboratorio. Lecturas sobre el tema.

Elaboración de lista de verificación acerca de las características de un Manejo de 3.4. ¿Qué es? buen diseño de entrada / salida. excepciones. System.Excep cion Generalidades , ejemplos

7.17/06/13 – 22/06/13

Operaciones CRUD

3.5. Adicionar. Investigaciones para profundizar los 5 Navegar temas. Práctica de Laboratorio.

Taller - Caso de Estudio 8.24/06/13 – 29/06/13

Operaciones CRUD

3.5. Eliminar, Investigaciones para profundizar los 5 Modificar temas. Práctica de Laboratorio. Taller - Caso de Estudio

01/07/13 – 06/07/13 9.08/07/13 – 13/07/13

EXAMEN HEMISEMESTRE

Programació n Avanzada

3.6. Valores Investigaciones para profundizar los 5 automáticos temas. 3.7. Validaciones de datos

Práctica de Laboratorio. Taller - Caso de Estudio

10.15/07/13 – 20/07/13

Integridad

3.8. Validación Investigaciones para profundizar los 5 Integridad temas. llave principal Práctica de Laboratorio. 3.9. Resolución de caso de Estudio. Validaciones llave ajena

11.22/07/13 – 27/07/13

Consultas

3.10. Búsqueda registros.

12.29/07/13 – 03/08/13

Acceso Sistema

Investigaciones para profundizar los 5 de temas.

Práctica de Laboratorio. Manejo de 3.11. Varias tablas Formularios Investigaciones para profundizar los Maestro – temas. Detalle. Práctica de Laboratorio. Cálculos al 3.12.Formulari os MDI

Investigaciones para profundizar los 5 temas.

3.13. Creación Práctica de Laboratorio. y manejo de Menús, Usuarios TOTAL DE HORAS DE UNIDAD III

44

UNIDAD IV: PRESENTACIÒN DE RESULTADOS SEMANAS DE

TEMAS

CONTENIDOS

ESTRATEGIAS DE

HORAS

ESTUDIO

APRENDIZAJE

13.Crystal 05/08/13 – Reports 10/08/13 Visual C#

4.1. Creación y Investigaciones para profundizar 5 y ejecución los temas. 4.2. Informes Práctica de Laboratorio. tipo maestro – detalle 4.3. Informes con filtros y quiebre de control

14.Proyecto 12/08/13 – 17/08/13

4.8. Desarrollo Práctica de Laboratorio de un proyecto dirigido

5

15.Proyecto 19/08/13 – 24/08/13

4.8. Desarrollo Práctica de Laboratorio de un proyecto dirigido

5

16.Proyecto 26/08/13 – 31/08/13

4.8. Defensa Presentación de un informe 5 de Proyectos técnico escrito y presentación oral sobre las bondades y características de la solución desarrollada para la institución seleccionada.

02/09/13 – 07/09/13

RECUPERACIÓN DE CLASES Y PREPARACIÓN DE EXAMENES FINALES

09/09/13 – 14/09/13

EXAMEN FIN DE SEMESTRE

16/09/13 – 21/09/13

EXAMEN DE SUSPENSO MEJORAMIENTO TOTAL DE HORAS DE UNIDAD IV

Y

20

5.- METODOLOGIA: (ENFOQUE METODOLOGICO)

5.1. Métodos de enseñanza De acuerdo a la temática propuesta, las clases y las actividades serán: a)

Clases magistrales, donde se expondrán los temas de manera teórica, mostrando y analizando ejemplos.

b) Trabajo en grupo, para elaborar los elementos de la literatura científica (fichas, citas y referencias bibliográficas), como recurso operativo para elaborar el documento científico. c)

Trabajo autónomo u horas no presenciales, que será el material básico para estructurar la carpeta del estudiante (o cuaderno) al que se agregará el trabajo en grupo: 1. Tareas estudiantiles, los trabajos bibliográficos semanales de tipo individual, además de resúmenes, mapas conceptuales, mapas mentales, cuadros sinópticos, líneas de tiempo, ensayos, entre otros. 2. Investigaciones bibliográficas, individuales o por grupos sobre profundización de temas a tratarse. 3. Trabajos de campo, realizados individual o grupalmente, donde realizan investigación, recopilación de datos acerca de los procesos y datos de la empresa para estructurar esquemas de base de datos.

d) Formas organizativas de las clases, los alumnos asistirán a clase con el material guía (libro) adelantando la lectura del tema de clase de acuerdo a la instrucción previa del docente, sobre los puntos sobresalientes o trascendentales que se van a exponer. De estos análisis saldrán los trabajos bibliográficos que deberán desarrollar y entregar posteriormente. e) Medios tecnológicos que se utilizaran para la enseñanza:  Pizarrón para tiza líquida y marcadores de varios colores.  Libros y revistas de la biblioteca.  Internet y material de Webs.  Equipo de proyección multimedia y material académico en Power Point.  Aplicaciones para elaborar diagramas (Visio) y diseño de interface (Paint, Adobe,

entre otros)  Aula Virtual

6.- COMPONENTE INVESTIGATIVO DE LA ASIGNATURA: Los tipos de investigación que se realizará en la asignatura son: Investigación Formativa.- Referida al aprendizaje por descubrimiento y construcción del conocimiento por parte de los estudiantes. Este método consiste en que el profesor a partir de una situación problémica, logra que el estudiante busque, indague, y encuentre situaciones similares, así mismo que haga revisiones de literatura, (bibliografía, códigos y especificaciones) recoja datos, los organice, interprete y encuentre soluciones a las dificultades planteadas por los profesores.

7. PORTAFOLIO DE LA ASIGNATURA

Durante el desarrollo de la actividad académica el estudiante construirá un Portafolio que comprende la evidencia de dichas actividades. El portafolio de la asignatura contendrá la siguiente información 

Carátula



Syllabus



Tareas en clase



Tareas extraclase



Evaluaciones parciales de cada unidad



Evaluación final



Evidencia de eventos investigativos (Informe Proyecto Final de la asignatura).



Apuntes relevantes (Resumen de las clases)

8. EVALUACIÓN La evaluación será diagnóstica, formativa y sumativa, considerándolas necesarias y complementarias para una valoración global y objetiva de lo que ocurre en la situación de enseñanza y aprendizaje. Los alumnos serán evaluados con los siguientes parámetros, considerando que la calificación de los exámenes finales de cada parcial corresponderán al 30% de la valoración total, el restante 70% se lo debe distribuir de acuerdo a los demás parámetros, utilizando un mínimo de cinco parámetros. 8.1 Evaluaciones Parciales: Pruebas parciales dentro del proceso, determinadas con antelación en las clases. Presentación de informes escritos como producto de investigaciones bibliográficas. Participación en clases a partir del trabajo autónomo del estudiante; y, participación en prácticas de laboratorio y de campo de acuerdo a la pertinencia en la asignatura. 8.2 Exámenes: Examen Final, al finalizar todas las unidades, en la semana No. 17, los estudiantes rendirán un examen final.

8.3 Parámetros de Evaluación:

PARAMETROS DE EVALUACION

PORCENTAJES

1er. PARCIAL Pruebas parciales dentro del proceso

20

Presentación de informes escritos

10

Investigaciones bibliográficas

10

Participación en clase

10

Trabajo autónomo

10

Prácticas de laboratorio

-

Prácticas de campo

10

Exámenes Finales

30

Total

100

9. BIBLIOGRAFÍA 9.1. Bibliografía Básica:  SANCHEZ, C. 2011. Conociendo lo nuevo de Visual C# 2010 y Framework 4.0. Primera edición. Editorial Macro. Lima, Perú. 9.2. Bibliografía Complementaría:  DEITEL, H & DEITEL, P. 2007. Cómo programar en C#. Segunda Edición. Editorial Pearson Educación, México.  CHARTE, F. 2007. Microsoft Visual C# 2005. Guía Práctica para usuarios. Editorial Anaya, España.  ZEA, M. 2013. Guía del módulo de Programación I. Universidad Técnica de Machala. Ecuador.

9.3. Páginas WEB (webgrafía) http://msdn.microsoft.com/es-es/library/zkxk2fwf%28v=vs.90%29.aspx http://www.elguille.info/NET/cursoCSharpErik/index.htm http://www.canalvisualbasic.net/manual-net/c-sharp/ http://www.programacionfacil.com/csharp_net/start http://es.scribd.com/doc/17812628/Manual-de-C-SQL-Server-Paso-a-Paso http://melca.com.ar/UTN/archivos/El%20lenguaje%20de%20programacion%20Csharp.pdf http://www.csharp-station.com/Tutorial.aspx http://www.onglasses.net/Default.aspx?id=165

http://www.youtube.com/watch?v=DHcyUM5Md94

10. DATOS DEL DOCENTE: Mariuxi Paola Zea Ordoñez Master en Educación Superior, Ingeniero en Computación y Ciencias de la Informática Dirección: Calle San Martín # 4-14 entre Colón e Independencia, Pasaje Teléfonos: 07-2915426, 07-2912042, 099-8228455, 0939036346. Correo electrónico: [email protected], [email protected] 11. FIRMA DEL O LOS DOCENTES RESPONSABLES DE LA ELABORACIÓN DEL SYLLABUS

_______________________ Mariuxi Paola Zea Ordoñez 12. FECHA DE PRESENTACION: Machala, Mayo del 2013

UNIVERSIDAD TÉCNICA DE MACHALA FACULTAD DE INGENIERÍA CIVIL ESCUELA DE INFORMÁTICA Carrera de Ingeniería de Sistemas

AUTORRETRATO

Mi nombre es Jennifer Lisseth Honores Cun soy estudiante de la asignatura de Programación I, actualmente curso el Quinto Semestre en la carrera de Ing. de Sistemas de la Escuela de Informática de la Facultad de Ingeniería Civil de la Universidad Técnica de Machala. Soy una persona responsable, puntual Mis metas son llegar a convertirme un gran profesional de Ingeniería de Sistemas para así poder ejercer mi profesión. Aprender más para así desarrollarme como persona, cumplir mis metas y propuesta porque nada es imposible en esta vida ya que todo es posible solo hay que ponerle fuerza de voluntad y teniendo como principal fuente de apoyo incondicional del docente Ing. Mariuxi Zea.

UNIVERSIDAD TÉCNICA DE MACHALA FACULTAD DE INGENIERÍA CIVIL ESCUELA DE INFORMÁTICA Carrera de Ingeniería de Sistemas

CURRÍCULO Apellidos: Honores Cun Nombres: Jennifer Honores Curso: Tercero Semestre: Primer Paralelo: ―A‖ Sección: Diurna C.I.: 0706418514 Edad: 18 Fecha de nacimiento: Facebook: Jennifer.Honores Correo electrónico: 14/09/1992 [email protected] Convencional: Celular 1: 0998075497 Celular 2: Domicilio: Urb. La Primavera Provincia: El Oro Cantón: Machala Parroquia: Machala Referencia: Dirección: Sexo: Femenino Estado Civil: Soltero Croquis de su domicilio:

Datos del Padre Apellidos y Nombres: Honores Ordoñez Pedro Luis Datos de la Madre Apellidos y Nombres: Cun Lopez Luz Emilia Donde trabaja: Dirección del trabajo: Dirección domiciliaria: Urb. La Primavera

Celular: 0998431264

Datos del cónyuge (en caso de tenerlo) Apellidos y Nombres: Donde trabaja: Dirección del trabajo: Dirección domiciliaria: Número de hijos: Observaciones: Datos del Trabajo: (en caso de tenerlo) Donde trabaja: Renacer Dirección del trabajo: Teléfono 1:

Celular:

Celular:

Sector: Teléfono 2:

UNIVERSIDAD TÉCNICA DE MACHALA

MISIÓN La Universidad Técnica de Machala es una Institución reconocida en su área de influencia formadora de profesionales, con capacidades científico- técnicas, éticos, solidarios, con identidad nacional, que aporta, creativamente, a través de la docencia, investigación, vinculación y gestión, a la solución de los problemas del desarrollo sostenible y sustentable.

VISIÓN

La Universidad Técnica de Machala para el año 2013 es una institución acreditada, lidera el desarrollo territorial, forma y perfecciona profesionales competentes, emprendedores, innovadores, críticos y humanistas.

ESCUELA DE INFORMÁTICA La Escuela de Informática fue creada mediante resolución No. 087/1995 (25 de Octubre/1995)

La Carrera de Ingeniería de Sistemas fue creada mediante resolución No.

077/2001 (7 de mayo de 2001) La Misión y Visión fueron aprobadas mediante resolución No. 452 del H. C. D. (Honorable Consejo Directivo) del 13 de Diciembre del 2011.

MISIÓN Formar profesionales en Ingeniería de Sistemas con capacidades científicas, técnicas, tecnológicas y humanísticas, competitivos y comprometidos con el desarrollo sostenible y sustentable del buen vivir.

VISIÓN La carrera de Ingeniería de Sistemas para el año 2013 es la unidad acreditada y líder en el desarrollo y transferencia de soluciones informáticas, acorde a los avances científicos y tecnológicos.

PERFIL PROFESIONAL El Ingeniero de Sistemas de la Universidad Técnica de Machala es un profesional con espíritu empresarial, ético con características de creatividad, innovación, capacidad investigativa, deseo permanente de trabajar, de aprender y perfeccionarse con amor propio, con amplia sensibilidad social y con capacidad promotora de desarrollo de la comunidad donde se desempeñe y que estará capacitado para:

Generar empresas comunicaciones.

en

las

áreas

de las

tecnologías

de la informática

y las

Asesorar, dirigir, intervenir y auditar proyectos informáticos.

Planificar, dirigir, analizar, diseñar e implementar Sistemas de Información. Evaluar, negociar e innovar la Tecnología. Trabajar en equipos interdisciplinarios y proponer soluciones en forma consensuada.

Identificar y definir procesos organizacionales en el ámbito en el cual se desempeñe.

Evaluar y seleccionar los recursos humanos informáticos de acuerdo a las necesidades de la organización.

DIARIO METACOGNITIVO

UNIDAD I: INTRODUCCIÓN A .NET

Semana N° 1 Día 1: Clase 1 PERÍODO

CLASE N°:

1

06/05/2013 al 10/05/2012

TIEMPO:

2 Horas

FECHA:

06/05/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD I: INTRODUCCIÓN A .NET

Contenidos  Presentación del Syllabus 

Parámetros de Calificación

Objetivos de Desempeño  Establecer los parámetro de calificación 

Establecer las Políticas del Syllabus

Competencia General  Como haremos el desarrollo del Portafolio.

Datos Interesados Discutidos Actividades Durante la Clase - Entrega del Syllabus y modelo del Portafolio.

Descriptores Analizados - Diario Metacognitivos -

Actividades Intraclase y Extraclase

Reflexionar ¿Qué cosa fueron difíciles?  Ahora en este modulo habrá que desarrollar a diario las clases ¿Qué cosas fueron fáciles?  Las actividades Intraclase y extraclase que se van a llevar me parece que ahora ya esta mas fácil desarrollarlas. ¿Por qué?  Ahora en nuestra carrea nos hacen llevar todos los apuntes en clase para después hacer refuerzo en casa, por lo cual hay que desarrollar diarios metacognitivos a diario ¿Qué Aprendí Hoy? - No hubieron temas de discusión solo explicación del modulo.

APUNTES DE CLASE 

El Modulo de Programación tendrá 5 créditos.



En el portafolio debemos llevar Diario Metacongnitivo, actividades Intrclase y Extraclase del módulo.



Parámetros de Calificación: o

Examen = 3 pts.

o

Proyecto= 2 pts.

o

Examen Hemisemestre = 2 pts.

o

Actividades = 3 pts. 

Tareas



Investigaciones



Actuaciones

Semana N° 1 Día 2: Clase 2 PERÍODO

CLASE N°:

2

06/05/2013 al 10/05/2012

TIEMPO:

2 Horas

FECHA:

08/05/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD I: INTRODUCCIÓN A .NET

Contenidos  Historia del C#. 

Ventajas de C#.

Objetivos de Desempeño  Aprender acerca de C#. 

Conocer su Historia.

Competencia General  Historia del C#: Quien lo Creo, por que lo crearon. 

Ventajas de C#: Es conveniente usarlo.

Datos Interesados Discutidos Actividades Durante la Clase - Se hizo una breve descripción de C# como quien lo creo y porque lo crearon y sacar ventajas sobre este Lenguaje de Programación. -

Se hizo una actividad Intraclase sobre un caso de estudio.(Anexo Actividad)

Descriptores Analizados  Historia de C#

 Ventajas de C# Conceptos de los Descriptores Analizados -

Historia de C#

 Hejlsberg lideró el proyecto de desarrollo de C#. Anteriormente, ya participó en el desarrollo de otros lenguajes como Turbo Pascal, J++ y Embarcadero Delphi. -

Ventajas de C#

 Declaraciones en el espacio de nombres: al empezar a programar algo, se puede definir una o más clases dentro de un mismo espacio de nombres.

Tipos de datos: en C# existe un rango más amplio y definido de tipos de datos que los que se encuentran en C, C++ o Java. Reflexionar ¿Qué cosa fueron difíciles?  No se nos hizo difícil nada. ¿Qué cosas fueron fáciles?  Realizar la actividad Intraclase. ¿Por qué?  Gracias al Internet se nos hizo mucho más fácil encontrar sobre C#.  La actividad Intraclase fue muy interesante ya que lo hicimos en grupo y después discutimos las respuestas con nuestros compañeros.

¿Qué Aprendí Hoy? -

Quien fue el creador de C# y cuáles son las ventajas de usar C#.

APUNTES DE CLASE

Semana N° 1 Día 3: Clase 3 PERÍODO

CLASE N°:

3

06/05/2013 al 10/05/2012

TIEMPO:

1 Horas

FECHA:

10/05/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD I: INTRODUCCIÓN A .NET

Contenidos  Evolución de los lenguajes de Programación. 

Sistemas Automatizados

Objetivos de Desempeño  Conocer más los lenguajes de Programación. 

Aprender sobre los sistemas automatizados que existen en la actualidad

Competencia General  Identifica los objetivos del lenguaje de programación C#

Datos Interesados Discutidos Actividades Durante la Clase - Se hizo una actividad Intraclase sobre la evolución de los lenguajes de programación.(Anexo Actividad) -

La actividad intraclase se trato de hacer una espina de pescado de la evolución.

-

Se compartió con los compañeros las características que se habían descritos en la espina de pescado.

-

Se compartió respuestas sobre preguntas acerca de C#.

Descriptores Analizados Creación del Lenguaje Ensamblador 1 Jan 1950

C# 1 Enero 1980

Conceptos de los Descriptores Analizados

Reflexionar ¿Qué cosa fueron difíciles?  Al realizar la espina de pescado acerca de las fechas de creación del los lenguajes de programación.  En una de las preguntas: ¿En qué generación ubica a C#. ¿Qué cosas fueron fáciles?  Encontrar las características de los lenguajes de programación. ¿Por qué?

 Al momento de buscar en el internet sobre las fechas de creación varían con relación a fuentes bibliográficas.  La pregunta de qué en que generación poníamos a C# fue tal vez la más confusa ya que si bien es cierto C# es un combinación de Java y C por lo cual estos lenguajes estaban en tercera generación, pero al momento de ver sus características automatizadas se analizo y debido a esto se la clasifico como cuarta generación.  Las características de los lenguajes de programación se encontraba de manera más amplia en el internet. ¿Qué Aprendí Hoy? - Se aprendió a analizar, describir en una espina de pescado la evolución de los lenguajes de programación. -

Entendimos en el lenguaje de Programación C# es te cuarta generación. APUNTES DE CLASE En esta clase no hubo apuntes debido a que se trabajó una actividad Intraclase.

Semana N° 2 Día 1: Clase 4 PERÍODO

CLASE N°:

4

13/05/2013 al 17/05/2012

TIEMPO:

2 Horas

FECHA:

13/05/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD I: INTRODUCCIÓN A .NET

Contenidos  Introducción a Visual Estudio 2010 

Creación de Proyectos en Visual Estudio 2010 con C#

Objetivos de Desempeño  Conocer la Interfaz de C# 

Trabajar con Visual Estudio 2010 C#

Competencia General  Conoce la interfaz de C# 

Aprende a trabajar en Proyectos de C#

Datos Interesados Discutidos Actividades Durante la Clase - Se aprendió a usar la herramienta de Visual Estudio C#. -

Se creó proyectos de C#: Console y Aplicación de Formulario.

-

Se conoce propiedades, explorador de soluciones

-

La Ing. Mariuxi Zea mediante el proyecto nos enseñaba todo lo antes mencionado.

Descriptores Analizados - Visual -

Estudio 2010

C#

Conceptos de los Descriptores Analizados Microsoft Visual Studio es un entorno de desarrollo integrado (IDE, por sus siglas en inglés) para sistemas operativos Windows. Soporta varios lenguajes de programación tales como Visual C++, Visual C#, Visual J#, y Visual Basic

.NET, al igual que entornos de desarrollo web como ASP.NET.

Versiones      

Visual Basic Express Edition Visual C# Express Edition Visual C++ Express Edition Visual J# Express Edition (Desapareció en Visual Studio 2008) Visual Web Developer Express Edition (para programar en ASP.NET) Visual F# (Apareció en Visual Studio 2010, es parecido al J#)*

Reflexionar ¿Qué cosa fueron difíciles?  No hubieron temas difíciles con relación a Visual Estudio 2010 C# ¿Qué cosas fueron fáciles?  Todo quedo entendido. ¿Por qué?  Debido a la Docente explicaba con proyector el alumno iba practicando en cada una de sus computadores y todo era más sencillo. ¿Qué Aprendí Hoy? -

A crear Proyectos C# mediante: Console y aplicación de formulario.

APUNTES DE CLASE 1. Ingresar a Visual Estudio 2010

2. Nos aparecerá la pantalla principal de Visual Estudio 2010

3. La ventana de Explorador de soluciones es donde se van a almacenar todos los formularios o clases de nuestro proyecto

4. En la ventana de cuadro de herramientas nos aparecerá todos los componentes que podemos arrastrar pero solo si es aplicación de formulario

5. Haremos clic en crear nuevo proyecto

6. Nos pantalla

aparecerá la siguiente

7. En este espacio escribiremos el nombre, escogeremos la ubicación, y el nombre de la solución.

8.

Primero crearemos aplicación de consola 8.1.

Damos clic en Aplicación de consola

8.2.

Cambiamos de nombre y damos clic en aceptar

8.3.

Nos aparecerá la siguiente pantalla

8.4.

Nos damos cuenta que este es el editor de códigos donde vamos a programar

8.5. Ahora en la ventana de explorador de soluciones nos aparecerá nuestras clases creadas.

9. Ahora crearemos una aplicación de formulario. 9.1.

Escogemos nuevo proyecto

9.2.

Escogemos aplicación de formulario

9.3.

Cambiamos los datos, y damos clic en aceptar

9.4.

Nos aparecerá la siguiente ventana

9.5.

En el cuadro de herramientas podemos arrastrar componentes

9.6.

Así nos quedara el formulario diseñándolo

9.7.

Si damos doble clic nos aparece el editor de código para programar

9.8. Un ejemplo vamos a dar clic en el botón guardar y nos tiene que aparecer se guardo con éxito. 9.8.1. Damos doble clic en el botón guardar 9.8.2. Nos aparecerá la siguiente ventana

9.8.3. En el método ―prívate void button1_Click (Object sender, EventArgs e)‖ escribimos la línea de código para el mensaje. Quedando así:

9.9. ventana podemos cambiar las propiedades de cada componente

En esta

9.10. Damos clic en depuración o pulsamos la tecla F5 para ejecutar la aplicación. 9.11. Esta es la ventana que nos aparece.

9.12. Al dar clic en el botón guardar nos aparecerá lo siguiente porque ya lo habíamos cambiado en el punto (9.8.3)

10. Así ya hemos creado proyectos tipo consola y aplicación de formulario.

UNIDAD II: BASE DE DATOS SQL Y ADO .NET

Semana N° 3 Día 1: Clase 5 CLASE N°:

5

PERÍODO

20/05/2013 al 24/05/2012

TIEMPO:

2 Horas

FECHA:

20/05/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD II: BASE DE DATOS SQL Y ADO .NET

Contenidos  Visual Estudio 2010 C# 

Creación de Base de datos en Microsoft Acces



Base de datos en Visual Estudio 2010 C#

Objetivos de Desempeño  Aprender a hacer conexiones con una base de datos y Visual Estudio 2010 

Trabajar con Visual Estudio 2010 C#

Competencia General  Aprende a trabajar en Proyectos de C# 

Aprende a hacer Conexiones BD y C#

Datos Interesados Discutidos Actividades Durante la Clase - La Ing. Mariuxi Zea mediante el proyecto nos enseñaba a crear las conexiones

1. Creamos BD en Microsoft Acces 2. Creamos 5 registros 3. Revisamos las conexiones mediante código para Visual Estudio 2010 C#

4. Hicimos la conexión entre la herramienta de aprendizaje con la BD Descriptores Analizados - Visual Estudio 2010 -

Base de datos

en Visual Studio 2010

Conceptos de los Descriptores Analizados Visual Studio proporciona herramientas para conectar la aplicación a datos de muchos orígenes diferentes, como bases de datos, servicios y objetos. Las conexiones a datos se

crean mediante programación (en código), como resultado de colocar los objetos de datos en un formulario o diseñador de componentes o a través de la finalización de uno de los asistentes de datos. Reflexionar ¿Qué cosa fueron difíciles?  Al momento de crear conexiones de base de datos como programador uno debe saberse el código de conexión. ¿Qué cosas fueron fáciles?  Conexionar la BD de manera automática. ¿Por qué?  Debido a que uno no solo va a crear conexiones automáticas por que no todos los lenguajes de programación no tienen esa facilidad uno aunque sea debe tener idea del código para estas conexiones. ¿Qué Aprendí Hoy? -

Crear conexiones con el lenguaje de Programación C# y las Bases de datos. APUNTES DE CLASE

1. Crearemos Conexiones 2. Primero Crearemos la base de datos en Access 2.1.

Abrimos Microsoft Access

2.2. datos

Creamos una base de

2.3.

Llenamos los campos según el tipo de dato

2.4.

Llenamos 5 registros

2.5.

Guardamos y cerramos Access

3. Abrimos Visual Estudio 2010 3.1.

En Visual Studio, elija Archivo, Nueva, proyecto.

3.2.

Dé al proyecto el nombre clientes.

3.3.

Seleccione Aplicación de Windows Forms y elija el botón Aceptar.

El proyecto clientes se Explorador de

crea y se agrega al soluciones.

4. Conectar con la base de datos Access 4.1.

En el menú Datos, haga clic en Mostrar orígenes de datos.

4.2. En Orígenes de datos, seleccione Agregar nuevo origen de datos.

la ventana

4.3. En la ventana Elegir un tipo de origen de datos, seleccione Base de datos y, a continuación, haga clic en Siguiente.

4.4. En un modelo de base de datos, seleccione Conjunto de datos y, a 4.5.

continuación, haga clic en Siguiente.

la ventana Elegir

4.6.

En la ventana Elegir la conexión de datos, seleccione una de estas opciones: 

Si una conexión de datos a la base de datos de ejemplo PAE está disponible en la lista desplegable, selecciónela.



Seleccione Nueva conexión para configurar una nueva conexión de datos. confidenciales y haga clic en Siguiente.

O bien

4.7.

Acogemos nueva conexión

4.7.1. En la ventana Nueva conexión 4.7.1.1.

Escogemos el Origen de datos

4.7.1.2.

Buscamos el archivo que creamos anteriormente

4.7.1.3. En este caso la base de datos no tenía nombre de usuario ni contraseña le dejamos por defecto.

4.7.1.4.

Damos clic en probar conexión y nos tiene que aparecer lo

siguiente

4.7.2. Damos clic en aceptar 4.8.

Otra vez nos aparecerá la ventana siguiente, damos clic en siguiente

4.9.

Damos clic en ―No‖ en el cuadro

4.10. Damos clic en siguiente

4.11. Seleccionamos tablas y damos clic en finalizar

5. Una vez creada la conexión tendremos la ventana orígenes de datos con la base de datos cargada

6. Arrastramos la taba datos hacia el formulario

7. Nos aparecerá la tabla como en Access

8. Al ejecutar la aplicación nos aparecerá los registros ya hechos en Access

9. Con esto podemos agregar, eliminar, modificar, guardar, y navegar entre los diferentes registros. 10. Todo esto que hacemos en visual estudio 2010 se irán guardando los registros en Access

Semana N° 4 Día 1: Clase 6 CLASE N°:

6

PERÍODO

27/05/2013 al 31/05/2012

TIEMPO:

2 Horas

FECHA:

27/05/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD II: BASE DE DATOS SQL Y ADO .NET

Contenidos  Visual Estudio 2010 C# 

Creación de Base de datos en Microsoft Acces



Conexiones de Base de datos mediante Código

Objetivos de Desempeño  Aprender a hacer conexiones con una base de datos y Visual Estudio 2010 

Trabajar con Visual Estudio 2010 C#

Competencia General  Aprende a trabajar en Proyectos de C# 

Aprende a hacer Conexiones BD y C#

Datos Interesados Discutidos Actividades Durante la Clase - La Ing. Mariuxi Zea mediante el proyector nos enseñaba a crear las conexiones

1. Creamos BD en Microsoft Acces 2. Creamos 5 registros 3. Revisamos las conexiones mediante código para Visual Estudio 2010 C#

4. Hicimos la conexión entre la herramienta de aprendizaje con la BD Descriptores Analizados - Visual Estudio 2010 -

Base de datos

en Visual Studio 2010

Conceptos de los Descriptores Analizados Visual Studio proporciona herramientas para conectar la aplicación a datos de muchos orígenes diferentes, como bases de datos, servicios y objetos. Las conexiones a datos se crean mediante programación (en código), como resultado de colocar los objetos de datos en un formulario o diseñador de componentes o a través de la finalización de uno de los asistentes de datos. Reflexionar ¿Qué cosa fueron difíciles?  Al momento de crear conexiones de base de datos como programador uno debe saberse el código de conexión. ¿Qué cosas fueron fáciles?  Trabajar en modo diseño y hacer las pruebas con las bases de datos. ¿Por qué?  Debido a que uno no solo va a crear conexiones automáticas porque no todos los lenguajes de programación no tienen esa facilidad uno aunque sea debe tener idea del código para estas conexiones. ¿Qué Aprendí Hoy? -

Crear conexiones con el lenguaje de Programación C# y las Bases de datos. APUNTES DE CLASE

1. Crearemos Conexiones 2. Primero Crearemos la base de datos en Access a.

Abrimos Microsoft Access

b.

Creamos una base de datos

c. dato

Llenamos los campos según el tipo de

d.

Llenamos 5 registros

e.

Guardamos y cerramos Access

3. Abrimos Visual Estudio 2010 a.

En Visual Studio, elija Archivo, Nueva, proyecto.

b.

Dé al proyecto el nombre clientes.

c.

Seleccione Aplicación de Windows Forms y elija el botón Aceptar.

El proyecto clientes se crea y se agrega al Explorador de soluciones.

4. Creamos los formularios quedando de la siguiente manera

5. Para todo el Formulario y la conexión a la base de datos se utilizo en la clase Form2 el siguiente código: using using using using using using using using using

System; System.Collections.Generic; System.ComponentModel; System.Data; System.Drawing; System.Linq; System.Text; System.Windows.Forms; System.Data.OleDb;

namespace WindowsFormsApplication5 { public partial class Form2 : Form { public DataSet ds; public DataRow dr; public OleDbDataAdapter da; public OleDbConnection con; public int fila = 0; public Form2() { InitializeComponent(); // creamos la variable con con la conexion a la bd con el proveedor de datos con = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Users\Usuario\Documents\Database1.accdb"); // creamos la consulta a la base de datos y cargamos el data adapter da = new OleDbDataAdapter("Select * from clientes", con); // creamos la variable data set. ds = new DataSet(); // cargamos la variable ds (data set) con la tabla clientes da.Fill(ds, "Clientes"); // Cargamos campos

mostrarDatos(fila); button3.Enabled = false; button5.Enabled = false; } private void Form2_Load(object sender, EventArgs e) { } private void LimpiarDatos() { textBox1.Clear(); textBox2.Clear(); textBox3.Clear(); textBox4.Clear(); textBox5.Clear(); textBox6.Clear(); button3.Enabled = true; button5.Enabled = true; button1.Enabled = false; button2.Enabled = false; button4.Enabled = false; button6.Enabled = false; button7.Enabled = false; } private void mostrarDatos(int f) { int uf = ds.Tables["Clientes"].Rows.Count; if (f < 0 || uf < 0) return; // Caso contrario dr = ds.Tables["Clientes"].Rows[f]; textBox1.Text = dr["Id"].ToString(); textBox2.Text = dr["Nombres"].ToString(); textBox3.Text = dr["Apellidos"].ToString(); textBox4.Text = dr["Edad"].ToString(); textBox5.Text = dr["Ciudad"].ToString(); textBox6.Text = dr["Genero"].ToString(); dateTimePicker1.Text = dr["Fecha_nac"].ToString(); }

private void button4_Click(object sender, EventArgs e) { LimpiarDatos(); } private void button1_Click(object sender, EventArgs e) { fila = fila - 1; if (fila < 0) fila = 0; mostrarDatos(fila); } private void button7_Click(object sender, EventArgs e) { fila = ds.Tables["Clientes"].Rows.Count - 1; mostrarDatos(fila); } private void button6_Click(object sender, EventArgs e) {

fila = 0; mostrarDatos(fila); } private void button2_Click(object sender, EventArgs e) { int uf = ds.Tables["Clientes"].Rows.Count - 1; fila = fila + 1; if (fila > uf) fila = uf; mostrarDatos(fila); } private void button3_Click(object sender, EventArgs e) { // Pasar los valore de las cajas de texto a variables auxiliares int aid = int.Parse(textBox1.Text); // Parse convierte texto a numerico. // Por estandar los nombres se deben crear de acuerdo a su condicion. // Ejemplo: auxiliar id = aid, nombre de clientes = nom_cli string nom = textBox2.Text; string ape = textBox3.Text; string eda = textBox4.Text; string ciu = textBox5.Text; string gen = textBox6.Text; // Convertimos el texto a fecha DateTime fec = Convert.ToDateTime(dateTimePicker1.Text); // creamos nuestra variable de texto que contendrá la sentencia SQL // que debe ejecutarse para Insertar el registro string sentenciaSQL = "INSERT INTO Clientes (nombres, apellidos, edad, ciudad, genero, fecha_nac) VALUES (@anom, @aape,@aeda,@aciu, @agen,@afec)"; // Creamos la variable comando que se va a ejecutar, con la sentencia SQl y la conexion (variable con) utilizada arriba OleDbCommand comando = new OleDbCommand(sentenciaSQL, con); // creacion de variables parametros y asignacion de valores comando.Parameters.Add(new OleDbParameter("@anom", OleDbType.VarChar, 25)); //Añadimos el parametro comando.Parameters["@anom"].Value= nom; // Asignando el valor de la variable nom en @anom comando.Parameters.Add(new OleDbParameter("@aape", OleDbType.VarChar, 25)); comando.Parameters["@aape"].Value= ape; comando.Parameters.Add(new OleDbParameter("@aeda", OleDbType.Integer)); comando.Parameters["@aeda"].Value= eda; comando.Parameters.Add(new OleDbParameter("@aciu", OleDbType.VarChar, 15)); comando.Parameters["@aciu"].Value=ciu; comando.Parameters.Add(new OleDbParameter("@agen", OleDbType.VarChar, 1)); comando.Parameters["@agen"].Value= gen; comando.Parameters.Add(new OleDbParameter("@afec", OleDbType.Date)); comando.Parameters["@afec"].Value= fec; // Abrimos la base de datos comando.Connection.Open(); // Abro la conexion con la base de datos comando.ExecuteNonQuery(); // Ejecuta el copmando Insert comando.Connection.Close(); // Cierro la conexion con la base datos da.Fill(ds, "Clientes"); button5_Click(null, null); } private void button5_Click(object sender, EventArgs e) { button3.Enabled = false; // Aceptar button5.Enabled = false; // Cancelar button1.Enabled = true; // Anterior button2.Enabled = true; // Siguiente button4.Enabled = true; // Nuevo button6.Enabled = true; // Primero button7.Enabled = true; // Ultimo

button7_Click(null, null); // Llamar al método clic del boton 7.

(Hacer clic

en Ultimo) } private void button8_Click(object sender, EventArgs e) { string sentenciaSQL = "DELETE FROM Clientes WHERE id = @aid"; // Creamos la variable comando que se va a ejecutar, con la sentencia SQl y la conexion (variable con) utilizada arriba OleDbCommand comando = new OleDbCommand(sentenciaSQL, con); // creacion de variables parametros y asignacion de valores comando.Parameters.Add(new OleDbParameter("@aid", OleDbType.Integer)); //Añadimos el parametro comando.Parameters["@aid"].Value = textBox1.Text; // Asignando el valor de la variable nom en @anom // Abrimos la base de datos comando.Connection.Open(); // Abro la conexion con la base de datos comando.ExecuteNonQuery(); // Ejecuta el copmando Insert comando.Connection.Close(); // Cierro la conexion con la base datos da.Fill(ds, "Clientes"); // Vuelve a cargar la tabla. button7_Click(null, null); } private void button9_Click(object sender, EventArgs e) { // Pasar los valore de las cajas de texto a variables auxiliares int aid = int.Parse(textBox1.Text); // Parse convierte texto a numerico. // Por estandar los nombres se deben crear de acuerdo a su condicion. // Ejemplo: auxiliar id = aid, nombre de clientes = nom_cli string nom = textBox2.Text; string ape = textBox3.Text; string eda = textBox4.Text; string ciu = textBox5.Text; string gen = textBox6.Text; // Convertimos el texto a fecha DateTime fec = Convert.ToDateTime(dateTimePicker1.Text); // creamos nuestra variable de texto que contendrá la sentencia SQL // que debe ejecutarse para Insertar el registro string sentenciaSQL = "UPDATE Clientes SET nombres = @anom, apellidos = @aape, edad = @aeda, ciudad = @aciu, genero = @agen, fecha_nac = @afec WHERE id = @aid"; // Creamos la variable comando que se va a ejecutar, con la sentencia SQl y la conexion (variable con) utilizada arriba OleDbCommand comando = new OleDbCommand(sentenciaSQL, con); // creacion de variables parametros y asignacion de valores comando.Parameters.Add(new OleDbParameter("@anom", OleDbType.VarChar, 25)); //Añadimos el parametro comando.Parameters["@anom"].Value = nom; // Asignando el valor de la variable nom en @anom comando.Parameters.Add(new OleDbParameter("@aape", OleDbType.VarChar, 25)); comando.Parameters["@aape"].Value = ape; comando.Parameters.Add(new OleDbParameter("@aeda", OleDbType.Integer)); comando.Parameters["@aeda"].Value = eda; comando.Parameters.Add(new OleDbParameter("@aciu", OleDbType.VarChar, 15)); comando.Parameters["@aciu"].Value = ciu; comando.Parameters.Add(new OleDbParameter("@agen", OleDbType.VarChar, 1)); comando.Parameters["@agen"].Value = gen; comando.Parameters.Add(new OleDbParameter("@afec", OleDbType.Date)); comando.Parameters["@afec"].Value = fec; comando.Parameters.Add(new OleDbParameter("@aid", OleDbType.Integer)); comando.Parameters["@aid"].Value = aid; // Abrimos la base de datos comando.Connection.Open(); // Abro la conexion con la base de datos comando.ExecuteNonQuery(); // Ejecuta el copmando Insert comando.Connection.Close(); // Cierro la conexion con la base datos da.Fill(ds, "Clientes");

button7_Click(null, null); }

} }

UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

Semana N° 4 Día 2: Clase 7 CLASE N°:

7

PERÍODO

27/05//2013 al 31/05/2012

TIEMPO:

2 Horas

FECHA:

29/05/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

Contenidos  Windows Forms

 Principales controles  Propiedades Objetivos de Desempeño  Crear interfaces gráficas amigables y flexibles. 

Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.



Crear funciones utilizando datos por valor y referencia.



Programar métodos que muestren características de bajo acoplamiento y alta cohesión.



Construir módulos que valida el ingreso de datos para la integridad de la información

Competencia General  Identificar los métodos a programar en la construcción de un sistema 

Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.



Utilizar programación modular.



Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.

Datos Interesados Discutidos Actividades Durante la Clase - Hubieron exposiciones de Compañeros -

Cada estudiante iba haciendo sus prácticas de cada tema expuesto 

CheckBox



CheckBoxList



ComboBox



DateTimePicker.



MonthCalendary.



Listbox



ListView

Descriptores Analizados - CheckBox -

Check BoxList

-

ComboBox

-

DateTimePicker.

-

MonthCalendary.

-

ListBox

-

ListView

Conceptos de los Descriptores Analizados

CHECKBOX El control CheckBox de Windows Forms indica si una condición establecida está activada o desactivada. Permite al usuario seleccionar uno o más elementos marcando la casilla / casillas de verificación correspondientes. Puede utilizar grupos de casillas para mostrar múltiples opciones entre las cuales el usuario puede elegir una o más. El control CheckBox puede mostrar una imagen, texto o ambas. Tiene dos propiedades importantes:

CHECKEDLISTBOX El control CheckedListBox de los formularios Windows Forms hace casi todo lo que puede hacer un cuadro de lista y puede mostrar una marca de verificación junto a los elementos de la lista.

COMBOBOX Representa un control de cuadro combinado de Windows.

Control DateTimePicker Este control permite ingresar una fecha en una aplicación. El ingreso se realiza mediante un calendario, que muestra el control o también digitando manualmente. El usuario puede elegir la fecha dando Click en una caja que muestra un calendario de donde se puede seleccionar un día determinado. Una vez elegido el día y/o la hora, estos son mostrados en el área de texto. Propiedades: - Format: Esta propiedad permite seleccionar el formato en el cual se debe visualizar la fecha o la hora en el control. Si se selecciona Custom la fecha se mostrara con el formato establecido en la propiedad CustomFormat. Un ejemplo de formato que se puede establecer en el propiedad CustomFormat es (las letras M están en mayúsculas): CustomFormat dd-MM-yy hh:mm:ss. Si se selecciona el formato Custom en la propiedad Format, el resultado será el siguiente: 06-May-10 - Value: Esta propiedad almacena la fecha y/o hora seleccionada en el control. - MaxDate: Esta propiedad permite establecer la fecha máxima que se puede seleccionar en el calendario. En forma predeterminada la fecha máxima es 31/12/9998. - MinDate: Esta propiedad permite establecer la fecha mínima que se puede seleccionar en el calendario. En forma predeterminada la fecha mínima es 01/01/1753. -ValueChange: Tiene lugar cuando el valor del control cambia. -VisibleChange: tiene lugar cuando cambia la visibilidad del control. -Maximumsize: Especifica el tamaño máximo del control.

-Minumunsize: Tamaño mínimo del control. -Modifiers: Indica el nivel de visibilidad del objeto. -Rightoleft: Indica si el componente debe dibujar del componente. -Rightoleftlayout: Indica si el diseño del control es de derecha a izquierda, cuando la propiedad rightleft está establecida en yes. -Showcheckbox: Determina si se muestra una casilla en el control. -Showupdown: Indica si se muestra un cuadro de números en un lugar de una calendario desplegable para modificar el valor del control.[/size].

CONTROL MONTHCALEDARY El control MonthCalendar de Windows Forms muestra una intuitiva interfaz gráfica de usuario para que los usuarios vean y establezcan información relativa a fechas. El control muestra un calendario: una cuadrícula que contiene el número de días del mes, ordenado en columnas debajo de los días de la semana con el intervalo de fechas seleccionado resaltado Para seleccionar un mes diferente, puede hacer clic en los botones de fecha a los lados de la leyenda del mes. A diferencia del control DateTimePicker similar, puede seleccionar más de una fecha con este control. Para obtener más información sobre el controlDateTimePicker, vea DateTimePicker (Control, formularios Windows Forms).

LISTBOX ListBox es un control o componente de Visual Studio 2010, específicamente de tipo Aplicación de Windows Forms, de la cual forma parte de los controles comunes para crear aplicaciones, se encuentra en el cuadro de herramientas y se utiliza para poder insertar elementos, elegir elementos en forma de una lista del cual se van agregando o se encuentran agregadas a este dicho componente. Principales métodos para utilizar este control: listBox.Items.Add() este método realiza el ingreso o el agregar de un elemento a la cuadro del cual mientras cómo se van agregando se van insertado de manera ordenada en el cuadro de texto. listBox.Items.Clear() este método realiza el borrado o eliminación de todo los elementos de la lista. listBox.BackColor = Color.White esta parte de código se efectúa que el fondo del cuadro donde se insertan los elementos de la lista tome un color que el programador le asigne. listBox.SelectedItem.Equals() este método realiza la comparación de un elemento seleccionado dela lista realice o efectué cualquier tipo de instrucción que se codifique, hasta el SelectedItem toma el elemento de la lista seleccionado.

LISTVIEW El componente ListView, forma parte del cuadro de herramientas de Visual Studio, el mismo que nos muestra una lista de elementos en diferentes tipos de vistas. Se encuentran a disposición un total de 5 vistas diferentes para este comando, entre las cuales tenemos: Details, List, LargeIcon, SmallIcon y Tile. La utilidad de este componente radica en la visualización de información, ya que permite mostrar una lista de elementos con texto, y además de forma opcional, con un icono que identifique el tipo de elemento al que pertenecen. La propiedad clave del Listview es items, ya que es la que contiene los elementos que muestra el control. Reflexionar ¿Qué cosa fueron difíciles?  Todo estuvo bien explicado ¿Qué cosas fueron fáciles?  Realizar las practicas ¿Por qué?  Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres ¿Qué Aprendí Hoy? -

A usar los componentes que vienen en visual Estudio 2010. APUNTES DE CLASE

PASOS PARA REALIZAR UNA PRÁCTICA EN VISUAL STUDIO 2010, DONDE SE MOSTRARA COMO UTILIZAR CONTROLES:

CHECHKBOX y CHECKEDLISTBOX Se crea un Windows Forms

Arrastramos los controles desde ToolBox hasta el formulario: 3 CheckBox 6 Button 1 CheckedListBox

, quedando así:

Luego procedemos a asignarle propiedades a cada control del formulario: Para cambiarle el nombre a los CheckBox seleccionamos: checkBox1 y en Propiedades buscamos: y escribimos y escribimos checkBox2 y en Propiedades buscamos: y escribimos y escribimos checkBox3 y en Propiedades buscamos: y escribimos y escribimos Para cambiarle el nombre a los Button seleccionamos: button1 y en Propiedades buscamos: y escribimos y escogemos y escribimos button2 y en Propiedades buscamos: y escribimos

y escribimos button3 y en Propiedades buscamos: y escribimos y escribimos button4 y en Propiedades buscamos: y escribimos y escribimos button5 y en Propiedades buscamos: y escribimos y escribimos button6 y en Propiedades buscamos: y escribimos y escribimos Para asignarle los nombres al CheckedListBox, lo seleccionamos y en Propiedades buscamos: y escribimos damos clic en el icono que aparece a la derecha Nos muestra este cuadro en la cual escribimos los nombres que tendrá cada CheckedListBox y finalmente damos clic en Aceptar. Nos queda así el formulario, con los nombres asignado para cada uno de los controles

Ahora damos doble clic en: Botón color y escribimos este código

Botón Apariencia y escribimos este código

Botón Contar y escribimos este código

Botón Desactivar Op2 y escribimos este código

Botón Revisar y escribimos este código

Botón seleccionar todos y escribimos este código

COMBOBOX Se crea un Windows Forms

Arrastramos los controles desde ventana de Componentes quedando asi:

Textbox1= caja de texto

button 1 =fuente button 1 = llenar

Combobox1 = Button2 = botón deshabiitar Button3 =boton cambiar color

Ejemplo 1:

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace ComboBoxEjemplo { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void button1_Click(object sender, EventArgs e) { //Agregar el texto que contiene el Texbox1 al ComboBox if (textBox1.Text != "") { if (comboBox1.Text == textBox1.Text) { MessageBox.Show("Escriba otra palabra"); } else { comboBox1.Items.Add(textBox1.Text); MessageBox.Show("Hay "+comboBox1.Items.Count+" elementos"); } } else

{ MessageBox.Show("El Campo está vacío"); } } private void comboBox1_SelectedIndexChanged(object sender, EventArgs e) { //Poner el texto seleccionado en el ComboBox en el TextBox2 textBox2.Text = ""+comboBox1.SelectedItem; } private void Form1_Load(object sender, EventArgs e) { } private void button4_Click(object sender, EventArgs e) { //Cambiar la fuente comboBox1.Font = new Font("Arial", 14); } private void button2_Click(object sender, EventArgs e) { if (button2.Text == "Deshabilitar") { //Deshabilitar la selección en el ComboBox comboBox1.Enabled = false; button2.Text = "Habilitar"; } else { //Habilitar la selección en el ComboBox comboBox1.Enabled = true; button2.Text = "Deshabilitar"; } } private void button3_Click(object sender, EventArgs e) { if (button3.Text == "Cambiar Color") { //Cambiar el color del ComboBox comboBox1.BackColor = Color.Blue; button3.Text = "Sin Color"; } else { //Cambiar el color del ComboBox comboBox1.BackColor = Color.White; button3.Text = "Cambiar Color"; } }

} }

Ejemplo2 : using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace combobox { public partial class Form1 : Form { public Form1() { InitializeComponent(); } //Añadir instancias de la clase ComboItem //en nuestro comboBox. //luego modificar la propiedad DrawMode del ComboBox, y fijarla en OwnerDrawFixed. private void Form1_Load(object sender, EventArgs e) { comboBox1.Items.Add(new ComboItem("Ambato", 0)); comboBox1.Items.Add(new ComboItem("Cuenca", 1)); comboBox1.Items.Add(new ComboItem("Esmeraldas", 2)); } // en esta parte tengo el error que el nombre de la clase es ta mal o algo asi private void comboBox1_DrawItem(object sender, DrawItemEventArgs e) { ComboItem item = comboBox1.Items[e.Index] as ComboItem; e.DrawBackground(); if (item.ImageIndex >= 0 && item.ImageIndex < imageList1.Images.Count) e.Graphics.DrawImage(imageList1.Images[item.ImageIndex], new PointF(e.Bounds.Left, e.Bounds.Top)); e.Graphics.DrawString(item.Etiqueta, e.Font, new SolidBrush(e.ForeColor), new PointF(e.Bounds.Left + imageList1.ImageSize.Width + 1, e.Bounds.Top)); } }

//Ahora necesitamos crear una clase muy simple que nos permita almacenar //la etiqueta de los elementos del Combo y el índice de la imagen en el ImageList. class ComboItem { private int _imageIndex;

private string _etiqueta; public string Etiqueta { get { return _etiqueta; } set { _etiqueta = value; } } public int ImageIndex { get { return _imageIndex; } set { _imageIndex = value; } } public ComboItem(string etiqueta, int imageIndex) { this.Etiqueta = etiqueta; this.ImageIndex = imageIndex; } public override string ToString() { return Etiqueta; } } }

MONTHCALENDARY Mostrar más de un mes en el control MonthCalendar. Una vez creada la Aplicación de Windows Foms, arrastramos hacia el formulario el control MonthCaledary. Hacemos doble clic sobre el control MonthCalendary, y nos aparece la ventana de código del formulario con sus respectivos controles.

Nos posicionamos en el método monthCalendary1, escribimos la siguiente línea de código.

monthCalendar1.CalendarDimensions = new System.Drawing.Size(2, 2);

Resultados: Al iniciar la depuración del programa se ejecuta así:

Debe hacer clic en la pestaña de cambiar el mes y se muestra de la siguiente manera:

Y podemos observar que el tamaño del calendario es de 2x2 como lo indica el código.

Mostrar en negrita una fecha(s) seleccionada(s). Una vez que seleccionamos el control MonthCalendary, elegimos la propiedad MonthlyBoldedDates.

Nos aparece la siguiente ventana en la cual debemos hacer clic en Agregar.

Seleccionamos la fecha que deseamos que se ponga en negrita y damos clic en Aceptar.

Como resultado podemos observar que la fecha seleccionada se encuentra en negrita:

Mostrar los números de semana a la izquierda de cada semana. Haciendo doble clic sobre el control, posesionándonos sobre el método del control monthCalendary escribimos la siguiente sentencia: this.monthCalendar1.ShowWeekNumbers = true; Como resultado podemos observar el número de la semana ubicado en la parte izquierda:

Ejemplos de cómo utilizar DateTimePicker: Mostrar fechas: Usar los controles MonthCalendar y DateTimePicker. Cómo: Mostrar la fecha y la hora en una aplicación Para mostrar una fecha mediante un control MonthCalendar: En el menú Archivo, haga clic en Nuevo proyecto. Aparecerá el cuadro de diálogo Nuevo proyecto. Haga clic en Aplicación de Windows Forms y, a continuación, en Aceptar. Agregue un control Label al formulario, con el nombre predeterminado Label1. Agregue un control MonthCalendar al formulario, con el nombre predeterminado MonthCalendar1. Haga doble clic en el formulario para agregar el controlador predeterminado del evento Load en el Editor de código y agregue el siguiente código. Este código asigna la fecha seleccionada (la fecha de hoy) a la propiedad Text de la etiqueta en el formato de fecha corto.

this.label1.Text = this.monthCalendar1.SelectionRange.Start.ToShortDateString();

Cree un controlador del evento DateChanged para el control MonthCalendar1. Para ello, sólo tiene que hacer doble clic sobre el control en el diseñador. Agregue el código siguiente al controlador del evento MonthCalendar_DateChanged. Este código establece la etiqueta en la fecha seleccionada, pero esta vez en formato de fecha largo this.label1.Text = this.monthCalendar1.SelectionRange.Start.ToShortDateString();

Presione F5 para ejecutar el programa. Cuando el formulario se abra, cambie la fecha haciendo clic en una fecha en el control MonthCalendar. Compruebe que la fecha se haya actualizado en la etiqueta.

Para mostrar la hora con el control DateTimePicker:

Agregue un control DateTimePicker al formulario, con el nombre predeterminado DateTimePicker1. Haga doble clic en el diseñador para cambiar al Editor de código. Agregue el código siguiente al controlador del evento Form1_Load. Este código establece el formato d-el control para mostrar una hora, en lugar de una fecha, y permite al usuario cambiar la hora que se muestra. Agregue un control Button al formulario y cambie las propiedades siguientes.

Propiedad

Valor

Name

horaActual

Text

Hora actual

Agregue el código siguiente para establecer la hora en la hora actual.

this.dateTimePicker1.Value = DateTime.Now;

Presione F5 para ejecutar el programa. Cuando el formulario se abra, cambia la hora seleccionando la hora, minuto o segundo y haga clic en la flecha arriba o abajo. Haga clic en Hora actual para restablecer el control a la hora actual.

LISTBOX La aplicación se basa en insertar nombres de colores, de los cuales se insertaran mediante un botón que realice esta acción, también se podrá realizar que mientras se selecciona un color se ejecuta la instrucción de cambiar el fondo de la listBox además de limpiar o eliminar los elementos de dicha lista. Insertar elementos: - Para insertar elementos en la caja de texto se escribe el nombre del color a insertar.

LISTVIEW

Ejemplos:

Usamos para este ejemplo, un ListView con vista tipo detallada, para mostrar la información guardada en él.

Semana N° 4 Día 3: Clase 8 CLASE N°:

8

PERÍODO

27/05/2013 al 31/05/2012

TIEMPO:

1 Horas

FECHA:

31/05/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

Contenidos  Windows Forms

 Principales controles  Propiedades Objetivos de Desempeño  Crear interfaces gráficas amigables y flexibles. 

Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.



Crear funciones utilizando datos por valor y referencia.



Programar métodos que muestren características de bajo acoplamiento y alta cohesión.



Construir módulos que valida el ingreso de datos para la integridad de la información

Competencia General  Identificar los métodos a programar en la construcción de un sistema 

Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.



Utilizar programación modular.



Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.

Datos Interesados Discutidos Actividades Durante la Clase - Hubieron exposiciones de Compañeros -

Cada estudiante iba haciendo sus prácticas de cada tema expuesto 

MaskedTextBox



NotifyIcon



Tooltip.

Descriptores Analizados - MaskedTextBox -

NotifyIcon

-

Tooltip.

Conceptos de los Descriptores Analizados

MASKEDTEXTBOX Constructor MaskedTextBox

Sobrecargado. Inicializa una nueva instancia de la clase MaskedTextBox.

NOTIFYICON

Según (MSDN, página oficial de Windows) dice: “El componente NotifyIcon de formularios Windows Forms muestra iconos en el área de notificación de estado de la barra de tareas para procesos que se ejecutan en segundo plano y que, de otro modo, no tendrían interfaz de usuario‖. Como su propio nombre lo indica el notifyicon, es un icono de notificación que tiene sus métodos, eventos y propiedades las cuales pueden ser modificadas ya sea desde la ventana de propiedades o por medio de la programación correspondiente.

Tooltip Según un blog ubicado en la página de "librosweb" 1dice: ―Los tooltips son pequeños recuadros de información que aparecen al posicionar el ratón sobre un elemento. Normalmente se utilizan para ofrecer información adicional sobre el elemento seleccionado o para mostrar al usuario pequeños mensajes de ayuda". Cuando utilizamos un ToolTip en Visual Studio, solo puede ser utilizado directamente sobre un control de Windows Forms, por ejemplo un TextBox, una Label, un Button, etc., ya que solo acepta dos parámetros; el control y la cadena de Texto que mostrará. Reflexionar ¿Qué cosa fueron difíciles?  Todo estuvo bien explicado

1 Página Oficial: (http://librosweb.es/javascript/capitulo_8/tooltip.html)

¿Qué cosas fueron fáciles?  Realizar las practicas ¿Por qué?  Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres ¿Qué Aprendí Hoy? -

A usar los componentes que vienen en visual Estudio 2010. APUNTES DE CLASE

Practica con:

MASKEDTEXTBOX 1.-Para realizar este ejercicio empezamos creando un formulario WindowsForms

2.- Luego nos dirigimos al cuadro de herramientas seleccionamos el MaskedTextBox y lo arrastramos al Formulario.

3.- También arrastramos el Control Label, para añadir etiqueta a los MaskedtextBox que colocaremos a continuación

4.- Luego añadimos la máscara con la propiedad Mask o click en la flechita del MaskedTextBox como veremos a continuación.

5.-Luego podemos dar click en ―Establecer máscara‖ o en Mask y aparecerá la siguiente ventana. Y podremos elegir cualquier formato de máscara.

6.-Luego realizamos el mismo procedimiento para el resto de MaskedTextBox y tendremos el siguiente formulario

7.- Agregamos un toolTip para en este caso mostrar un mensaje al momento de que no sea válido el dato ingresado.

8.- Con esto terminamos la parte gráfica y ahora procedemos al código de los MaskedTexBox. Al hacer doble click en cada MaskedTextBox nos muestra la línea del evento void maskedTextBox1_MaskInputRejected(object sender, MaskInputRejectedEventArgs e) { toolTip1.ToolTipTitle = "entrada incorrecta"; toolTip1.Show("solo registrar datos desde (0-9)", maskedTextBox1, maskedTextBox1.Location, 2000);

PRACTICA CON:

NOTIFYICON y TOOLTIP Pasos: 1. Ingresamos a Visual Studio y se crea un nuevo proyecto. 2. En propiedades de formulario cambiamos de titulo en Text.

3. Para que el proyecto se lleva a cabo necesitamos 4 objetos: Un Boton, el NotifyIcon, ContextMenuStrip y el ToolTip

4. Colocamos los componentes Boton, y ContextMeuStrip donde nosotros deseemos en la ventana 5. Hacemos Clic en ContextMenuStrip y escribimos las opciones que aparecerán cuando este la ventana minimizada

6. Escribimos las opciones salir, restaurar y ocultar

7. Ahora en el notifyIcon damos clic sobre

una flechita superior que tiene y nos pedirá

escoger un icono el cual lo podemos elegir dependiendo de la ruta donde tengamos el icono deseado.

8.

En Propiedades de NotifyIcon modificamos de la siguiente manera:

9. Ahora vamos a empezar a darle código a nuestro Programa 10. Empezamos escribimiendo un método llamado Minimizar

11. Lo llamamos del Botón con el método Minimizar()

12. Ingresamos el código siguiente en Restaurar. this.Show() this.WindowState = FormWindowState.Normal

13. En La Sección Ocultar ingresamos el siguiente codigo:

this.WindowState = FormWindowState.Minimized this.Hide()

14. En Salir ingresamos el siguiente código:

NotifyIcon1.Visible = False

15. Creamos un método Tip() con el código que se muestra a continuación en el formulario.

ToolTip1.SetToolTip(Button1, "EL MOUSE ESTA SOBRE ESTE BOTON")

Semana N° 5 Día 1: Clase 9 CLASE N°:

9

PERÍODO

03/06/2013 al 07/06/2012

TIEMPO:

2 Horas

FECHA:

03/06/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

Contenidos  Windows Forms

 Principales controles  Propiedades Objetivos de Desempeño  Crear interfaces gráficas amigables y flexibles. 

Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.



Crear funciones utilizando datos por valor y referencia.



Programar métodos que muestren características de bajo acoplamiento y alta cohesión.



Construir módulos que valida el ingreso de datos para la integridad de la información

Competencia General  Identificar los métodos a programar en la construcción de un sistema 

Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.



Utilizar programación modular.



Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.

Datos Interesados Discutidos Actividades Durante la Clase - Hubieron exposiciones de Compañeros -

Cada estudiante iba haciendo sus prácticas de cada tema expuesto 

PictureBox



ProgressBar



RadioButton



TreeView



NumericUpDown



GroupBox



TabControl



MenuStrip



ContextMenuStrip

Descriptores Analizados - PictureBox -

ProgressBar

-

RadioButton

-

TreeView

-

NumericUpDown

-

GroupBox

-

TabControl

-

MenuStrip

-

ContextMenuStrip

Conceptos de los Descriptores Analizados

PictureBox PictureBox es un control de Visual Studio 2010, específicamente de tipo Aplicación de Windows Forms, la cual forma parte de los controles comunes para crear aplicaciones, lo podemos encontrar en el cuadro de herramientas y la utilizamos para mostrar imágenes.

PROPIEDADES Nombre Descripción ErrorImage

Nombre Descripción

Imagen que se muestra cuando falla la carga de otra imagen.

GenerateMember

Indica si se genera una varible miembro para este componente.

Image

Imagen mostrada en el control PictureBox

ImageLocation

Disco o ubicación web desde la que carga la imagen.

WaitOnLoad

Controla si el procesamiento se detendrá hasta que la imagen se cargue.

ProgressBar Muestra una barra que se va completando para mostrar al usuario el progreso de una operación.

PROPIEDADES

Nombre Descripción Step

Nombre Descripción

Cantidad por la que aumentar el valor actual del control cuando se emplea el método PerformStep().

Style

Esta propiedad permite al usuario establece el estilo de progressbar.

Value

Valor actual de progressbar, en el intervalo especificado por las propiedades de mínimo y máximo.

RadioButton Permite al usuario seleccionar una única opción de entre una lista de opciones cuando están emparejadas con otros RadioButtons.

PROPIEDADES

Nombre Descripción

Nombre Descripción

CheckAlign

Determina la ubicación de la casilla dentro del control.

Checked radio esta activado o no.

TextAlign

Indica si el botón de

Alineación del texto que se mostrar en el control.

TreeView Muestra una colección jerárquica de elementos con etiquetas, representado cada uno por un TreeNode. La colección Nodes contiene todos los objetos TreeNode asignados al control TreeView. A los nodos de árbol de esta colección se les conoce como los nodos de árbol raíz. Cualquier nodo de árbol que se agregue posteriormente a un nodo de árbol raíz se conoce como nodo secundario.

NumericUpDown Representa un cuadro de número de Windows (también conocido como control de flechas) que muestra los valores numéricos. Un control NumericUpDown contiene un único valor numérico que se puede aumentar o disminuir al hacer clic en los botones Arriba o Abajo del control. El usuario también puede escribir un valor, a menos que la propiedad ReadOnly se haya establecido en true.

GroupBox El cuadro de grupo es un control contenedor que puede utilizarse para definir grupos de controles. El GroupBox muestra un marco alrededor de un grupo de controles con o sin título. Generalmente se Utiliza un GroupBox para agrupar de forma lógica una colección de controles en un formulario. Un contenedor de componentes es una clase especializada que actúa como medio para organizar y contener componentes.

El GroupBox se encuentra dentro del cuadro de herramientas del IDE Visual C#, más específicamente en la parte donde están los contenedores:

Principales propiedades del GroupBox: Backcolor: sirve para colocarle un color de fondo al control. BackgroundImage: sirve para colocar una imagen de fondo al control. BackgroundImageLayout: sirve para ajustar la imagen colocada en el control. Cursor: sirve para elegir el tipo de cursor que se va a visualizar en el control. Enabled: sirve para bloquear o desbloquear al control de acuerdo al valor booleano que se le dé. Font: sirve para asignarle un tipo y tamaño de letra al control. Forecolor: sirve para cambiar el color de letra en el control. Text: sirve para colocarle un título al control.

Tabcontrol Ventanas TabControl es un control útil que permite mostrar varios cuadros de diálogo de pestañas en una única forma de cambiar entre las pestañas. Una ficha actúa como otra forma que puede albergar otros controles.

MenuStrip Añade una barra de menú en su programa de Windows Forms. Con este control, se añade un área de menú y, a continuación añadimos los menús predeterminados o crear menús personalizados directamente en Visual Studio. Se demuestra la MenuStrip y ofrecemos algunos consejos de uso.

Entre las principales características de este objeto tenemos las siguientes: Crear fácilmente menús personalizados y comúnmente empleados compatibles con la interfaz de usuario avanzada y con las características de diseño, como la alineación y orden de texto e imágenes, operaciones de arrastrar y colocar, MDI, desbordamiento y modos alternativos de acceso a comandos de menú. Compatibilidad con el comportamiento y aspecto típico del sistema operativo. Controlar de forma coherente los eventos para todos los contenedores y los elementos contenidos, al igual que controla los eventos para otros controles.

Imagen Un elemento de menú puede mostrar una imagen, además de un título textual. Debido a varios casos de control diferentes a menudo utilizan la misma imagen, las imágenes no se almacenan en la instancia del control en sí. Por el contrario, las imágenes se almacenan en un archivo de recursos. Imágenes se añaden a un archivo de recursos utilizando el cuadro de diálogo Seleccionar recurso se muestra en la siguiente figura.

Ilustración 1 Asignación de Iconos a ítems ContextMenuStrip Los menús contextuales aparecen en la posición del mouse (ratón) cuando el usuario hace clic con el botón secundario. Los menús contextuales proporcionan opciones para el área de cliente o el control en la ubicación del puntero del mouse.

Reflexionar ¿Qué cosa fueron difíciles?  Todo estuvo bien explicado ¿Qué cosas fueron fáciles?  Realizar las practicas ¿Por qué?  Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres ¿Qué Aprendí Hoy?

-

A usar los componentes que vienen en visual Estudio 2010. APUNTES DE CLASE

Practica:

PICTUREBOX 1. Creamos un nuevo proyecto

2. Luego agregamos los componentes que se va a utilizar del toolbox hacia el formulario.

2

Button

1 PictureBox

3

Luego procedemos a asignarle propiedades a cada control del formulario: Para cambiarle el nombre a los Button seleccionamos: button1 y en Propiedades buscamos: 

y escribimos



y escribimos

Button2 y en Propiedades buscamos:  

y escribimos y escribimos

Picturebox1 y en Propiedades buscamos:  4

y escribimos

Para asignarle las imágenes al pictureBox debemos dar click en la parte superior derecha del mismo control.

5

Ahora procedemos a codificar los eventos:

Practica:

PROGRESSBAR 1. Repetimos los pasos 1 y 2 ya descritos anteriormente.

2. Luego procedemos a asignarle propiedades a cada control del formulario: Para cambiarle el nombre a los Button seleccionamos: button1 y en Propiedades buscamos: 

y escribimos



y escribimos

button2 y en Propiedades buscamos: 

y escribimos



y escribimos

button2 y en Propiedades buscamos: 

y escribimos

textBox1 y en Propiedades buscamos: 

y escribimos

3. Ahora procedemos a codificar los eventos:

Practica:

RADIOBUTTON 1. Repetimos los pasos 1 y 2 ya descritos anteriormente.

2. Luego procedemos a asignarle propiedades a cada control del formulario:

Para cambiarle el nombre a los RadioButton seleccionamos: Radiobutton1 y en Propiedades buscamos: 

y escribimos



y escribimos

Radiobutton2 y en Propiedades buscamos: 

y escribimos



y escribimos

Button1 y en Propiedades buscamos:  

y escribimos y escribimos

Label1 y en Propiedades buscamos: 

y escribimos

4. Ahora procedemos a codificar los eventos:

PRACTICA CON:

TREEVIEW A continuación se desarrollara un ejemplo haciendo uso del TreeView: 1. Se crea un nuevo proyecto de tipo Aplicación de Windows Forms. 2. Se arrastra hacia la ventada del diseñador el control TreeView.

3. Se arrastra hacia la ventana del diseñador un ImageList para poder almacenar los iconos del TreeView.

4. Agregamos imágenes al ImageList, desde la ventana de Tareas del ImageList seleccionamos Elegir imágenes y rápidamente se nos presentara el Editor de la colección Imágenes en donde agregaremos las imágenes que deseemos dando clic en el botón Agregar.

5. Desde la ventana de Tareas de TreeView le agregamos el ImageList

6. Desde la ventana de Tareas de TreeView elegimos la opción Editar nodos, en donde tendremos el Editor de TreeNode, en donde tendremos la opción de agregar nuevos nodos de tipo raíz y secundario según sea la aplicación y al mismo tiempo desde el menú de propiedades se podrá colocar una imagen de ImageList al Nodo, una ves agregados los nodos deseado aceptamos para guardar los cambios

7. Agregamos tres botones a nuestra ventana, los cuales cumplirán las funciones de Agregar Nodo, Eliminar Nodo y Eliminar Node

8. Procedemos a codificar los eventos para cada uno de los botones.

9. Ejecutar la aplicación y comprobar resultados. PRACTICA CON:

NUMERICUPDOWN Ejemplo de aplicación del NumericUpDown y algunas de sus propiedades: 1. Se crea un nuevo proyecto de tipo Aplicación de Windows Forms. 2. Se arrastra hacia la ventada del diseñador el control NumericUpDown.

3. Desde la ventana de propiedades modificamos los valores del NumericUpDown del tal manera que establecemos un máximo, un mínimo y un incremento.

4. Agregamos 3 botones que nos permitirán capturar las propiedades actuales del NumericUpDown como máximo, mínimo e incremento, otro para poder limpiar los TextBoxs y otro para poder agregar nuevos valores a las propiedades y 4 Textboxs.

5. Codificamos los eventos de los botones.

6. Ejecutar la aplicación y verificar resultados.

PRACTICA CON:

CONTEXTMENUSTRIP

Pasos para usar un ContextMenuStrip:  Abrimos el visual estudio 2010  Creamos un nuevo proyecto  De la barra de herramientas arrastramos textbox, label y botones hasta que nos quede el formulario de esta forma

 A continuación vamos al cuadro de herramientas y en ―Menús y barras de Herramientas‖ seleccionamos la opción ContextMenuStrip

 Una ves seleccionada la opcion lo insertamos en el formulario, y nos aparecera la herrameinta seleccionada. Le ponemos el nombre en el recuadro que dice ―Escribe aqui‖ según lo que deseamos hacer en este menu.

En mi caso mi programa es sobre la suma, resta, multiplicacion y division de dos numeros.

 Para poder activar el menú median otro objeto, lo que tenemos que hacer es seleccionar el objeto en nuestro caso es el botón ―Elija lo que desea calcular‖, y en las propiedades buscamos la propiedad siguiente:

 Al hacer esto estamos diciendo que al darle clic derecho al botón se nos presente el ContextMenuStrip con las opciones que

pusimos en los pasos anteriores.

 Lo siguiente que haremos es programar cada una de las opciones, esto lo hacemos de la misma forma que programar en un botón.  Le damos doble clic en la opción para que nos aparezca la ventana de código.

CÓDIGO DEL EJERCICIO SOBRE ContextMenuSTrip using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace WindowsFormsApplication1 { public partial class Form1 : Form { public Form1() { InitializeComponent();

}

private void cerrarToolStripMenuItem_Click(object sender, EventArgs e) { if (textBox1.Text == "" || textBox2.Text == "") { MessageBox.Show("Tiene que llenar todos los campos"); } else { int numerouno = Convert.ToInt32(textBox1.Text); int numerodos = Convert.ToInt32(textBox2.Text);

int resp = (numerouno + numerodos); textBox4.Text = Convert.ToString(resp); }

} private void rESTAToolStripMenuItem_Click(object sender, EventArgs e) { if (textBox1.Text == "" || textBox2.Text == "") { MessageBox.Show("Tiene que llenar todos los campos"); } else { int numerouno = Convert.ToInt32(textBox1.Text); int numerodos = Convert.ToInt32(textBox2.Text);

int resp = (numerouno - numerodos); textBox3.Text = Convert.ToString(resp); } } private void mULTIPLICACIONToolStripMenuItem_Click(object sender, EventArgs e) { if (textBox1.Text == "" || textBox2.Text == "") { MessageBox.Show("Tiene que llenar todos los campos"); } else { int numerouno = Convert.ToInt32(textBox1.Text); int numerodos = Convert.ToInt32(textBox2.Text);

int resp = (numerouno * numerodos); textBox5.Text = Convert.ToString(resp); } } private void dIVICIONToolStripMenuItem_Click(object sender, EventArgs e)

{ if (textBox1.Text == "" || textBox2.Text == "") { MessageBox.Show("Tiene que llenar todos los campos"); } else { int numerouno = Convert.ToInt32(textBox1.Text); int numerodos = Convert.ToInt32(textBox2.Text); int resp = (numerouno / numerodos); textBox6.Text = Convert.ToString(resp); } } private void lIMPIARDATOSToolStripMenuItem_Click(object sender, EventArgs e) { textBox1.Clear(); textBox2.Clear(); textBox3.Clear(); textBox4.Clear(); textBox5.Clear(); textBox6.Clear(); textBox1.Focus(); } private void sALIRToolStripMenuItem_Click(object sender, EventArgs e) { this.Close(); } private void button2_Click(object sender, EventArgs e) { } } }

PRACTICA CON:

GROUPBOX El presente formulario ha sido desarrollado para indicar las propiedades más importantes o más relevantes de este contenedor llamado GroupBox:

Lo primero que debemos hacer es crear un nuevo Proyecto: Windows Forms, arrastrar el control o contendor GroupBox y colocarlo en el formulario.

Modificamos la fuente, el tamaño y el color del texto en las propiedades: Font y forecolor. En la propiedad Font nos aparecerá un ventanita como esta para la modificación antes dicha.

Mientras que en la propiedad forecolor nos aparcera los diferentes colores que le podemos colocar al contenedor.

Ahora para poderle cambiar el color de fondo al contendor nos vamos a la propiedad BackColor y nos aparecerá un cuadro similar al anterior y seleccionamos el color que deseemos.

Lo siguiente que debemos hacer es agregar los componentes al contendor GroupBox, añadiendo cajas de texto, etiquetas y un botón, de tal manera que nos queda de esta forma:

En la parte inferior de la ventana, agregamos 6 etiquetas y 2 botones. A las etiquetas le borramos el texto de tal manera que esa propiedad Text quede vacía, mientras que a los botones les colocamos en la propiedad Text: Desbloquear y Cancelar, respectivamente.

Una vez que nos haya quedado el formulario de esa forma, procedemos a darles funciones a los botones que existen en dicho formulario: Botón enviar El botón enviar nos va a servir para enviar la información o el texto que se encuentra dentro del GroupBox a la parte inferior de la ventana donde se encuentran las etiquetas que no contienen ningún texto. Además cabe recalcar que si no se llenan todas las cajas de texto la información no se llenara en la parte inferior y además mostrara un mensaje de error.

Para colocarle el código al botón y me realice las funciones antes mencionadas, procedemos a darle doble clic al botón y escribimos dentro del método lo siguiente.

Botón Desbloquear El botón desbloquear va a permanecer bloqueado y una vez que se encuentre desbloqueado va a cumplir la función de desbloquear el GroupBox y sus componentes que están adentro una vez que el botón cancelar lo haya bloqueado. Además de limpiar las cajas de texto del GroupBox. Así mismo le damos doble clic a dicho botón y le colocamos el siguiente código:

Botón Cancelar El botón cancelar va a servir para bloquear el contenedor GroupBox y sus componentes que se encuentran adentro. Y también dejar en blanco las etiquetas que se encuentran en la parte inferior de la ventana, además de desbloquear el botón desbloquear. Para que el botón cumpla dichas funciones le damos doble clic y escribimos el siguiente código en el método:

PRACTICA CON:

TABCONTROL ¿Cómo Crear un TabControl en mi Ventana? Una vez creado nuestro proyecto, nos ubicamos en el cuadro de herramientas y buscamos la opción TabControl.

Una vez ubicados en la opción TabControl la arrastramos hacia la ventana donde deseamos usar el TabControl una vez arrastrado nos quedara algo más o menos así:

Por Default nos aparecerá dos pestañas con el nombre TabPage1 y TabPage1, y es ahí cuando surgen las interrogantes, ¿Podre poner o quitar pestañas a mi TabControl?, ¿Podre cambiar el nombre de mis pestañas de mi TabControl?, Pues la respuesta es que sí. Procederé a explicar cómo agregar o quitar pestañas de mi TabControl asi como a cambiar el nombre de las pestañas de mi tabControl de la misma manera revisaremos las demás propiedades. Agregar y Quitar pestañas de mi TabControl Lo explicare gráficamente como con código, así que gráficamente para agregar pestañas o quitarlas le damos clic a la flecha que se encuentra en la parte superior del TabControl y se nos despliegan las opciones agregar y quitar ficha dándole clic se procederá agregar o quitar según como nosotros lo manejemos.

Ahora procederé a eliminar las pestañas del TabControl y agregare dos botones donde el uno tenga como texto agregar pestaña y el otro eliminar pestaña, nos quedara algo más o menos así:

Entonces comenzamos a programar los eventos de los botones respectivamente cuando yo presione agregar pestaña se me agregué una pestaña a mi tabControl y así respectivamente con el eliminar pestaña. Nos ubicaremos en el modo programador, como lo hacemos damos doble clic sobre la ventana y nos aparecerá el código y entonces debemos escribir la librería: using System.Collections; //Es la que nos permite manejar las pestañas en modo de arrayList Declaramos un arrayList yo utilizare el nombre pestana el objeto pestana se encarga de almacenar cada pestaña, con esto tendremos control sobre la pestaña a tenerla almacenada y el código para declarar un arrayList quedaría así: ArrayList pestana = newArrayList(); Lo siguiente que realizare será declarar una variable int con el nombre contarPestana, la variable contarPestana, lleva un control sobre la cantidad de pestaña que llevamos almacenado en el objeto pestana, de esta manera podemos eliminar pestaña por medio de índice de esta variable y la sintaxis quedaría así: int contarPestana = 0; Ahora voy a crear el método crearPestana() como su nombre indica es para crear pestaña en tiempo de ejecución, en este método procederé añadir lo siguiente: Private void crearPestana() { // Creo una nueva Pestaña TabPage nuevaPestana = new TabPage("Nueva Pestaña " + contarPestana); // Creamos una nueva pestaña

pestana.Add(nuevaPestana); // cada pestaña creada los añadimos en un arraylist tabControl1.TabPages.Add(nuevaPestana); //cargamos la pestaña en el control contarPestana++; //variable que lleva el control de la cantidad de pestaña creada tabControl1.SelectedTab = nuevaPestana; //seleccionamos la pestaña } Lo que realizo en el código es primero crear un TabPage que no es más que una pestaña por medio de constructor de objeto le pasamos en título que queremos que tenga la pestaña. Una vez que eh creado una pestaña guardo esa pestaña con su título en el ArrayList pestana luego cargo esa pestaña en el control TabControl1 (es el nombre de mi tabControl). Incremento la variable contarPestana, luego marco la pestaña recién creada como seleccionada mediante las propiedades de TabControl.SelectedTab le paso la pestaña recién creada. Luego nos vamos al modo diseñador y damos doble clic sobre el botón crear pestaña y dentro del evento coloco el nombre del método, ósea llamo al método crearPestana, y tendremos algo más o menos así:

Ejecutando podremos observar que nuestro trabajo puede hacer esto: Ventana de inicio (ventana como se ejecuta inicialmente)

Una vez presionando agregar pestana (procedí a agregar 2 pestañas)

Procederé a trabajar con el eliminar pestaña, tendremos un código así:

private void EliminarPestana() { TabPage vacio = tabControl1.SelectedTab; pestana.Remove(vacio); tabControl1.TabPages.Remove(vacio); contarPestana--; } Como se ve el código del método es bastante corto, primero creamos un TabPage vació, y le paso la pestaña que tengo seleccionada para eliminar. Luego elimino las pestaña de las lista, y también de TabControl1 y por últimos restamos un -1 a la variable contarPestana. El código mejorado poniéndole al eliminar pestaña un controlador de que cuando no se agregado pestañas y se quiera eliminar mostrar un mensaje, entonces el código completo quedaría así: using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Collections; //Es la que nos permite manejar las pestañas en modo de arrayList namespace WindowsFormsApplication1 { public partial class Form1 : Form { ArrayList pestana = new ArrayList(); int contarPestana = 0; public Form1() { InitializeComponent(); } private void crearPestana() { // Creo una nueva Pestaña TabPage nuevaPestana = new TabPage("Nueva Pestaña " + contarPestana); // Creamos una nueva pestaña pestana.Add(nuevaPestana); // cada pestaña creada los añadimos en un arraylist tabControl1.TabPages.Add(nuevaPestana); //cargamos la pestaña en el control contarPestana++; //variable que lleva el control de la cantidad de pestaña creada tabControl1.SelectedTab = nuevaPestana; //seleccionamos la pestaña } private void EliminarPestana() { if (contarPestana = toolStripProgressBar1.Maximum) { timer1.Enabled = false; MessageBox.Show("En hora buena...ha cargado con exito"); toolStripStatusLabel1.Text = "Carga Completa"; }

}

private void cargarNuevamenteToolStripMenuItem_Click(object sender, EventArgs e) { toolStripProgressBar1.Value = 0; timer1.Enabled = true; timer1.Interval = 50; toolStripStatusLabel1.Text = "Cargando nuevamente..."; }

private void limpiarBarraToolStripMenuItem_Click(object sender, EventArgs e) { toolStripProgressBar1.Value = 0;

toolStripStatusLabel1.Text = "Barra de progreso"; } } }

Práctica con la herramienta:

TIMER Practica: Crear un semáforo en C# utilizando el componente Timer:

Para Iniciar el semáforo Hay que darle clic en el botón que dice encender el cual va a habilitar los dos botones siguientes de ―Detener‖ y ―Apagar‖ y bloqueara al botón ―Encender‖ ya que no se puede encender el semáforo si ya esta encendido además de poner en el label un mensaje indicando que el semáforo se encuentra activo.

Para pausar el semáforo Se da clic en el botón ―Detener‖ el cual una vez presionado pausara el timer que se encuentra activado y el botón cambiara el nombre a ―Reanudar‖, cuando se de clic en ―Reanudar‖ activara de nuevo el temporizador del timer.

Para Apagar el semáforo Dar clic en el último botón que se llama ―Apagar‖ la función principal de este botón es finalizar el timer con un método que se llama Stop(), desactivando los demás botones y dejando activado solo el botón de ―Encender‖ activado.

¿Cómo funciona el timer en este programa? El uso del timer en este programa es que en cada intervalo diferente de tiempo, hacer el el picturebox cargue una imagen diferente del semáforo, por medio de un case de una forma infinita hasta que el usuario de clic en el botón ―Apagar‖ para que finalice el timer con el método Stop(); todo el proceso se lo debe realizar en el único método que tiene el timer que se llama Tick

Práctica con la herramienta:

ERROR PROVIDER Practica: Validar un formulario para que el usuario no pueda dejar casilleros vacíos

Cuando se da clic en comprobar lo que hace el programa es comprobar si cualquiera de los tres textBox estén vacios y si en caso de estarlos nos saldrá una notificación indicando en que componente se encentra el error:

La forma para controlar esto es muy sencilla: hay que validar cada textBox utilizando un ―if‖ y en caso que se cumpla la condición dada se utiliza el componente error proveer utilizando su método que se llama setError en el que se envían dos parámetros, el primero es el componente donde se encuentra el

error y el segundo es una mensaje que queramos que se muestre cuando pasemos el mouse sobre el la notificación de error.

Práctica con la herramienta:

COLORDIALOG En el siguiente ejemplo, se aplicaran las funciones que nos brinda el Colordialog:

2

1 3

Color de Letra: nos permite cambiar el color de fuente del texto ubicado en el textbox

Color de Fondo: permite cambiar de color al fondo de del textbox

Fondo de Panel: permite cambiar el color de fondo del GroupBox ColorDialog

A continuación se muestra las líneas de código utilizadas para la práctica: private void button1_Click(object sender, EventArgs e) { if (colorDialog1.ShowDialog() == DialogResult.OK) //si el dialogo es abierto se consulta si el boton aceptar fue presionado

{ textBox1.ForeColor = colorDialog1.Color; //cambia de color el texto del textbox } }

private void button2_Click(object sender, EventArgs e) { if (colorDialog1.ShowDialog() == DialogResult.OK) { textBox1.BackColor = colorDialog1.Color; //cambia de color de fondo de la caja de texto } }

Práctica con la herramienta:

FOLDERBROWSERDIALOG Para elegir carpetas con el componente FolderBrowserDialog En un procedimiento, compruebe la propiedad DialogResultdel componente FolderBrowserDialog para ver cómo se cerró el cuadro de diálogo y obtener el valor de la propiedad SelectedPath del componente FolderBrowserDialog. Si necesita definir la carpeta de nivel más alto que aparecerá en la vista de árbol del cuadro de diálogo, establezca la propiedad RootFolder, que toma el miembro de la enumeración SpecialFolder. Asimismo, puede definir la propiedad Description, que especifica la cadena de texto que aparece en la parte superior de la vista de árbol del explorador de carpetas. En el siguiente ejemplo, se aplicaran las funciones que nos brinda el FolderBrowserDialog:

1

2

Dirección de una carpeta: nos permite obtener la dirección completa de una carpeta a buscar

Botón nueva carpeta: permite establecer el botón ―crear nueva carpeta‖ en el cuadro de diálogo FolderBrowserDialog

El mismo que nos permite crear carpetas donde nosotros queramos

El código de esta sección es el siguiente:

private void button4_Click(object sender, EventArgs e) { //indica que el boton crear nueva carpeta no esta visible folderBrowserDialog1.ShowNewFolderButton = false;

// descripcion del dialogo folderBrowserDialog1.Description = "Seleccione una carpeta para copiar su direccion";

if (folderBrowserDialog1.ShowDialog() == DialogResult.OK) { //selecciona el texto de la direccion y lo coloca en un label label1.Text = folderBrowserDialog1.SelectedPath; } }

private void button5_Click(object sender, EventArgs e) {

//indica que el boton crear nueva carpeta esta visible folderBrowserDialog1.ShowNewFolderButton = true;

folderBrowserDialog1.Description = "Puede crear una nueva carpeta, haciendo clic en el boton \"Crear Nueva Carpeta\""; folderBrowserDialog1.ShowDialog(); }

Práctica con la herramienta:

OPENFILEDIALOG y SAVEFILEDIALOG Creamos un nuevo Formulario

Agregamos diferentes herramientas al formulario 1 Boton: Abrir 1 Boton: Guardar 2 TextBox: textBox1, y textBox2

Quedando de la siguiente manera

Ingresamos el siguiente Código en cada botón haciendo doble clic en cada uno de ellos Botón: Abrir openFileDialog1.FileName = ""; openFileDialog1.Title = "Lector de archivos"; if (openFileDialog1.ShowDialog() == DialogResult.OK) { this.textBox1.Text = openFileDialog1.FileName;

StreamReader sr = new StreamReader(textBox1.Text, System.Text.Encoding.Default);

textBox2.Text = sr.ReadToEnd(); sr.Close();

Botón: Guardar

if (saveFileDialog1.ShowDialog() == DialogResult.OK) {

StreamWriter fichero = new StreamWriter(saveFileDialog1.FileName); fichero.Write(textBox2.Text);

fichero.Close(); MessageBox.Show("Se guardo el archivo: " + saveFileDialog1.FileName); }

Previamente debemos haber importado lo siguiente

using System.IO;

Al momento de Ejecutar: Clic en Abrir:

Clic en Guardar

Escogemos el nombre del archivo a guardar

Semana N° 6 Día 1: Clase 11 CLASE N°:

11

PERÍODO

10/06/2013 al 14/06/2012

TIEMPO:

2 Horas

FECHA:

10/06/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

Contenidos  Windows Forms

 Principales controles  Propiedades Objetivos de Desempeño  Crear interfaces gráficas amigables y flexibles. 

Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.



Crear funciones utilizando datos por valor y referencia.



Programar métodos que muestren características de bajo acoplamiento y alta cohesión.



Construir módulos que valida el ingreso de datos para la integridad de la información

Competencia General  Identificar los métodos a programar en la construcción de un sistema 

Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.



Utilizar programación modular.



Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.

Datos Interesados Discutidos Actividades Durante la Clase - Hubieron exposiciones de Compañeros -

Cada estudiante iba haciendo sus prácticas de cada tema expuesto 

FontDialog



PrintDialog



LineShape



OvalShape



RectangleShape

Descriptores Analizados - FontDialog -

PrintDialog

-

LineShape

-

OvalShape

-

RectangleShape

Conceptos de los Descriptores Analizados FontDialog

Pide al usuario que elija una fuente de entre todas las instaladas en el equipo local. Sintaxis

PrintDialog Invoca un cuadro de diálogo de impresión estándar de Microsoft Windows que configure PrintTicket y PrintQueue según los datos proporcionados por el usuario y después imprimir un documento. Sintaxis

Reflexionar ¿Qué cosa fueron difíciles?  Todo estuvo bien explicado ¿Qué cosas fueron fáciles?  Realizar las practicas ¿Por qué?  Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres ¿Qué Aprendí Hoy?

-

A usar los componentes que vienen en visual Estudio 2010. APUNTES DE CLASE

Práctica con la herramienta:

FONTDIALOG En el siguiente ejemplo de código se utiliza ShowDialog para mostrar FontDialog. En este código se requiere que ya se haya creado un objeto Form que incluya un objeto TextBox y un botón. También requiere que se haya creado fontDialog1. Font contiene la información de tamaño pero no la información de color. Pasos: 1. Creamos un nuevo proyecto

2. En el modo diseñador, colocamos un text y un button; cambiamos nombres como nos convenga.

3. Arrastramos el fontDialog

4. Damos doble click en el botón y nos lanzara al editor de código, donde colocaremos el siguiente código.

5. Una vez terminado regresamos al editor de diseño y ejecutamos el programa; damos click en el botón fuente y se nos abre la pantalla de la fuente de las letras, hay elegimos la fuente que queremos dar al texto que se mostrara en el texto.

Práctica con la herramienta:

PRINTDIALOG

1. Digitamos un texto en el textbox que se encuentra en el centro. 2. Luego pulsamos en el botón ―Vista Previa‖ para obtener una vista previa del documento a imprimir.

3. Luego pulsamos el botón ―Imprimir‖ donde se abrirá el printDialog para escoger los detalles de impresión.

Semana N° 6 Día 2: Clase 12 CLASE N°:

12

PERÍODO

10/06/2013 al 14/06/2012

TIEMPO:

2 Horas

FECHA:

12/06/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

Contenidos  Windows Forms

 Manejo de Excepciones en Visual Estudio C# Objetivos de Desempeño  Crear interfaces gráficas amigables y flexibles. 

Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.



Crear funciones utilizando datos por valor y referencia.



Programar métodos que muestren características de bajo acoplamiento y alta cohesión.



Construir módulos que valida el ingreso de datos para la integridad de la información

Competencia General  Identificar los métodos a programar en la construcción de un sistema 

Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.



Utilizar programación modular.



Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.

Datos Interesados Discutidos Actividades Durante la Clase - Hubieron exposiciones de Compañeros -

Cada estudiante iba haciendo sus prácticas de cada tema expuesto 

Manejo de Excepciones

Descriptores Analizados - Excepciones en C#

Conceptos de los Descriptores Analizados Manejo de excepciones estructuradas Las excepciones en C# las podemos controlar usando las instrucciones try / catch / finally. Estas instrucciones realmente son bloques de instrucciones, y por tanto estarán delimitadas con un par de llaves. Cuando queramos controlar una parte del código que puede producir un error lo incluimos dentro del bloque try, si se produce un error, éste lo podemos detectar en el bloque catch. Cuando creamos una estructura de control de excepciones no estamos obligados a usar los tres bloques, aunque el primero: try si es necesario, ya que es el que le indica al compilador que tenemos intención de controlar los errores que se produzcan. Veamos ahora con más detalle cada uno de estos bloques y que es lo que podemos hacer en cada uno de ellos. Bloque try En este bloque incluiremos el código en el que queremos comprobar los errores. El código a usar será un código normal, es decir, no tenemos que hacer nada en especial, ya que en el momento que se produzca el error se usará (si hay) el código del bloque catch. Bloque catch Si se produce una excepción, ésta la capturamos en un bloque catch. En el bloque catch podemos indicar que tipo de excepción queremos capturar, para ello usaremos una variable de tipo Exception, la cual puede ser del tipo de error específico que queremos controlar o de un tipo genérico. Por ejemplo, si sabemos que nuestro código puede producir un error al trabajar con ficheros, podemos usar un código como éste: try { // código para trabajar con ficheros, etc. } catch(System.IO.IOException ex) { // el código a ejecutar cuando se produzca ese error } Si nuestra intención es capturar todos los errores que se produzcan, es decir, no queremos hacer un filtro con errores específicos, podemos usar la clase Exception como tipo de excepción a capturar. La clase Exception es la más genérica de todas las clases para manejo de excepciones, por tanto capturará todas las excepciones que se produzcan.

try { // código que queremos controlar } catch(System.Exception ex) { // el código a ejecutar cuando se produzca cualquier error } Aunque si no vamos usar la variable indicada en el bloque Catch, pero queremos que no se detenga la aplicación cuando se produzca un error, podemos hacerlo de esta forma: try { // código que queremos controlar } catch { // el código a ejecutar cuando se produzca cualquier error }

La variable indicada en el bloque catch la podemos usar para mostrar un mensaje al usuario o para obtener información extra sobre el error, pero no siempre vamos a hacer uso de esa variable, en ese caso podemos utilizar el código anterior, en el que no se usa una variable y tampoco se indica el tipo de error que queremos interceptar. Pero es posible que nuestra intención sea capturar errores de un tipo concreto sin necesidad de utilizar una variable, en ese caso podemos crear un bloque catch como el siguiente, en el que solo se indica el tipo de excepción: try { // código que queremos controlar } catch(FormatException) {

// interceptar los errores del tipo FormatException } Varias capturas de errores en un mismo bloque try/catch En un mismo try/catch podemos capturar diferentes tipos de errores, para ello podemos incluir varios bloques catch, cada uno de ellos con un tipo de excepción diferente. Es importante tener en cuenta que cuando se produce un error y usamos varios bloques catch, el CLR de .NET buscará la captura que mejor se adapte al error que se ha producido, pero siempre lo hará examinando los diferentes bloques catch que hayamos indicado empezando por el indicado después del bloque try, por tanto deberíamos poner las más genéricas al final, de forma que siempre nos aseguremos de que las capturas de errores más específicas se intercepten antes que las genéricas. Aunque el propio compilador de C# detectará si hay capturas de errores genéricas antes que las más específicas, avisándonos de ese hecho. En el siguiente código capturamos un error específico y también uno genérico, con idea de que tengamos siempre controlado cualquier error que se produzca: try { // código que queremos controlar } catch(FormatException) { // captura de error de formato } catch(Exception ex) { // captura del resto de errores } Captura de errores no controlados Como es lógico, si no controlamos las excepciones que se puedan producir en nuestras aplicaciones, éstas serán inicialmente controladas por el propio runtime de .NET, en estos casos la aplicación se detiene y se muestra el error al usuario. Pero esto es algo que no deberíamos consentir, por tanto siempre deberíamos detectar todos los errores que se produzcan en nuestras aplicaciones, pero a pesar de que lo intentemos, es muy probable que no siempre podamos conseguirlo. Una forma de hacerlo es iniciando nuestra aplicación dentro de un bloque try/catch, de esta forma, cuando se produzca el error, se capturará en ese bloque catch, porque cuando el runtime

de .NET se encuentra con una excepción, lo que hace es revisar "la pila" de llamadas y buscar algún try/catch, si lo encuentra, lo utiliza, y si no lo encuentra, se encarga de lanzar la excepción deteniendo el programa. Esto es importante saberlo, no ya por detectar esos errores que no hemos tenido la previsión de controlar, sino porque es posible que si un error se produce dentro de un método en el que no hay captura de errores, pero antes de llamar a ese método hemos usado un try/catch, el error será interceptado por ese catch, aunque posiblemente ni siquiera lo pusimos pensando que podía capturar errores producidos en otros niveles más profundos de nuestra aplicación. Reflexionar ¿Qué cosa fueron difíciles?  Todo estuvo bien explicado ¿Qué cosas fueron fáciles?  Realizar las practicas ¿Por qué?  Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres ¿Qué Aprendí Hoy? -

A usar los componentes que vienen en visual Estudio 2010.

APUNTES DE CLASE Práctica con la Manejo de Execiones mediante:

TRY { CATCH (…){} Desarrollo de la aplicación.

using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace WindowsFormsApplication6 { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void textBox2_TextChanged(object sender, EventArgs e) { } private void txtcantidad_Leave(object sender, EventArgs e) { try { byte numero = (byte.Parse(txtcantidad.Text)); } catch (Exception a) {

MessageBox.Show("Por favor ingrese un numero valido"); txtcantidad.Text=""; txtcantidad.Focus(); } } private void txtprecio_Leave(object sender, EventArgs e) { try { byte numero = (byte.Parse(txtprecio.Text)); } catch (Exception b) { MessageBox.Show(b.GetBaseException().ToString()); txtprecio.Text = ""; txtprecio.Focus(); } } private void button1_Click(object sender, EventArgs e) { txttotal.Text = (int.Parse(txtcantidad.Text)*int.Parse(txtprecio.Text)).ToString(); } } }

Semana N° 7 Día 1: Clase 13 CLASE N°:

13

PERÍODO

01/07/2013 al 05/07/2013

TIEMPO:

2 Horas

FECHA:

01/07/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

Contenidos

 Revision de temas para expsiciones Objetivos de Desempeño  Crear interfaces gráficas amigables y flexibles. 

Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.



Crear funciones utilizando datos por valor y referencia.



Programar métodos que muestren características de bajo acoplamiento y alta cohesión.



Construir módulos que valida el ingreso de datos para la integridad de la información

Competencia General  Identificar los métodos a programar en la construcción de un sistema 

Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.



Utilizar programación modular.



Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.

Datos Interesados Discutidos Actividades Durante la Clase  A cada grupo les dio tema para exposición

Semana N° 7 Día 2: Clase 14 CLASE N°:

14

PERÍODO

01/07/2013 al 05/07/2013

TIEMPO:

2 Horas

FECHA:

03/07/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

Contenidos

 Examen Objetivo de Hemisemestre Objetivos de Desempeño  Crear interfaces gráficas amigables y flexibles. 

Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.



Crear funciones utilizando datos por valor y referencia.



Programar métodos que muestren características de bajo acoplamiento y alta cohesión.



Construir módulos que valida el ingreso de datos para la integridad de la información

Competencia General  Identificar los métodos a programar en la construcción de un sistema 

Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.



Utilizar programación modular.



Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.

Datos Interesados Discutidos Actividades Durante la Clase  La Ing. Realizo a los estudiantes un examen objetivo de fin de Hemisemestre.

Semana N° 8 Día 1: Clase 15 CLASE N°:

15

PERÍODO

15/07/2013 al 19/07/2013

TIEMPO:

2 Horas

FECHA:

15/07/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

Contenidos

 Revision de Examen Objetivo de Hemisemestre Objetivos de Desempeño  Crear interfaces gráficas amigables y flexibles. 

Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.



Crear funciones utilizando datos por valor y referencia.



Programar métodos que muestren características de bajo acoplamiento y alta cohesión.



Construir módulos que valida el ingreso de datos para la integridad de la información

Competencia General  Identificar los métodos a programar en la construcción de un sistema 

Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.



Utilizar programación modular.



Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.

Datos Interesados Discutidos Actividades Durante la Clase  La Ing. Realizo la correcion del examen hecha a los estudiantes un examen objetivo de fin de Hemisemestre. APUNTES DE CLASE - Correcion de la Pureba

1. Private Button btnImprimir = new Button(); Respuesta: Crea un control button, Instancia un control button

2. Una variable del instancia -----Respuesta: Es un objeto de una clase, Representa un atributo de un objeto

3. Que devuelve la siguiente función: Using System; Class Q1: System.NullReferenceException{ static int Main(){ Try{ String valor=‖Value: ‖+(Q1)null; return valor.length;}catch(Q1 q){Throw;}} public static string operator +(String msg, Q1 q){return msg+1;}} Respuesta: Se produce un StackOverFlowExeception

4. Que hace: class prueba:Form{} Respuesta: Crea la clase prueba que hereda de la clase form

5. Una variable declarada dentro de un método se llama variable Respuesta: Local

6. Encuentra algún error en el constructor CuentaBancaria Public int CuentaBancaarioao

Semana N° 8 Día 2: Clase 16 CLASE N°:

16

PERÍODO

15/07/2013 al 19/07/2013

TIEMPO:

2 Horas

FECHA:

17/07/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

Contenidos  Windows Forms

 Manejo de Excepciones en Visual Estudio C# Objetivos de Desempeño  Crear interfaces gráficas amigables y flexibles. 

Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.



Crear funciones utilizando datos por valor y referencia.



Programar métodos que muestren características de bajo acoplamiento y alta cohesión.



Construir módulos que valida el ingreso de datos para la integridad de la información

Competencia General  Identificar los métodos a programar en la construcción de un sistema 

Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.



Utilizar programación modular.



Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.

Datos Interesados Discutidos Actividades Durante la Clase - Hubieron exposiciones de Compañeros -

Cada estudiante iba haciendo sus prácticas de cada tema expuesto 

Valores automáticas y validación de datos

Descriptores Analizados - Valores automáticos y validación de datos VALORES AUTOMÁTICOS EN C# Es posible establecer una columna de un DataTable para que sea una clave principal de incremento automático con el fin de garantizar que haya un valor único para cada fila de la tabla. Sin embargo, es posible tener varios clientes de la aplicación y cada uno de esos clientes puede trabajar con una instancia diferente de la tabla DataTable. En este caso, podría haber valores duplicados en las distintas instancias de la DataTable. Como todos los clientes trabajan con un único origen de datos, es posible resolver este conflicto si se permite que el origen de datos defina el valor de incremento automático. Para ello se utilizan columnas de identidad en Microsoft SQL Server o campos Autonumérico en Microsoft Access. El uso del origen de datos con el fin de llenar una columna Identidad o Auto numérica para una nueva fila agregada a un DataSet crea una situación única, ya que el DataSet no tiene conexión directa con el origen de datos. Por tanto, el DataSet no conoce los valores generados automáticamente por el origen de datos. Sin embargo, con un origen de datos que pueda crear procedimientos almacenados con parámetros de salida, como Microsoft SQL Server, se pueden especificar los valores generados automáticamente, como un nuevo valor de identidad, como parámetro de salida, y utilizar DataAdapter para volver a asignar el valor a la columna del DataSet. Puede que el origen de datos pertinente no admita procedimientos almacenados con parámetros de salida. En este caso es posible utilizar el evento RowUpdated para recuperar un valor generado automáticamente y ponerlo en la fila insertada o actualizada del DataSet. Esta sección incluye un ejemplo que muestra cómo se puede utilizar Microsoft Access 2000 o posterior y el proveedor de datos OLE DB de Jet 4.0 con el fin de agregar código al evento RowUpdated para determinar si se ha producido una inserción y recuperar el valor de incremento automático y almacenarlo en la fila actualizada en estos momentos.

Recuperar valores de columnas de identidad de SQL Server El procedimiento almacenado y el ejemplo de código siguientes muestran cómo asignar el valor de identidad de incremento automático desde una tabla de Microsoft SQL Server a su columna correspondiente en una fila agregada a una tabla de un DataSet. El procedimiento almacenado se utiliza para insertar una nueva fila en la tabla Categories de la base de datos Northwind y para devolver el valor de identidad devuelto por la función Transact-SQL SCOPE_IDENTITY() como parámetro de salida. VALIDACION DE DATOS Puede aplicar reglas de validación a una entidad o tabla para asegurarse de que se escriben datos con formato correcto en el origen de datos. Una regla de validación es una condición o una restricción que deben cumplir los datos de la aplicación. Puede agregar una o más reglas de validación a una entidad o tabla en LightSwitch. Si un usuario agrega o cambia datos y esos datos no cumplen las reglas de validación, LightSwitch muestra un error. Antes de que un usuario pueda confirmar los datos, debe solucionarse el error de validación. Reflexionar ¿Qué cosa fueron difíciles?  Todo estuvo bien explicado ¿Qué cosas fueron fáciles?  Realizar las practicas ¿Por qué?  Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres ¿Qué Aprendí Hoy? -

A usar los componentes que vienen en visual Estudio 2010.

APUNTES DE CLASE PRACTICA VALIDACION DE DATOS INTERFAZ

MÉTODOS

VALIDATING

CODIGO PARA VALIDAR CAMPOS NULOS private void textBox2_Validating(object sender, CancelEventArgs e) {

if (txtCantidades.Text.Trim() == "") { MessageBox.Show("INGRESE NUMERO"); e.Cancel = true; }

}

CODIGO PARA VALIDAR CAMPOS NULOS private void txtNombres_Validating(object sender, CancelEventArgs e) { if (txtNombres.Text.Length == 0) { MessageBox.Show("Necesita escribir Nombres"); e.Cancel = true; } }

CODIGO PARA VALIDAR INGRESO DE CIFRAS private void txtPrecios_Validating(object sender, CancelEventArgs e) { try { double numero = Double.Parse(txtPrecios.Text); }catch(System.FormatException){ MessageBox.Show("No es una cifra"); e.Cancel = true; } }

CODIGO PARA VALIDAR EL INGRESO DE CORREOS ELECTRONICOS private void txtCorreo_Validating(object sender, CancelEventArgs e) { if (txtCorreo.Text.IndexOf('@') == -1 || txtCorreo.Text.IndexOf('.') == -1) { MessageBox.Show("Correo Invalido!"); e.Cancel = true; }

} VALIDATED

CODIGO PARA VALIDAR INGRESO DE CAMPOS NULOS private void txtNombres_Validated(object sender, EventArgs e) { if (txtNombres.Text.Length==0) { MessageBox.Show("Necesita escribir Nombres"); } }

EVENTOS

KEYPRESS

CODIGO PARA VALIDAR INGRESO DE LETRAS Y ESPACIOS private void txtNombres_KeyPress(object sender, KeyPressEventArgs e) { if (!Char.IsLetter(e.KeyChar)&&e.KeyChar!=(char)Keys.Back&&e.KeyChar!=(char)Keys.Space) e.Handled = true; }

CODIGO PARA VALIDAR INGRESO DE NUMEROS private void txtPrecios_KeyPress(object sender, KeyPressEventArgs e) { if (Char.IsLetter(e.KeyChar)) e.Handled = true; }

CODIGO PARA VALIDAR INGRESO DE CANTIDADES private void txtCantidades_KeyPress(object sender, KeyPressEventArgs e) { if (!Char.IsDigit(e.KeyChar) && e.KeyChar != (char)Keys.Back) e.Handled = true; }

MOUSEMOVE

CODIGO PARA ENVIAR VALORES AL CALENDARIO private void calendario_MouseMove(object sender, MouseEventArgs e){ calendario.MaxDate = DateTime.Today; } VALUECHANGED CODIGO PARA VALIDAR FECHA DE NACIMIENTO private void calendario_ValueChanged(object sender, EventArgs e) { if (calendario.Value > DateTime.Today) MessageBox.Show("La fecha no puede ser mayor a Hoy"); }

Semana N° 9 Día 1: Clase 17 CLASE N°:

17

PERÍODO

22/07/2013 al 26/07/2013

TIEMPO:

2 Horas

FECHA:

22/07/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

Contenidos  Windows Forms

 Manejo de Excepciones en Visual Estudio C# Objetivos de Desempeño  Crear interfaces gráficas amigables y flexibles. 

Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.



Crear funciones utilizando datos por valor y referencia.



Programar métodos que muestren características de bajo acoplamiento y alta cohesión.



Construir módulos que valida el ingreso de datos para la integridad de la información

Competencia General  Identificar los métodos a programar en la construcción de un sistema 

Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.



Utilizar programación modular.



Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.

Datos Interesados Discutidos Actividades Durante la Clase - Hubieron exposiciones de Compañeros -

Cada estudiante iba haciendo sus prácticas de cada tema expuesto 

Validacion de llaves primarias y ajenas



Formularios MDI

Descriptores Analizados - Validacion de llaves primarias y ajenas -

Formularios MDI

VALIDACION DE DATOS ¿De qué trata? Proceso por el cual los datos son filtrados y aceptados o rechazados en base a procedimientos definidos. Es también el paso previo a su entrega. Punto a considerar Debe verificarse la exactitud de los datos críticos, independientemente de si fueron ingresados a mano o transferidos electrónicamente. Los chequeos deben ser parte de procedimientos rutinarios para identificar errores Deben existir procedimientos estándar para definir datos sin procesar, seguridad para la entrada de datos y revisión. Los resultados finales deben ser traceables a quien ingresó los datos o al instrumento desde el cual se incorporaron automáticamente TIPOS DE DATOS Cuando se introducen numerosos datos en una tabla, existe el riesgo de que cometamos errores, estos errores pueden ser por tipeo o debido a que la información ingresada sea incorrecta. Se puede disminuir el riesgo de cometer errores, con la creación de técnicas para VALIDACION DE DATOS, la cual impide introducir datos erróneos a medida que llenamos una tabla. Los tipos de datos que se pueden validar son: Números: Se puede establecer que el número que se introduce a una celda sea decimal o entero, que este entre un mínimo y un máximo, excluir un número o intervalo de números y finalmente se puede utilizar una fórmula para hacer el cálculo de validación Fechas y horas: En este caso se pueden excluir fechas u horas, establecer una fecha máxima, mínima o un intervalo y también establecer una fórmula para determinar las fechas válidas. Longitud: Pone límites al número de caracteres que se pueden introducir, tanto en máximo como en mínimo. BASE DE DATOS: LLAVES PRIMARIAS Y AJENAS LLAVE PRIMARIA En base de datos, una llave primaria es un conjunto de uno o más atributos de una tabla, que tomados colectivamente nos permiten identificar un registro como único, es decir, en una tabla podemos saber cuál es un registro en específico sólo con conocer la llave primaria. Ejemplo el número de cedula de ciudadanía, o la clave de única el registro de población, permiten identificar a una persona en particular en una entidad de personas. LLAVE AJENA En base de datos, llaves o también conocidas como claves ajenas consiste en garantizar la integridad referencial entre tablas que puedan existir en una base de datos.

"La clave ajena hace referencia a un campo que se añade a una tabla para hacer de enlace con otra. Dicho campo hará la función de clave primaria en la tabla referenciada". VALIDACION DE LLAVES PRIMARIAS Y AJENAS La validación de llaves primarias siempre se da, cuando se genera un ingreso de datos, es ahí donde toma un papel importante el poder validar ese ingreso y no tener inconvenientes, para lo cual se debe saber el tipo de dato que permite, y algunas características mismas del ingreso. La validación de llaves ajenas, tiene lugar al momento de hacer consultas e ingresar datos a tablas ya referenciadas, con llaves primarias. Por ejemplo: al registrar un factura, se está registrando llaves ajenas correspondiente a cliente y producto, es ahí donde se valida dicho ingreso. Como parte de demostración de se tiene el siguiente ejemplo, desarrollado en lenguaje de programación c#. FORMULARIOS MDI (INTERFAZ DE MULTIPLES DOCUMENTOS) ¿Qué son?

Los programas de ordenador gráficos de interfaz de múltiples documentos (MDI) son aquellos cuyas ventanas se encuentran dentro de una ventana padre (normalmente con la excepción de las ventanas modales), de manera opuesta a una interfaz de documento único o SDI. Ha habido muchos debates sobre qué tipo de interfaz se prefiere. Generalmente se considera que SDI es más útil si los usuarios trabajan con varias aplicaciones. Las compañías han utilizado ambos sistemas con reacciones diversas. Por ejemplo, Microsoftha cambiado la interfaz de sus aplicaciones Office de SDI a MDI y luego otra vez a SDI, aunque el grado de implementación varía entre componentes. Formulario "Padre" o "Parent" que puede contener otros formularios llamados "Hijos" o "Child". La principal desventaja de MDI es la escasez de información sobre las ventanas abiertas: Para ver una lista de ventanas abiertas de una aplicación MDI, el usuario normalmente tiene que seleccionar un menú específico ("lista de ventanas" o algo parecido), si esta opción está disponible. Con una aplicación SDI, la barra de tareas del administrador de ventanas muestra las ventanas abiertas actualmente. En los últimos años, las aplicaciones han añadido barras de tareas o sistemas de pestañas a las aplicaciones MDI, lo que ha hecho obsoleta esta crítica. Algunas personas usan un nombre distinto para este tipo de interfaz, "interfaz de pestañas" (TDI). Cuando se usa pestañas para controlar las ventanas, estas normalmente no se pueden cambiar de tamaño por separado.

Aplicaciones de interfaz de múltiples documentos (MDI)

Las aplicaciones MDI (interfaz de múltiples documentos) permiten mostrar varios documentos al mismo tiempo, cada uno de ellos en su propia ventana. Las aplicaciones MDI suelen tener un elemento de menú Ventana con submenús que permiten cambiar entre ventanas o documentos.

Reflexionar ¿Qué cosa fueron difíciles?  Todo estuvo bien explicado ¿Qué cosas fueron fáciles?  Realizar las practicas ¿Por qué?  Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres ¿Qué Aprendí Hoy? -

A usar los componentes que vienen en visual Estudio 2010. APUNTES DE CLASE

PRACTICA PARA LA VALIDACION DE LLAVES PRIMARIAS Y AJENAS Nuestro ejemplo ilustrativo estará compuesta por una base de datos, creada en Microsoft Access 2010, y una aplicación dentro del Entorno Integrado Microsoft Visual Studio 2010 y su lenguaje C#. Como parte principal, es necesario crear nuestra base que contendrá todos los datos, en donde se pueda consultar y agregar llaves tanto en el caso de llaves primarias como llaves ajenas. 1.

CREACION DE BASE DATOS

Dentro de Microsoft Access 2010, en la parte lateral derecho es necesario colocarle un

nombre a nuestra base de datos, con el propósito de poderla identificar, en nuestro caso la nombraremos: ―DataBaseSistema.accdb‖, cabe recalcar MS Access 2010 coloca a que toda base de datos, en su nombre la extensión de archivo ―.accdb‖.

Ya creada nuestra base de datos, procedemos a crear cada una las tablas con sus correspondientes atributos o campos, especificando el tipo de datos que puede almacenar. Para la creación de una tabla es necesario, estar en la pestaña CREAR y seleccionamos la opción TABLA

Con el propósito de simular las operaciones que realiza una factura, se necesitara crear cuatro tablas: Tabla CLIENTE [cedula, nombre, ciudad, teléfono, direccion].

Tabla PRODUCTO

[código, descripción, valorUnitario, stock].

Tabla FACTURA [numero, cliente, valorTotal, fechaNacimiento].

Tabla DETALLE_FACTURA [codigoPro, nombre, ciudad, teléfono, direccion].

Ya habiendo creado las tablas correspondientes, realizamos las relaciones a cada tabla, sin dejar ninguna tabla suelta o sin relacionar, es necesario colocar las llaves primarias en las tablas CLIENTES, PRODUCTO Y FACTURA, la tabla DETALLE_FACTURA, nos servirá para almacenar nuestras llaves ajenas correspondientes a FACTUA, PRODUCTO, no olvidar que existe una relación de Muchos a Muchos entre la tabla PRODUCTO Y FACTURA, por tal motivo se vio la necesidad crear la tabla DETALLE_FACTURA, luego en su modelo relacional tendremos, la siguiente ilustración:

En la tabla CLIENTE, nuestra llave primaria es: “CEDULA”; y esta misma será llave ajena en la tabla FACTURA, como parte de hacer una consulta a los clientes en caso de que dicho cliente ya este registro. En la tabla PRODUCTO, llave primaria es: “CODIGO”, de igual forma esta será llave ajena en la tabla FACTURA, ya que por medio de esta llave se podrá consultar el producto a facturar. En FACTURA, tenemos como primaria a “NUMERO‖ ya que una factura solo posee un número y no se podrá repetir, entre las llaves foránea tenemos: “CLIENTE” que será “CEDULA” en la tabla CLIENTE. DETALLE FACTURA, tenemos como foránea a “COD_PRO” y “NUM_FAC”, no tiene llaves primaria por ser una tabla que rompe las relacione de ―Muchos a Muchos.‖ Una vez, terminado la creación de nuestra base de datos, desarrollamos nuestro proyecto en Microsoft Visual Studio 2010, en lenguaje C#:

2.

CREACION DE APLICACIÓN

Creamos nuestro proyecto en lenguaje C#, en nuestro caso lo nombraremos ―Validación de Llaves‖, nuestro proyecto estará compuesto por dos formulación, una clase y una conexión de datos. Creación del ORIGEN DE DATOS 1. Ingresamos al menú ―DATOS‖ y al desplegarse las opciones seleccionamos ―AGREGAR NUEVO ORIGEN DE DATOS‖.

2. Escogemos el tipo de Origen de datos, en nuestro ejemplo, ocuparemos Base de Datos, después click en botón ―Siguiente‖

3. Realizamos una NUEVA CONEXIÓN. Y al momento de aparecer la nueva venta es necesario buscar nuestra base de datos creada, y colocarla, luego como un téster para conocer si la conexión está bien es necesario presionar el botón ―PROBAR CONEXION‖

Es necesario, copiar la cadena de conexión, ya que este sirve como el Path o la direccion para poder enlazar nuestra aplicación con la base de datos. 4. Luego se selecciona lo que se desea ocupar de la base de datos, por ejemplo las vistas y tablas, y como parte final, presionamos el botón FINALIZAR.

Una vez realizado la creación del Origen de Datos, podremos ver que en nuestro proyecto aumento una parte de base datos, y en panel de Origen de datos, podremos visualizar las tablas con las que cuenta la base de datos ―DataBaseSistema.accdb‖

Creación de INTERFAZ GRAFICA DE USUARIO Formulario1: INICIAL CLIENTE: Nos llevara el formulario ―CLIENTE‖, el cual tendrá la función de ingresar los nuevos registros y validar la llave primaria no se repita y poder controlar cierto errores que se presentan al almacenar una llave primaria. FACTURA: Nos presentara el formulario ―FACTURA‖: que tendrá la función hacer consultar por medio de llaves primarias registros de las tablas CLIENTES Y PRODUCTOS, además podrá registrar las llaves foráneas.

Factura

Cliente

Cada vez que se llame a los eventos de los botones ese tendrá la responsabilidad de crear objetos, en el caso del botón Factura, al dar click creara un nuevo objeto de la clase FACTURA. Formulario2: INGRESO DE CLIENTE El form2, tendrá el nombre de ―CLIENTE‖, permitirá el ingreso de un nuevo registro a nuestra base de datos y su interfaz estará compuesta por varios controles (cajas de texto, etiquetas, paneles, botones, etc.) que ya antes se han manipulados, su interfaz estará de la siguiente forma, como lo ilustra la imagen:

Como notamos los datos a ingresar son los atributos que

hemos

puesto en nuestra base de datos, en la misma tabla Cliente,

este

formulario en su parte ―RUC O CEDULA‖, tiene la función

de validar

el ingreso de cedula del nuevo registro que se pretende guardar, este consultara a nuestra base de datos, y en caso de que el número ya esté en un registro genera un mensaje advertencia y no permitirá que se guarde, ya que una cedula es una llave primaria y por ende no se puede repetir. El guardado de registro se realiza mediante el evento click que se realiza al presionar el botón ―REGISTRAR‖. Líneas de código del botón “REGISTRAR”:

botón “REGISTRAR”:

CLASE 1: CLASS1

Esta clase nos permitirá el ingreso de registros en la base de datos, esta clase tendrá los métodos de conexión y consulta a las tablas. Ya creada la clase, crearemos tres métodos primero ―conexionBD( )‖,el segundo ―busquedasql( )‖, y el tercero ―ingresoclientesql( )‖. Antes debemos tener en cuenta que para que la clase trabaje con base de datos y formularios utilizaremos las librerías:

Método: conexionBD( ) Este método tendrá la función de establecer la conexión a la base de datos, estableciendo en una variable tipo String.

Método: busquedasql( ) Este método realiza las búsquedas y realiza comparaciones con el dato ingresado en este caso CEDULA, es el dato ingreso que nos ayuda a validar la no existencia de duplicidad de valore. Ahora algo muy importante a recatar es que el método busquedasql( ) es un método que retorna un valor booleano, entre True y False.

Esta línea de código: string setenciasql = "Select COUNT(*) FROM " + tabla + " WHERE CEDULA = @cedula ";

es la sentencia o la orden para la consulta, aquí cuenta todos los registros de la tabla al que se quiere acceder, siempre cuando cumpla la condición en que el campo cedula de la tabla sea igual al valor cedula que se esté ingresando. Método: ingresoclientesql( ): Como indica el método, este método recibe varios parámetros entre los cuales solo tenemos los atributos ya colocados al principio en la tabla cliente, con esto este método es llamado de cualquier formulario para el registros de clientes e insertarlo a la base de datos. Cada recalcar que primero tiene una condición en el cual valida al método busquedasql(), donde verifica que el número de cedula no este repetido con cualquier otro registro.

Este método será el encargado de ingresar los nuevos registros y podrá ser llamado directamente desde el formulario INICIAL, al dar click en el botón de CLIENTE, también estará siendo accedido desde el formulario FACTURA, al momento de buscar los datos un cliente y tal no se encuentre registrado en la base de datos, el formulario automáticamente se cerrara y nos presentara el formulario cliente, con el propósito de registrarlo, y una vez ingresado e forma automática el usuario podrá ser consultado desde el formulario factura.

Formulario3: FACTURA

El botón de BUSCAR CLIENTE: Este evento tendrá la función de ir a la tabla clientes y buscar los valor del nombre del cliente y direccion del cliente, para esta búsqueda se utilizara su llave primaria ―CEDULA‖. Este botón tiene las siguientes líneas de código:

El botón de AGREGAR: Este método captura el código del producto que es llave

primaria

en la tabla PRODUCTO, lo busca y captura todos sus

atributos

del producto que se pretende buscar, luego capturado realiza

una

operación aritmética para realizar el cálculo entre la cantidad del producto y el valor unitario y así tener el valor total.

El botón GUARDAR Este botón tiene una de las funciones más principales en la validación de llaves ajenas, ya que aquí se tornara a guardar los datos de cliente y de producto, aquí es donde se valida si las llaves foráneas aceptan el tipo de formato y valores. Una vez ya ingresado los valor, completamente al momento de guardar, se ejecuta la sentencia u operación INSERT INTO, capturando de forma automática los valores ya ingresados y en la sentencia los pone como parámetros y antepuestos por un signo de @.

En las siguientes líneas de código, cuenta y captura el número de filas que se pudo llenar en el dataGridView1. Después por medio de un bucle iterativo, pone con un valor máximo de iteración al número de filas de dataGridView1, va recorriendo y al mismo tiempo realiza un comando de insertar lo que recorre el dataGridView1.

CALCULO DE TOTAL Este método, realiza la sumatoria de todos los valores en el detalle de cada producto, y lo presenta en la caja de texto ―TOTAL‖. Este método se aplica cuando se realiza el evento click en el botón AGREGAR. public void valortotal() { double valort = 0; int columnas = Convert.ToInt32(dataGridView1.Rows.Count.ToString()); for (int i = 0; i < columnas; i++) { valort += Convert.ToDouble(dataGridView1.Rows[i].Cells[4].Value); } textBox9.Text = valort.ToString(); }

Practica de Formularios MDI Pasos para crear un formulario MDI: 1. Creamos un Nuevo proyecto en Visual Studio 2010.

2. En la ventana Propiedades, se busca la propiedad "IsMDIContainer" y se cambia a "True".

3. L uego en el menú se elige Proyectos -> Agregar Windows Form. Aparecer á la ventana de "Agregar Nuevo Elemento ". Se elige "Windows Form, le colocamos un nombre a nuestro formulario nuevo".

4. A este control le agregamos 3 controles tipo textBox que se dejarán con sus nombres por defecto: textBox1, textBox2 y textBox3.

5. En la ventana "Inspector de Soluciones", se le hace click derecho al icono de Form1 y clickeamos en "Ver Código". El código a añadir será:

public partial class Form1 : Form { Form2 frm2; public Form1() { InitializeComponent(); } private void Form1_Load(object sender, EventArgs e) { frm2 = new Form2(); frm2.MdiParent = this; frm2.Show(); } }

6. En la ventana "Inspector de Soluciones", se le hace click derecho al icono de Form2 y clickeamos en "Ver Código". El código a añadir será:

private void Form2_Load(object sender, EventArgs e)

{ textBox1.Text = "Probando"; } public void Borar() {

textBox1.Text=""; textBox2.Text="";

textBox3.Text = ""; }

7. Luego a Form1 le añadimos un control MenuStrip, jalándolo desde la caja de herramientas:

8. Luego se le hace click a la etiqueta "limpiar" y se añade el código:

private void limpiarToolStripMenuItem_Click(object sender, EventArgs e) {

frm2.Borar(); }

9. Se pueden hacer más cosas, por ejemplo, añadí esto al menuStrip:

10. Junto con este código:

11. Esto permite minimizar y maximizar Form2 clickeando la opción correspondiente en el menú.

Resultados: Al ejecutar el proyecto se muestra el Texto que escribimos en el primer textBox:

Si deseamos limpiar la caja de texto debemos presionar el Menú Limpiar:

Si deseamos maximizar, minimizar la ventana hacemos clic en los menús Maximizar y Minimizar: Vista Maximizada:

Vista Minimizada:

Por ultimo si deseamos poner la ventana en estado Normal presionamos el Menú Normal:

PRACTICA 2: 1.- Creamos un formulario, del cual será primario o padre en donde se mostraran las demás ventanas de los otros formularios llamados secundarios o hijos.

2.- Luego para que nuestro formulario sea Padre o Primario, se debe colocar en la propiedad IsMdiContainer a True, al momento de que se ponga True el color de fondo del formulario cambiara indicando de que será contenedor de formularios hijos o secundarios.

3.- Ahora colocamos un MenuStrip, en el cual contendra opcviones para abrir y mostrar los formularios hijos que se encuentran en el formulario.

4.- Seleccionamos el MenuStrip, en propiedades MdiWindowsListItem selecciones ventanaTollStripMenuItem, esto sirvira para indicvar que ventana secundario o hija esta activa que se muestra en el formulario padre.

5.- Procedemos a crear formularios para los MenuStrip

6.- En los MenuStrip se realiza la siguiente codificacion private void bananoToolStripMenuItem_Click(object sender, EventArgs e) { //se crea una instancia de un formulario hijo Form9 banana = new Form9(); //el nombre de la instancia se le asigna el formulario padre a este, mediante la propiedad MdiParent banana.MdiParent = this; //.show se utiliza para mostrar la instancia del formulario previo banana.Show(); } private void perroToolStripMenuItem_Click(object sender, EventArgs e) { Form2 perro = new Form2(); perro.MdiParent = this; perro.Show(); }

7.- Luego damos clic en Animales  Perro y nos mostrara el formulario Perro (Secundario) dentro del formulario Padre (Form1).

8.- Luego damos clic en otro formulario en este caso Pera y se nos abrira otro formulario hijo dentro del formulario Padre. Ademas en ventana podemos visualizar el o los formularios que se encuentren abiertos, el formulario que esta primero se seleccionara con un visto.

Semana N° 9 Día 2: Clase 18 CLASE N°:

18

PERÍODO

22/07/2013 al 26/07/2013

TIEMPO:

2 Horas

FECHA:

24/07/2013

DOCENTE GUÍA:

Ing. Mariuxi Paola Zea Ordoñez

TEMA DISCUTIDO:

UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

Contenidos  Windows Forms

 Manejo de Excepciones en Visual Estudio C# Objetivos de Desempeño  Crear interfaces gráficas amigables y flexibles. 

Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.



Crear funciones utilizando datos por valor y referencia.



Programar métodos que muestren características de bajo acoplamiento y alta cohesión.



Construir módulos que valida el ingreso de datos para la integridad de la información

Competencia General  Identificar los métodos a programar en la construcción de un sistema 

Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.



Utilizar programación modular.



Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.

Datos Interesados Discutidos Actividades Durante la Clase - Hubieron exposiciones de Compañeros -

Cada estudiante iba haciendo sus prácticas de cada tema expuesto 

Busquedad de Registros



Formulario Maestro Detalle

Descriptores Analizados - Busqueda de registros -

Formulario Maestro Detalle

BUSQUEDA DE REGISTROS Primeramente para poder conceptualizar que es una búsqueda de registro debemos tener bien en claro algunos conceptos principales es por eso que nos eso visto en la necesidad de definirlos a continuación. QUE ES UN REGISTRO? Un registro es un conjunto de campos que contienen los datos que pertenecen a una misma repetición de entidad. Se le asigna automáticamente un número consecutivo (número de registro) que en ocasiones es usado como índice aunque lo normal y práctico es asignarle a cada registro un campo clave para su búsqueda. QUE ES UNA BUSQUEDA? La palabra búsqueda refiere, por un lado, la acción de buscar que despliega alguien o una cosa, por ejemplo una máquina o una función especializada para tal efecto; y también se llama búsqueda, a la investigación o estudio de documentación, la búsqueda bibliográfica, la búsqueda de una persona, entre otras. Uno de los sistemas más complejos cuando de recuperar información se trata, básicamente porque busca información en una cantidad inmensa de documentos, los buscadores web emplean este tipo de metodología. Consiste en extraer de los documentos un mínimo fragmento de texto el cual responde a una pregunta que se hace en el lenguaje corriente natural. El mismo, por la complejidad que mencionamos, se encuentra ubicado por delante de la tecnología que tiene un buscador tradicional. Pues bien un concepto el cual nos interesa es la búsqueda con respecto a la informática resulta ser aquel sistema informático que busca archivos que se encuentran guardados en diversos servidores o en algunas bases de datos. BÚSQUEDA DE REGISTRO Una vez definidos estos conceptos tenemos una idea clara de lo que es una búsqueda de registro. Se refiere a la acción de búsqueda de un archivo o documento en un conjunto de campos perteneciente a una base de datos. PROGRAMA DE BÚSQUEDA DE REGISTRO INTERFAZ INICIO

FORMULARIOS MAESTRO, DETALLE, CÁLCULOS Una factura bien hecha debería contener los siguientes elementos en el orden establecido: Datos identificativos del profesional que presta los servicios: nombre completo, domicilio y Razón social. Número de factura: todas las facturas han de ir numeradas de forma correlativa, es decir, no se puede saltar del número 93 a la 98, por ejemplo. Fecha de la factura: también hay que tener en cuenta que las fechas de las facturas han de ir de acuerdo a su numeración, es decir, la factura 98 no puede tener una fecha anterior a la 97. Concepto de la factura: breve descripción de los productos o servicios prestados. Importe del IVA: cantidad resultante de aplicar al importe 12%. Cantidad total a percibir: la suma del importe inicial, más el importe del IVA. Forma de pago. Reflexionar ¿Qué cosa fueron difíciles?  Todo estuvo bien explicado ¿Qué cosas fueron fáciles?  Realizar las practicas ¿Por qué?  Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres ¿Qué Aprendí Hoy? -

A usar los componentes que vienen en visual Estudio 2010.

APUNTES DE CLASE

BÚSQUEDA DE REGISTROS PASOS PARA REALIZAR LA PRÁCTICA CREAR LA BASE DE DATOS 1. Para llevar a cabo la práctica, iniciamos con la creación de la base de dato, la cual contendrá los registros que se van a acceder, para esto, hacemos lo siguiente:

1.1. Abrimos Microsoft Access y damos clic en la opción Nuevo y le colocamos un nombre

1.2. Luego procedemos a crear una tabla de nombre ―Personal‖

1.3. Luego damos clic en la opción Ver, y seleccionamos ―Diseño‖

1.4. Para continuar, debemos crear los campos en la tabla, para ello haremos 7 campos, de la siguiente manera:

1.5. Una vez que fijemos los tipos de datos, procedemos a llenar la tabla con los registros que nosotros queramos y guardamos los cambios efectuados.

CREAR EL FORMULARIO 2. Primero debemos crear un nuevo Proyecto y ponerle el nombre que nosotros queramos. Y luego arrastramos los componentes de manera que se parezca a la que se muestra a continuación:

3. Los nombres de las variables de cada componente se detallan a continuación:

COMPONENTES (nombre de variables) Label

Button

ComboBox

TextBox

1: comboBox1

3: tbuscar

2: comboBox2

8: tcedula

19: csueldo

9: tnombre

21: cfecha

10: tapellido

24: cordenacion

12: tciudad

7: button2 5: lregistros

27: button4

6: lerror

28: button1 29: button3 13: ttelefono

DateTimePicker

RadioButton

Datagridview

14: tsueldo 15: fced

11: tfecha 25: asc

16: fnom

22: fdate1 26: desc

4: dataGridView1

17: fape

23: fdate2 (oculto) 18: fciu

20: fsue

4. Procedemos a llenar los componentes ComboBox, de la siguiente manera: 4.1. comboBox1

4.2. comboBox2 (Deshabilitar)

4.3. csueldo



4.4. cfecha

4.5. cordenacion

5. Una vez que se haya finalizado con el ingreso de elementos de los ComboBox, nos vamos a vista código y realizamos lo siguiente:

Declaramos tres variables globales: DataRow (dr), OleDbConnection (con), int (totalRegistros). Una vez hecho esto, nos ubicamos en el método Form1_Load, el cual permitirá que realice las acciones al abrirse el formulario: Lo que haremos aquí será de especificar a los ComboBox el elemento que queremos mostrar como predeterminado, en este caso que inicie con el valor de los elementos que se encuentran en la posición 0. Del mismo modo se ajusta el tamaño del formulario y por último se llama al método llenarTabla(). Código:

DataRow dr; OleDbConnection con; int totalRegistros = 0;

private void Form1_Load(object sender, EventArgs e) { llenarTabla(); comboBox1.SelectedIndex = 0; comboBox2.SelectedIndex = 0; csueldo.SelectedIndex = 0; cfecha.SelectedIndex = 0; cordenacion.SelectedIndex = 0; this.Size = new Size(391, 477); }

6. El método llenarTabla(), lo que hará es llenar el dataGridView1 con los registros de la base de datos. Primero se instancia la variable OleDbConnection y se ubica la ruta en donde se encuentra nuestra base de datos.

Después creamos un objeto de tipo DataAdapter y en los parámetros recibirá la conexión y la sentencia SQL, la cual será seleccionar todos los registros de la tabla; porque inicializa la variable total Registros con el número de filas que tenga el dataGridView1 y se coloca el número de registros en lregistros.

Código:

public void llenarTabla() { con = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=D:\BDEjemplo.accdb"); OleDbDataAdapter da = new OleDbDataAdapter("SELECT * FROM Personal", con);

DataSet ds = new DataSet();

da.Fill(ds, "Personal");

dataGridView1.DataSource = ds.Tables["Personal"]; totalRegistros = dataGridView1.Rows.Count - 1; lregistros.Text = (dataGridView1.Rows.Count-1) + " de " + totalRegistros; }

EVENTOS 7. Evento comboBox1 Este evento habilitará el comboBox2 al momento de seleccionar el elemento en la posición 5. Código: private void comboBox1_SelectedIndexChanged(object sender, EventArgs e) { if (comboBox1.SelectedIndex == 5) { comboBox2.Enabled = true; } else { comboBox2.Enabled = false; tbuscar.Text = ""; } }

8. Evento tbuscar Este evento hará que se llene el dataGridView1 con el resultado de la consulta a la base de datos dependiendo del campo que se haya seleccionado en comboBox1. Tendrá un bucle el cual vaciará la tabla y dependiendo del elemento que se seleccione en comboBox1, llamará al método filtarTabla() siempre y cuando no se elija el elemento en la posición 5 (sueldo). Si se eligió el elemento 5, entonces llamará a otro método busquedaSueldo(). En caso que el tbuscar esté vacío, se llamará al método llenarTabla().

Código: private void tbuscar_TextChanged(object sender, EventArgs e) { for (int i = 0; dataGridView1.Rows.Count - 1 > 0; i++) { dataGridView1.Rows.RemoveAt(0); }

if (comboBox1.SelectedIndex != 5) { lerror.Text = ""; if (tbuscar.Text != "") filtrarTabla(comboBox1.SelectedItem.ToString()); else llenarTabla(); } else { lerror.Text = ""; if (tbuscar.Text != "") busquedaSueldo(comboBox2.SelectedItem.ToString()); else llenarTabla(); } }

9. El método filtarTabla(), recibirá el campo que se eligió en comboBox1 y se armará la sentencia SQL, la cual mandará a buscar en la tabla Personal aquellos campos que contengan parte de texto que se escribió en tbuscar. Si se encontró registros se llenará el dataGridView1 y se actualizarán el número de registros en legistros.

En caso de no hallar registros, se mostrará un mensaje en lerror, del mismo modo nos mostrará error cuando genere una excepción. Código:

public void filtrarTabla(string campo) { //senetencia sql string sql = "SELECT * FROM Personal WHERE " + campo + " LIKE '%" + tbuscar.Text + "%'"; try { lerror.Text = ""; con = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=D:\BDEjemplo.accdb"); OleDbDataAdapter da = new OleDbDataAdapter(sql, con);

DataSet ds = new DataSet();

da.Fill(ds, "Personal"); dataGridView1.DataSource = ds.Tables["Personal"]; lregistros.Text = (dataGridView1.Rows.Count - 1) + " de " + totalRegistros;

if ((dataGridView1.Rows.Count - 1) == 0) { lerror.Text = "¡No hay registros!"; } } catch (Exception ex) { lerror.Text = "¡No hay registros!"; } }

10. El método busquedaSueldo(), recibirá el operador que se eligió en comboBox2 (, =, =) y se armará la sentencia SQL, la cual mandará a buscar en la tabla Personal aquellos registros que tengan el Sueldo especificado por el operador.

Si se encontró registros se llenará el dataGridView1 y se actualizarán el número de registros en legistros. En caso de no hallar registros, se mostrará un mensaje en lerror,

del mismo modo nos mostrará error cuando genere una excepción. Código: public void busquedaSueldo(string o) { string sql = "SELECT * FROM Personal WHERE Sueldo " + o + tbuscar.Text; try { lerror.Text = ""; con = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=D:\BDEjemplo.accdb"); OleDbDataAdapter da = new OleDbDataAdapter(sql, con);

DataSet ds = new DataSet();

da.Fill(ds, "Personal"); dataGridView1.DataSource = ds.Tables["Personal"]; lregistros.Text = (dataGridView1.Rows.Count - 1) + " de " + totalRegistros;

if ((dataGridView1.Rows.Count - 1) == 0) { lerror.Text = "¡No hay registros!"; } } catch (Exception ex) { lerror.Text = "¡No hay registros!"; } }

11.

Evento dataGridView1

Este evento mostrará en las cajas de texto el registro que se haya encontrado mediante la consulta SQL donde la cédula sea igual al valor de la fila que se haya seleccionado

mediante un clic. En caso de no hallar registros, se mostrará un mensaje en lerror, del mismo modo nos mostrará error cuando genere una excepción. Código: private void dataGridView1_CellClick(object sender, DataGridViewCellEventArgs e) { string sql = "SELECT * FROM Personal WHERE Cedula = '" + dataGridView1[0, dataGridView1.CurrentRow.Index].Value.ToString()+ "'"; try { lerror.Text = ""; OleDbDataAdapter da = new OleDbDataAdapter(sql, con); DataSet ds = new DataSet();

da.Fill(ds, "Personal");

dr = ds.Tables["Personal"].Rows[0];

tcedula.Text = dr["Cedula"].ToString(); tnombre.Text = dr["Nombre"].ToString(); tapellido.Text = dr["Apellido"].ToString(); tfecha.Text = dr["Fecha_nac"].ToString(); tciudad.Text = dr["Ciudad"].ToString(); ttelefono.Text = dr["Telefono"].ToString(); tsueldo.Text = dr["Sueldo"].ToString();

tbuscar.Text = ""; comboBox2.Enabled = false; } catch (Exception ex) { lerror.Text = "¡No hay registros!"; }

}

12.

Evento button2

Este botón únicamente ajustará el tamaño del formulario y deshabilitará tbuscar. Código: private void button2_Click(object sender, EventArgs e) { this.Size = new Size(781,477); tbuscar.Enabled = false; }

13.

Evento cfecha

Este evento hará visible el fdate2, siempre y cuando el elemento que se haya seleccionado esté en la posición 4, caso contrario, no se podrá visualizar éste dataTimePicker. Código: private void cfecha_SelectedIndexChanged(object sender, EventArgs e) { if (cfecha.SelectedIndex == 4) fdate2.Visible = true; else fdate2.Visible = false; }

14.

Evento button4

Llamará al método busquedaAvanzada() Código: private void button4_Click(object sender, EventArgs e) { busquedaAvanzada();

}

El método busquedaAvanzada() Capturará en las variables string todos los valores que contenga cada TextBox, en base a esto, la sentencia SQL se irá concatenando siempre y cuando los campos tengan un valor y no sean nulos. Del mismo modo la ordenación se verá afectado al seleccionar los valores en cordenacion y en asc/desc En caso de no hallar registros, se mostrará un mensaje en lerror, del mismo modo nos mostrará error cuando genere una excepción.

Código: public void busquedaAvanzada() { string ced, nom, ape, ciu, sue, cs, cf, sql, fec1, fec2; int cont = 0;

ced = fced.Text; nom = fnom.Text; ape = fape.Text; ciu = fciu.Text; sue = fsue.Text; cs = csueldo.SelectedItem.ToString(); fec1 = formatoFecha(fdate1.Value.Date); fec2 = formatoFecha(fdate2.Value.Date);

cf = cfecha.SelectedItem.ToString(); if (cf == "entre") cf = "BETWEEN";

sql = "SELECT * FROM Personal ";

if (ced != "") { cont++; sql += " WHERE Cedula LIKE '%" + ced + "%' "; }

if (nom != "") { cont++; if (cont == 1) sql += " WHERE Nombre LIKE '%" + nom + "%' "; else sql += " AND Nombre LIKE '%" + nom + "%' "; }

if (ape != "") { cont++; if (cont == 1) sql += " WHERE Apellido LIKE '%" + ape + "%' "; else sql += " AND Apellido LIKE '%" + ape + "%' "; }

if (ciu != "") { cont++; if (cont == 1) sql += " WHERE Ciudad LIKE '%" + ciu + "%' "; else sql += " AND Ciudad LIKE '%" + ciu + "%' "; }

if (sue != "") { cont++; if (cont == 1) sql += " WHERE Sueldo " + cs + sue; else sql += " AND Sueldo " + cs + sue; }

if (fdate1.Value.Date != DateTime.Today) { cont++; if (cont == 1) { if (cf == "BETWEEN") sql += " WHERE Fecha_nac " + cf + "#" + fec1 + "# AND #" + fec2 + "# "; else sql += " WHERE Fecha_nac " + cf + "#" + fec1+ "# "; } else { if (cf == "BETWEEN") sql += " AND Fecha_nac " + cf + "#" + fec1 + "# AND #" + fec2+ "# "; else sql += " AND Fecha_nac " + cf + "#" + fec1 + "# "; } }

String campo = cordenacion.SelectedItem.ToString(); if (campo != "(Sin ordenación)") { if (asc.Checked) sql += " ORDER BY " + campo + " ASC";

else sql += " ORDER BY " + campo + " DESC"; }

try { lerror.Text = ""; con = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=D:\BDEjemplo.accdb"); OleDbDataAdapter da = new OleDbDataAdapter(sql, con);

DataSet ds = new DataSet();

da.Fill(ds, "Personal"); dataGridView1.DataSource = ds.Tables["Personal"]; lregistros.Text = (dataGridView1.Rows.Count - 1) + " de " + totalRegistros;

if ((dataGridView1.Rows.Count - 1) == 0) { lerror.Text = "¡No hay registros!"; } } catch (Exception ex) { lerror.Text = "¡No hay registros!"; } }

El método formatoFecha(), convertirá a String la fecha que se ha colocado en el dateTimePicker1 Código: private string formatoFecha(DateTime dt)

{ return dt.Year + "/" + dt.Month + "/" + dt.Day; }

15. Evento button1 Lo que hará este evento es llamar al método llenarTabla () Código: private void button1_Click(object sender, EventArgs e) { llenarTabla(); }

16.

Evento button3

Este evento ajustará el formulario para que su tamaño se reduzca y habilitará el tbuscar Código: private void button3_Click(object sender, EventArgs e) { this.Size = new Size(391,477); tbuscar.Enabled = true; }

FUNCIONAMIENTO: EJEMPLOS En este ejemplo buscaremos los registros cuyo campo apellido contenga la palabra “ez” y seleccionaremos el primer registro que aparezca:

En este ejemplo buscaremos los registros cuyo campo ciudad sea igual a “Machala”, el campo sueldo sea menor o igual a 900 y lo ordenamos por sueldo de forma ascendente; seleccionamos el primer registro que aparezca:

En este ejemplo buscaremos los registros cuyo campo cédula contenga ―070”, el campo nombre contenga la letra “a” y lo ordenamos por apellido de forma descendente; seleccionamos el primer registro que aparezca:

PRACTICA EN VISUAL C#: FACTURA MAESTRO DETALLE

A

D

B

C

Hacemos click en el botón FACTURACION.

E

F

G

H

Si no recordamos los códigos de producto podemos hacer click en INVENTARIO y doble click para agragar el producto a la factura.

I

Ingresamos la cantidad y aceptamos. J

DESCRIPCION DE LA INTERFAZ A: IMAGEN

La imagen que presenta al iniciar el programa es el control PICTUREBOX, donde le agregamos una imagen. B: BOTÓN FACTURACIÓN

Debemos presionar este botón para empezar a facturar (E,F,G,H), el botón es un control BUTTON. C: BOTÓN INVENTARIO

Debemos presionar este botón para visualizar el inventario de productos y agregar a la factura (I,J), el botón es un control BUTTON. D: OPCIONES DE FACTURACIÓN

Esta barra es un control TOOLSTRIP, donde encontramos los botones de, nueva factura, abrir factura, guardar factura, imprimir factura y ayuda.

E: NOMBRE DE LA EMPRESA

Estos datos se encuentran en un control LABEL. F: NUMERO DE FACTURA

Aquí tenemos los controles LABEL para poner (N°:) y un control TEXTBOX para el numero de factura y estos dos contenidos en un control GROUPBOX que nos permite por medio de un marco etiquetar a que pertenecen. G: DATOS DEL CLIENTE

Tenemos los controles LABEL para poner (CI, NOMBRES, DIRECCION, TELEFONO, FECHA) y controles TEXTBOX, también encontramos tres controles BUTTON que por medio de imágenes representan BUSCAR, AÑADIR, GUARDAR respectivamente y un control DATETIMEPICKER para la fecha de factura, todos estos están contenidos en un control GROUPBOX que nos permite por medio de un marco etiquetar a que pertenecen. H: DATOS DEL PRODUCTO

Dentro del control GROUPBOX con nombre ―DATOS DEL PRODUCTO‖ se encuentra en control DATAGRIDVIEW que nos permite mostrar los datos en una cuadrícula personalizable ya sea conectado a una base de datos o simplemente creando las filas y las columnas, y para mostrar los cálculos los controles LABEL (SUBTOTAL, IVA 12%, TOTAL) y TEXTBOX respectivamente. I: INVENTARIO DE PRODUCTOS

Esta ventana nos aparece al hacer Click en el botón INVENTARIO (C), se usa un control DATAGRIDVIEW conectado a una base de datos puesto en un segundo FORMULARIO (FORM). J: CANTIDAD DE ARTÍCULOS

Usamos un mensaje para pedir al usuario que ingrese la cantidad de artículos que desea facturar previamente el usuario hizo doble Click en algún artículo de Inventario. Por medio del evento datagridview_DoubleClick realizamos el proceso de hacer doble Click en algún artículo de Inventario.

CODIGO DE PRÁCTICA Form1: using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.OleDb; namespace ProgramacionIFactura { public partial class Form1 : Form { /// VARIABLES public OleDbConnection conexionD; public DataSet ds; public DataRow dr; public OleDbDataAdapter da; public Form2 inventario = new Form2(); public int contadorRegistrosFilas = 0; public string codigoNuevo; public string descripcionNuevo; public string puNuevo; public string stockNuevo; public Form1() { InitializeComponent(); } /// BOTON FACTURACION private void button1_Click(object sender, EventArgs e) { panel1.Visible = true; pictureBox1.Visible = false; btnGuardar.Visible = false; } /// CARGA DEL FORMULARIO 1 private void Form1_Load(object sender, EventArgs e) { pictureBox1.Visible = true; panel1.Visible = false; inventario.CreacionFila += new Form2.TableDelegada(agregarFila); }

/// EVENTO BUTTON_CLICK PARA BOTÓN NUEVO private void btnNuevo_Click_1(object sender, EventArgs e) { btnGuardar.Visible = true; txtNombres.Enabled = true; txtDireccion.Enabled = true; txtTelefono.Enabled = true; //PONER EN BLANCO LOS BOTONES } /// METODO QUE CONTIENE LA RUTA DEL ARCHIVO DE LA BASE DE DATOS public void conexion() { conexionD = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Users\PAOLA\Desktop\PROGRAMACION FACTURA\Inventario.accdb"); }

/// METODO PARA GUARDAR CLIENTES A LA BASE DE DATOS public void guardarCliente() { string sentenciaSQL = "Select COUNT(*) FROM Clientes WHERE CedulaRuc = @cedula";/// SENTENCIA QUE BUSCA EN LA TABLA CLIENTE, SI LA CEDULA YA EXISTE OleDbCommand comando = new OleDbCommand(sentenciaSQL, conexionD);/// ENVIO LA SENTENCIA Y LA RUTA comando.Parameters.Add(new OleDbParameter("@cedula", OleDbType.VarChar, 10)); //Creando parametro de la colum. comando.Parameters["@cedula"].Value = txtCedula.Text; conexionD.Open(); int count = Convert.ToInt32(comando.ExecuteScalar()); if (count != 0) { MessageBox.Show("Este Usuario ya existe"); busquedaCliente(); } else { // UNA VARIABLE CON LA SENTENCIA SQL EN EL CASO DE NO EXISTIR LA CEDULA QUE SE ESCRIBIO EN EL TXTCEDULA.TEXT, LOS ADEMAS DATOS SON ALMACENADOS EN LAS VARIABLESPARA LUEGO ENVIARLOS A LA BASE DE DATOS CON AYUDA DE DEL BOTON GUARDAR

string setenciasql = "INSERT INTO CLIENTES (CedulaRuc, Nombre, Direccion, Telefono) VALUES(@acedula,@anombre,@adireccion,@atelefono)"; comando = new OleDbCommand(setenciasql, conexionD); comando.Parameters.Add(new OleDbParameter("@acedula", OleDbType.VarChar, 25)); //creo el parametro comando.Parameters["@acedula"].Value = txtCedula.Text; // asigno el valor al parametro

comando.Parameters.Add(new OleDbParameter("@anombre", OleDbType.VarChar, 50)); //creo el parametro comando.Parameters["@anombre"].Value = txtNombres.Text;

comando.Parameters.Add(new OleDbParameter("@adireccion", OleDbType.VarChar, 35)); comando.Parameters["@adireccion"].Value = txtDireccion.Text; comando.Parameters.Add(new OleDbParameter("@atelefono", OleDbType.VarChar, 25)); comando.Parameters["@atelefono"].Value = txtTelefono.Text;

comando.ExecuteNonQuery(); comando.Connection.Close(); /// CIERRO LA CONEXION CON LA BASE DE DATOS MessageBox.Show("Cliente Nuevo Guardado con Exito", "NUEVO CLIENTE", MessageBoxButtons.OK, MessageBoxIcon.Information); } } /// METODO PARA BUSCAR CLIENTES DE LA BASE DE DATOS public void busquedaCliente() { conexion();/// METODO QUE CONTIENE LA VARIABLE DE CONEXION OleDbDataAdapter bd = new OleDbDataAdapter("select * from Clientes", conexionD);/// SENTENCIA DE BUSQUEDA ds = new DataSet(); bd.Fill(ds, "Clientes"); int filas = ds.Tables["Clientes"].Rows.Count; dr = ds.Tables["Clientes"].Rows[filas - 1]; //asigna los valores de los campos en los objetos del formulario txtCedula.Text = dr["CedulaRuc"].ToString(); txtNombres.Text = dr["Nombre"].ToString(); txtDireccion.Text = dr["Direccion"].ToString(); txtTelefono.Text = dr["Telefono"].ToString(); } /// EVENTO BUTTON_CLICK PARA BOTÓN GUARDAR private void btnGuardar_Click_1(object sender, EventArgs e) { conexion(); //Mandar a guardar guardarCliente(); btnGuardar.Visible = false; txtNombres.Enabled = false; txtDireccion.Enabled = false; txtTelefono.Enabled = false; } /// LINEA DE CÓDIGO QUE PERMITE QUE EL DATETIMEPICKER SOLO MUESTRE EL CALENDARIO HASTA LA FECHA ACTUAL

private void dateTimePicker1_ValueChanged(object sender, EventArgs e) { dtpFecha.MaxDate = DateTime.Today; } /// EVENTO BUTTON_CLICK QUE MUESTRA EL FORM2 (INVENTARIO) private void button2_Click(object sender, EventArgs e) { inventario.Show(); } /// EVENTO BUTTON_CLICK QUE LLAMA A METODO BUSQUEDACLIENTE() private void btnBuscar_Click(object sender, EventArgs e) { busquedaCliente(); } /// EVENTO BUTTON_CLICK PARA BOTON ACTUALIZAR private void btnActualizar_Click(object sender, EventArgs e) { txtNombres.Enabled = true; txtDireccion.Enabled = true; txtTelefono.Enabled = true; btnGuardar.Visible = true; } /// METODO AGREGAR FILA QUE CAPTURA EL VALOR DE LOS PRODUCTOS DE CADA FILA DEL DETALLE DE PRODUCTOS Y LLAMA AL METODO CALCULOS() public void agregarFila(String codigo, String descripcion, double pu, int cantidad) { double valor = cantidad * pu; dgProductos.Rows.Add(codigo, cantidad, descripcion, pu, valor); calculos(); } /// METODO QUE HACE LOS CALCULOS RESPECTIVOS public void calculos() { double subtotal = 0; double iva = 0; double total = 0; int columnasTotals = int.Parse(dgProductos.Rows.Count.ToString());/// ALMACENAMOS LA CANTIDAD DE COLUMNAS QUE TIENE EL DATAGRIDVIEW for (int i = 0; i < columnasTotals; i++) { subtotal += Convert.ToDouble(dgProductos.Rows[i].Cells[4].Value);/// SUMA LOS VALORES DE LA COLUMNA 4(TOTAL) DE CADA FILA PARA OBTENER EL SUBTOTAL }

txtSubtotal.Text = subtotal.ToString();/// ESCRIBIMOS EL RESULTADO EN EL TEXTBOX iva = (subtotal * 12) / 100; txtIva.Text = iva.ToString(); total = subtotal + iva; txtTotal.Text = total.ToString(); } private void dgProductos_UserDeletedRow(object sender, DataGridViewRowEventArgs e) { calculos(); } ///*** BOTON PARA ALMACENAR LA FACTURA ***//// private void saveToolStripButton_Click(object sender, EventArgs e) { conexion(); string setenciasql = "INSERT INTO Factura (numFactura, Cliente, Fecha, Subtotal, Iva, Total) VALUES(@anumFactura,@acliente,@afecha,@asubtotal, @aiva,@atotal)"; OleDbCommand comando = new OleDbCommand(setenciasql, conexionD); comando.Parameters.Add(new OleDbParameter("@anumFactura", OleDbType.Integer));//creo el parametro comando.Parameters["@anumFactura"].Value = Convert.ToInt32(txtNumeracion.Text);//asigno el valOr comando.Parameters.Add(new OleDbParameter("@acliente", OleDbType.VarChar, 10)); comando.Parameters["@acliente"].Value = txtCedula.Text; comando.Parameters.Add(new OleDbParameter("@afecha", OleDbType.Date)); comando.Parameters["@afecha"].Value = dtpFecha.Value.Date;

comando.Parameters.Add(new OleDbParameter("@asubtotal", OleDbType.Integer));| comando.Parameters["@asubtotal"].Value = Convert.ToInt32(txtSubtotal.Text); comando.Parameters.Add(new OleDbParameter("@aiva", OleDbType.Double)); comando.Parameters["@aiva"].Value = double.Parse(txtIva.Text); comando.Parameters.Add(new OleDbParameter("@atotal", OleDbType.Double)); comando.Parameters["@atotal"].Value = double.Parse(txtTotal.Text); comando.Connection.Open(); // se habre la base de datos comando.ExecuteNonQuery(); // se ejecuta el comando comando.Connection.Close(); //cierra la coneccion int columnas = Convert.ToInt32(dgProductos.Rows.Count.ToString()); for (int i = 0; i < columnas - 1; i++) { string codigo = dgProductos.Rows[i].Cells[0].Value.ToString(); int cantidad = Convert.ToInt32(dgProductos.Rows[i].Cells[1].Value); int numFactura = Convert.ToInt32(txtNumeracion.Text); int valor = Convert.ToInt32(dgProductos.Rows[i].Cells[4].Value); string setencia = "INSERT INTO DetalleFactura (numFactura, codigoProducto, cantidad,

valorTotal) VALUES(@anumFactura,@acodigoProducto,@acantidad,@avalorTotal)"; OleDbCommand ingreso = new OleDbCommand(setencia, conexionD); ingreso.Parameters.Add(new OleDbParameter("@anumFactura", OleDbType.Integer)); ingreso.Parameters["@anumFactura"].Value = numFactura; ingreso.Parameters.Add(new OleDbParameter("@acodigoProducto", OleDbType.VarChar)); ingreso.Parameters["@acodigoProducto"].Value = codigo; ingreso.Parameters.Add(new OleDbParameter("@acantidad", OleDbType.Integer)); ingreso.Parameters["@acantidad"].Value = cantidad; ingreso.Parameters.Add(new OleDbParameter("@avalor", OleDbType.Integer)); ingreso.Parameters["@avalor"].Value = valor; ingreso.Connection.Open(); ingreso.ExecuteNonQuery(); // se ejecuta el comando ingreso.Connection.Close(); } MessageBox.Show("Guardado Exitoso"); } ///*** BOTON PARA ABRIR UNA FACTURA ***//// private void openToolStripButton_Click(object sender, EventArgs e) { string numFactura = Microsoft.VisualBasic.Interaction.InputBox("Ingrese Numero de Factura");/// aparece automaticamente para inh string cedula = txtCedula.Text; string nombres = txtNombres.Text.ToString(); string direc = txtDireccion.Text.ToString(); string telf = txtTelefono.Text.ToString(); string fecha = dtpFecha.Text.ToString(); string subtotal =txtSubtotal.Text.ToString(); string numeracion = txtNumeracion.Text; string iva = txtIva.Text.ToString(); string total = txtTotal.Text.ToString(); conexion(); /// PRIMERO SE REALIZA LA BUSQUEDA POR EL NUMERO DE FACTURA PARA LUEGO USAR LOS DATOS DE LA TABLA FCTURA QUE CONTIENEN UN CAMPO cliente /// string sentencia = "Select * From FACTURA Where numFactura = '" + numFactura + "'"; OleDbCommand comando = new OleDbCommand(sentencia,conexionD); conexionD.Open(); OleDbDataReader leer = comando.ExecuteReader(); if (leer.Read() == true) { numFactura = leer["numFactura"].ToString(); MessageBox.Show(leer["numFactura"].ToString()); cedula = leer["Cliente"].ToString(); // / CON ESTE DATO REALIZAMOS LA CONSULTA PARA EL DETALLE DE LA FACTURA MessageBox.Show(cedula); fecha = leer["Fecha"].ToString();

MessageBox.Show(fecha); subtotal = leer["Subtotal"].ToString(); iva=leer["Iva"].ToString(); total = leer["Total"].ToString();

} else { MessageBox.Show("Factura no Existe"); } conexionD.Close(); } } }

Form2 (Contiene el Stock de productos): using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Data.OleDb; namespace ProgramacionIFactura { public partial class Form2 : Form { // Delegado public delegate void TableDelegada(string codigo, string descripcion, double pu, int cantidad); //Evento public event TableDelegada CreacionFila; public String codigo; public String descripcion; public double pu; public int stock; public String [] Vector= new string[100]; public Form2() { InitializeComponent(); //Cargar Datos de la de los productos datosConexion(); } public void datosConexion() { OleDbConnection conexionD = new

OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Users\Compac\Desktop\PROGRAMACIONFACTURA\Inventario.accdb"); OleDbDataAdapter bd = new OleDbDataAdapter("select * from Productos", conexionD); DataRow dr; DataSet ds = new DataSet(); bd.Fill(ds, "Productos"); int filas = ds.Tables["Productos"].Rows.Count; for (int i = 0; i < filas-1; i++) { dr = ds.Tables["Productos"].Rows[i]; string codigo=dr["CodigoProducto"].ToString(); string descripcion=dr["Descripcion"].ToString(); string pu = dr["Pu"].ToString(); string stock = dr["Stock"].ToString(); dgInventario.Rows.Add(codigo, descripcion, pu, stock); } } private void dgInventario_DoubleClick(object sender, EventArgs e) { int aux=0; codigo = dgInventario[0,dgInventario.CurrentRow.Index].Value.ToString(); descripcion = dgInventario[1, dgInventario.CurrentRow.Index].Value.ToString(); pu = Double.Parse(dgInventario[2, dgInventario.CurrentRow.Index].Value.ToString()); stock = int.Parse(dgInventario[3, dgInventario.CurrentRow.Index].Value.ToString()); String cantidad = Microsoft.VisualBasic.Interaction.InputBox("Ingrese Cantidad");//para esto hice en //1. voy al explorador de soluciones y doy clic derecho donde dice referencias y busco visualBasic doy clic en aceptar //y listo puedo escribir la linea de arriba if (stock == 0 || int.Parse(cantidad) > stock || int.Parse(cantidad)= 0 && (Convert.ToInt32(txtbuscar.Text) y presionamos aceptar.

Una vez enlazado con el dataSet1. Se mostraran los campos de la tabla que se agrego en el dataset, a esos campos se los debe arrastrar a la sección de ―Detalle‖, los colocamos ordenadamente, ya que depende de como los ordenemos, cambiara la apariencia del reporte.

Una vez Terminada esta parte, llegamos a la parte final, donde realizaremos la codificación del Botón ―Generar Reporte‖ que se encuentra en el Formulario Report1Tabla. Damos doble clic sobre ese componente y se generara el evento click del botón, dentro de este evento escribiremos las siguientes líneas de código.

visualizartabla a = new visualizartabla();

CrystalReport1 informe = new CrystalReport1(); informe.SetDataSource(dt.Tables[0]); a.crystalReportViewer1.ReportSource = informe;

a.ShowDialog();

Y una vez Terminado todos los Pasos, al ejecutar nuestro proyecto se vera asi, con la tabla que muestra todos los datos de la base de datos y el reporte que se crea al dar clic sobre el botón de generación de reporte.

NOTAS IMPORT ANTES PARA LA CORRE CTA IMPLEM ENTACI ÓN DE LOS REPOR TES CON CRYST AL REPOR T. Cuando creamos de esta manera el reporte en VS 2010 tendría que agregar automáticamente las librerías necesarias, además configurar el App.Config de manera que la ejecución resulte exitosa. Pero por alguna razón en algunos VS 2010 no configura de manera correcta el App.config y nuestro reporte no se ejecuta, en otros no existe el problema. Estuve probando en diferentes VS 2010 sobre todo ultímate pero me sale un error, en otros no y todo es normal, tal vez sea porque algunos PC eran de X64 y otros de X32 pero, no hay problema si tenemos este error de ejecución el cual indica que no podemos compilar porque no se reconoce las librerías de CR.

Para que se ejecute de manera correcta solo tenemos que configurar el App.Config, agregando esta línea.



Y comentando la línea –>

Quedando el App.config como sigue: //////////////////////

Nuevo Proyecto --> Y escogemos una aplicación de C#

3. Nos aparecerá la siguiente Pantalla

350

4. Arrastramos todos los componentes necesarios a la Formulario, quedándonos así:

5. Se creara la Nueva Clase con constructor para recibir parámetros 6. Dar clic en Proyecto—> Agregar Windows Form

7. Nos aparecerá la nueva pantalla --> Clic en Aceptar

351

8. Arrastramos los componentes Nuevamente:

352

9. Regresamos al formulario 1. Y Cambiamos nombres de los TextBox

10. Damos doble clic y nos aparecerá la ventana de código e ingresamos los siguiente: a. PARA LLAMAR A LA OTRA CLASE

private void button1_Click(object sender, EventArgs e) { //Inicializamos la Clase Presentar //Y le enviamos lo que tenia los textos al constructor que recibe parametros

Presentar aas= new Presentar(txtNombre.Text, txtEdad.Text);

//Hacemos que se haga visible aas.Visible = true; }

11. En la clase Presentar debe tener el Constructor recibiendo Parámetros

public partial class Presentar : Form { public Presentar(String nombre, String edad) { InitializeComponent(); } }

12. Cambiamos los nombres a los Labels

353

13. Creamos un método que reciba parámetros para presentarlos y escribimos lo siguientes:

public void recibidoInformacion(String nmb, String dd) { lblNombre.Text=nmb; lblEdad.Text = dd; }

14. Llamamos al método recibido informacion de la siguiente manera:

public Presentar(String nombre, String edad) { recibidoInformacion(nombre, edad); InitializeComponent(); }

15. A si nos debe quedar

354

Conclusiones Con clases y métodos podemos ver que ambos se pueden pasar información Bibliografía

Desarrollo de Software en C# Comunidad virtual para profesionales y/o estudiantes de habla castellana. Geeks.ms Blogs sobre desarrolladores de la plataforma .NET y C# http://msdn.microsoft.com/es-es/library/ms173114%28v=vs.80%29.aspx

355

Actividad N° 8

ACTIVIDAD N°:

8

FECHA:

12/06/2013

TEMA:



UNIDAD N° 3:

CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

OBJETIVO:

Crear y manipular Objetos

PROBLEMA:

Desconocimiento sobre la creación y manipulación de objetos en Visual Estudio 2010 C#

Realizar una Aplicación en C# para crear y manipular objetos

INDICADOR DE EVALUACION:

q) Comunicación efectiva

VALORES:

Respeto, Honestidad, Responsabilidad.

r) Asuntos contemporáneos

TIPO DE ACTIVIDAD LUGAR

□Intraclase □Extraclase

ALCANCE

FORMA

□Individual

□Taller

□Práctica de laboratorio

□Grupal

□Síntesis, esquemas

□Práctica de clase

□Caso de estudio

□Resolución de problemas,

CALIFICACIÓN

□Investigativa

ejercicios

□Vinculación con la colectividad

□Ensayo, artículo □Informe

356

e exposición

Actividad N° 9

ACTIVIDAD N°:

TEMA:

UNIDAD N° 3:

9

FECHA:

14/06/2013

Ejercicio: Crear un formulario que permita validar campos a ingresar a través del control ErrorProvider. El Formulario deberá ser diseñado con los siguientes Datos de ingreso: Nombre del Trabajador Apellido Paterno Apellido Materno Sexo Fecha de nacimiento: Fecha de Ingreso Fecha de Egreso Y deberá obtener los siguientes resultados: Edad: Tiempo de servicio: Código autogenerado: Reglas: Todos los campos deben ser ingresados. En Apellidos Paterno, Materno y nombre, solo puede ingresarse letras y espacios. En Sexo solo ingresará femenino y masculino. En Fecha de Ingreso y Egreso. La fecha de Ingreso no puede ser mayor a la de hoy, y la fecha de egreso no puede ser menor a la de ingreso. Todo debe ser en mayúsculas, así el usuario ingrese minúsculas, deberá transformarse en mayúsculas. El código se generará con: año de nacimiento, dos primeras letras del apellido paterno, dos primeras letras apellido materno, dos primeras letras nombre, y un número randómico (al azar). CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

OBJETIVO:

Crear y manipular Objetos

PROBLEMA:

Desconocimiento para manipular objetos.

INDICADOR DE EVALUACION:

s) Comunicación efectiva

357

t) Asuntos contemporáneos VALORES:

Respeto, Honestidad, Responsabilidad. TIPO DE ACTIVIDAD

LUGAR

□Intraclase □Extraclase

ALCANCE

FORMA

□Individual

□Taller

□Práctica de laboratorio

□Grupal

□Síntesis, esquemas

□Práctica de clase

□Caso de estudio

□Resolución de problemas,

CALIFICACIÓN

□Investigativa

ejercicios

□Vinculación con la colectividad

□Ensayo, artículo □Informe

e exposición

Solucion o Resultados Ejercicio: 1. Crear un formulario que permita validar campos a ingresar a través del control ErrorProvider. 2. El Formulario deberá ser diseñado con los siguientes Datos de ingreso: 2.1. Nombre del Trabajador 2.2. Apellido Paterno 2.3. Apellido Materno 2.4. Sexo 2.5. Fecha de nacimiento: 2.6. Fecha de Ingreso 2.7. Fecha de Egreso 3. Y deberá obtener los siguientes resultados: 3.1. Edad: 3.2. Tiempo de servicio: 3.3. Código autogenerado: 4. Reglas: 4.1. Todos los campos deben ser ingresados. 4.2. En Apellidos Paterno, Materno y nombre, solo puede ingresarse letras y espacios. 4.3. En Sexo solo ingresará femenino y masculino. 4.4. En Fecha de Ingreso y Egreso. La fecha de Ingreso no puede ser mayor a la de hoy, y la fecha de egreso no puede ser menor a la de ingreso. 4.5. Todo debe ser en mayúsculas, así el usuario ingrese minúsculas, deberá transformarse en mayúsculas. 4.6. El código se generará con: año de nacimiento, dos primeras letras del apellido paterno, dos primeras letras apellido materno, dos primeras letras nombre, y un número randómico (al azar)

358

Para los Puntos (1, 2) se crea la siguiente Imagen

Para la elaboración de todos los puntos mencionados se deja todo el código utlizado en esa clase: using System; using System.Windows.Forms; namespace deber1 { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void btnGuardar_Click(object sender, EventArgs e) { controlarVacios(); // controlarIngresosEgresos(); //calculos(); //datos(); } public void controlarVacios() { error.Clear(); int op = 0; if (txtNombre.Text == "") { op = 1; error.SetError(txtNombre, "Nombre es Requerido."); } else error.Clear(); if (txtApellidoPat.Text == "") { op = 1;

359

error.SetError(txtApellidoPat, "Apellido Paterno es Requerido."); } else error.Clear(); if (txtApellidoMat.Text == "") { op = 1; error.SetError(txtApellidoMat, "Apellido Materno es Requerido."); } else error.Clear(); if (rbFemenino.Checked == false && rbMasculino.Checked == false) { op = 1; error.SetError(label5, "Genero es requerido."); } else error.Clear(); if (op == 0) { //Controlar Fechas par continuar controlarIngresosEgresos(); } } public void controlarIngresosEgresos() { int op1 = 0; if (dtpIngreso.Value > DateTime.Now) { op1=1; MessageBox.Show("La Fecha de Ingreso NO puede Ser Mayor a Hoy"); }else if (dtpEgreso.Value < dtpIngreso.Value) { op1 = 1; MessageBox.Show("Fecha de Egreso NO puede ser Menor a la Fecha de Ingreso"); } if (op1 == 0) { calculos(); //datos(); } } public void calculos() { //Edad int a_o = dtpNacimiento.Value.Year; int edad= DateTime.Now.Year - a_o; txtEdad.Text = ""+edad; //Servicio int a_o1 = dtpIngreso.Value.Year; int a_o2= dtpEgreso.Value.Year; int servicioA_os =a_o2-a_o1;

int meses1 = dtpIngreso.Value.Month; int meses2 = dtpEgreso.Value.Month; int servicioMeses = meses2 - meses1; int dias1 = dtpIngreso.Value.Day; int dias2 = dtpEgreso.Value.Day; int servicioDias = dias2-dias1;

360

txtServicios.Text = servicioA_os + ":Años, " + servicioMeses + ":Meses, " + servicioDias+":Dias"; Random varRandom = new Random(); int numeroRandom = varRandom.Next(0, 99); String cadPat = txtApellidoPat.Text[0] +""+ txtApellidoPat.Text[1]; String cadMat = txtApellidoMat.Text[0] + "" + txtApellidoMat.Text[1]; String cadNom = txtNombre.Text[0] + "" + txtNombre.Text[1]; txtCodigo.Text = a_o + "" + cadPat + "" + cadMat + cadNom + ""+numeroRandom; }

/*public void datos() { String cadPat = txtApellidoPat.Text; String cadMat = txtApellidoMat.Text; String cadNom = txtNombre.Text; lblDatos.Text = cadNom.ToUpper()+" "+cadPat.ToUpper()+" "+cadMat.ToUpper(); }*/

//CONTROL DE TECLAS private void txtNombre_KeyPress(object sender, KeyPressEventArgs e) { if (!(char.IsLetter(e.KeyChar)) && (e.KeyChar != (char)Keys.Back) && (!(char.IsSeparator(e.KeyChar)))) { e.Handled = true; return; } e.KeyChar = Char.ToUpper(e.KeyChar); } private void txtApellidoPat_KeyPress(object sender, KeyPressEventArgs e) { if (!(char.IsLetter(e.KeyChar)) && (e.KeyChar != (char)Keys.Back) && (!(char.IsSeparator(e.KeyChar)))) { e.Handled = true; return; } e.KeyChar = Char.ToUpper(e.KeyChar); } private void txtApellidoMat_KeyPress(object sender, KeyPressEventArgs e) { if (!(char.IsLetter(e.KeyChar)) && (e.KeyChar != (char)Keys.Back) && (!(char.IsSeparator(e.KeyChar)))) { e.Handled = true; return; } e.KeyChar = Char.ToUpper(e.KeyChar); } }

361

}

362

Actividad N° 10

ACTIVIDAD N°:

10

FECHA:

05/07/2013

Ejercicio:

1. Realizar una aplicación en C# donde simule las funciones de una calculadora.(Ver Calculadora de Windows) 2. Realizar una aplicación en C#, que simule el juego del ahorcado, coloco algunos lineamientos que deben considerar: a. Debe contar con al menos 4 categorías, por ejemplo: Animales, Ciudades, Películas, Canciones. (Ustedes eligen) b. Cada palabra a adivinar debe pertenecer únicamente a una categoría y se debe incluir una pista.

TEMA:

c. Cuando el jugador seleccione una categoría, las palabras a adivinar debe aparecer utilizando un orden aleatorio. d. Cada vez que se ingrese una letra que no se encuentra en la palabra a adivinar se debe dibujar el ahorcado, el juego terminará cuando se haya completado el dibujo. e. Se debe presentar guiones (_) por cada letra de la palabra a adivinar, cada vez que se adivine una letra, ésta debe reemplazar al guión.

UNIDAD N° 3:

CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C#

OBJETIVO:

Crear y manipular Objetos

PROBLEMA:

Desconocimiento para manipular objetos.

INDICADOR DE EVALUACION:

u) Comunicación efectiva

VALORES:

Respeto, Honestidad, Responsabilidad.

v) Asuntos contemporáneos

TIPO DE ACTIVIDAD LUGAR

ALCANCE

FORMA

363

□Intraclase □Extraclase

□Individual

□Taller

□Práctica de laboratorio

□Grupal

□Síntesis, esquemas

□Práctica de clase

□Caso de estudio

□Resolución de problemas,

CALIFICACIÓN

□Investigativa

ejercicios

□Vinculación con la colectividad

□Ensayo, artículo □Informe

364

e exposición

Desarrollo de la actividad

Ejercicio 1: 1. Realizar una aplicación en C# donde simule las funciones de una calculadora.(Ver Calculadora de Windows) Realizacion: 1. Creamos un nuevo proyecto 2. Creamos una clase tipo FORM: 3. Nos tiene que quedar la ventana:

4. Programamos todos los botones

CODIGO using using using using using using using using

System; System.Collections.Generic; System.ComponentModel; System.Data; System.Drawing; System.Linq; System.Text; System.Windows.Forms;

namespace Deber2 { public partial class Form1 : Form

365

{ int contadorDecimal; int contadorSuma; int contadorMultiplicacion = 1; int contadorResta = 1; int contadorPotencia=1; int contadorDivision = 1; double valor1; int decimalInt=1; Boolean cont; double [] vectorOperaciones = new double[1]; double [] vectorMultiplicacion=new double[2]; int operacionesCasos; public Form1() { InitializeComponent(); } private void btnRetroceso_Click(object sender, EventArgs e) { if(txtIngreso.Text[0]!=0){ if (txtIngreso.TextLength == 1) { txtIngreso.Text = "0"; } else { String texto=txtIngreso.Text.Substring(0, txtIngreso.TextLength - 1); txtIngreso.Text = texto; } } } private void btnCe_Click(object sender, EventArgs e) { } private void btnC_Click(object sender, EventArgs e) { txtIngreso.Text = "0"; } private void btnMasMenos_Click(object sender, EventArgs e) { valor1 = double.Parse(txtIngreso.Text); if (valor1 != 0) { if (valor1 < 0) { valor1 = valor1 * (-1); txtIngreso.Text = valor1+""; } else { valor1 = valor1 * (-1); txtIngreso.Text = valor1 + ""; } } } private void btnRaiz_Click(object sender, EventArgs e) { valor1 = double.Parse(txtIngreso.Text);

366

double valor1Double = double.Parse(txtIngreso.Text); if (valor1 != 0) { valor1Double = Math.Sqrt(valor1Double); txtIngreso.Text = valor1Double + ""; } } private void btn7_Click(object sender, EventArgs e) { if (txtIngreso.TextLength