Porta Folio

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




UNIDAD II: BASE DE DATOS SQL Y ADO .NET ................................................................................... 42



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




Semana N° 5 Día 2: Clase 10 ............................................................................................................... 128









Semana N° 10 Día 1: Clase 19 ............................................................................................................ 239




UNIDAD IV: PRESENTACIÓN DE RESULTADOS .............................................................................. 291


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


FACULTAD DE INGENIERÌA CIVIL

CARRERA DE INGENIERÌA DE SISTEMAS

SYLLABUS ESTANDARIZADO

1.- DATOS GENERALES

Asignatura:

PROGRAMACIÓN I

Código de la Asignatura:

IS502

Eje Curricular de la Asignatura:

PROFESIONAL

Año:

2013 - 2014

Horas presenciales teoría:

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

Semestrales.

Ciclo/Nivel:

4to. Semestre

Horas presenciales práctica:

4 horas de clase presenciales en laboratorios o en el

campo por semanas / 40 horas Semestrales.

Número de créditos:

5 (CINCO)

Horas atención a estudiantes:

Horas trabajo autónomo:

5 horas semanales / 80 horas

semestrales

Fecha de Inicio:

6/Mayo/2013

Fecha de Finalización:

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

CONTRIBUCIÓN (alta, media,

baja) EL ESTUDIANTE DEBE:

a) Habilidad para

aplicar el

conocimiento de las

Ciencias Básicas de

la profesión

BAJA

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.

b) Pericia para diseñar

y conducir

experimentos, así

como para analizar e

interpretar datos.

BAJA

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.

c) Destreza para el

manejar procesos de

Ingeniería de

Sistemas

ALTA

Diseñar componentes de código

reutilizables, para su implementación entre

diferentes proyectos de desarrollo de

software aplicables en distintos contextos

de negocio.

d) Trabajo

multidisciplinario. MEDIA

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.

e) Resuelve problemas

de Ingeniería de

Sistemas.

ALTA

Identificar problemas informáticos

generales que involucren parámetros

comunes y determinen subrutinas

reutilizables.

f) Comprensión de sus

responsabilidades

profesionales y éticas

BAJA

Asumir la participación en las actividades

con responsabilidad.

Demostrar su participación e innovación

de únicamente los involucrados y

entregarlo a tiempo

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 COMPETENCIAS RESULTADOS DE APRENDIZAJE

I.

―INTRODUCCIÓN

A .NET‖

1.- Identificar los objetivos

del lenguaje de

programación C#.

1.- Describe conceptos y terminología

sobre el lenguaje de programación.

2.- Reconoce los componentes del IDE

g) Comunicación

efectiva ALTA

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.

h) Impacto en la

profesión y en el

contexto social

----------

i) Aprendizaje para la

vida BAJA

Practicar la investigación para comprender

la necesidad de seguir capacitándose

continuamente.

j) Asuntos

contemporáneos BAJA

Analizar problemas de actualidad y más

comunes del negocio, que se resuelvan

con soluciones informáticas de escritorio.

k) Utilización de

técnicas e

instrumentos

modernos

BAJA

Conocer nuevas metodologías y técnicas

de programación que simplifiquen

procesos de extracción y transformación

de datos

l) Capacidad para

liderar, gestionar o

emprender proyectos

BAJA

Dirigir grupos de trabajo, liderando su área

de mayor competencia con empatía.

2.- Identificar los

componentes del IDE de

Visual C#.

de C#.

3.- Navega y utiliza la ayuda.

II. ―BASE DE

DATOS SQL Y

ADO .NET‖

1.- Conectar una Base de

Datos con el lenguaje de

programación C#.

2.- Gestionar la

información de la Base de

Datos.

3.- Utilizar funciones en

C#.

1.- Escribe programas que se conectan

a una base de datos y muestren la

información.

2.-Construye sistema que permiten

realizar operaciones CRUD con

integridad y seguras sobre la base de

datos

II. ―CONCEPTO

DE INTERFAZ

GRÁFICA DE

USUARIO Y

PROGRAMACIÓN

EN C#

1.- Identificar los métodos

a programar en la

construcción de un sistema

2.- Manejar controles que

se pueden utilizar para que

la interfaz gráfica sea

amigable.

3.- Utilizar programación

modular.

4.- Aplicar y emplear el

lenguaje C# para el

desarrollo, implementación

y mantenimiento de los

sistemas.

1.- Crea interfaces gráficas amigables y

flexibles.

2.- Utiliza nombres estandarizados,

comentarios, documentación y sangría

para facilitar la posterior lectura del

código.

3.- Crea funciones utilizando datos por

valor y referencia.

4.- Programa métodos que muestren

características de bajo acoplamiento y

alta cohesión.

5.- Construye módulos que valida el

ingreso de datos para la integridad de

la información.

IV.

―PRESENTACIÓN

DE

RESULTADOS‖

1.- Crear y generar

informes necesarios para

la toma de decisiones.

1.- Crea interfaces que permiten

parametrizar los informes.

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

programación

1.1. Diagnó

stico

1.2. Historia

,

Concepto,

importanci

a

1.3. Introdu

cción a las

computado

res y C#

Elaboración del objetivo personal

para el módulo.

Lectura: Dos enfoques de

programación

Elaboración de un mapa conceptual

sobre ¿Qué es programar?

Resolución de Casos de Estudio

Elaboración de línea de tiempo

sobre evolución de los lenguajes de

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.

5

2.-

13/05/13

–

18/05/13

Net

Framework

4.0

Introducción

al IDE de

Visual C#

1.4. ¿Qué

es?

Novedades

.

Composici

ón.

1.5. Arquite

ctura,

tecnología

y WPF.

1.6. Genera

lidades,

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 ESTRATEGIAS DE

APRENDIZAJE

HORAS

3.-

20/05/13 –

25/05/13

Conexión a

Base de

Datos

Tipos de

datos por

Valor y

Referencia

2.1.

Arquitectura

ADO

2.2. Crear una

conexión

mediante el

asistente

2.3. Crear

conexión

mediante

programación.

2.4.

Declarando y

trabajando con

variables,

comparación

Investigaciones para profundizar

los temas.

Elaboración de cuadro sinóptico

sobre ADO.

Elaborar un cuadro comparativo

acerca de los DBMS que trabajan

con C# (Características, Ventajas,

Desventajas)

Práctica de laboratorio

Taller para implementar diagrama

E/R en el DMBS seleccionado.

Elaboración de mapas mentales

sobre los Tipos de datos por valor

y referencia.

Elaboración de cuadros sinópticos

sobre las Funciones en C#.

5

4.-

27/05/13 –

01/06/13

Términos y

definiciones.

2.5.

Funciones.

2.6. Nombres


los temas.

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

TEMAS CONTENIDOS ESTRATEGIAS DE APRENDIZAJE HOR

AS

4.-

27/05/13

–

01/06/13

Formularios

Windows

Forms

3.1.

Principales

controles


temas.


Ensayo acerca de los objetos GUI

que se pueden utilizar para crear la

interface gráfica en C#.

4

5.-

03/06/13

–

08/06/12

Formularios

Windows

Forms

3.1.

Principales

controles

3.2.

Propiedades


temas.


Elaboración de listas de verificación

acerca de las características de un

buen diseño de interface para el

usuario.

5

6.-

10/06/13

–

15/06/13

Manejo de

Eventos

Manejo de

excepciones.

3.2. Clases y

Métodos

3.3.

Programación

de métodos.

3.4. ¿Qué es?

System.Excep

cion

Generalidades

, ejemplos


temas.

Práctica de Laboratorio.

Lecturas sobre el tema.

Elaboración de lista de verificación

acerca de las características de un

buen diseño de entrada / salida.

5

7.-

17/06/13

–

22/06/13

Operaciones

CRUD

3.5. Adicionar.

Navegar


temas.


5

Taller - Caso de Estudio

8.-

24/06/13

–

29/06/13

Operaciones

CRUD

3.5. Eliminar,

Modificar


temas.



5

01/07/13

–

06/07/13

EXAMEN HEMISEMESTRE

9.-

08/07/13

–

13/07/13

Programació

n Avanzada

3.6. Valores

automáticos

3.7.

Validaciones

de datos


temas.



5

10.-

15/07/13

–

20/07/13

Integridad 3.8. Validación

Integridad

llave principal

3.9.

Validaciones

llave ajena


temas.


Resolución de caso de Estudio.

5

11.-

22/07/13

–

27/07/13

Consultas

Manejo de

Varias tablas

3.10.

Búsqueda de

registros.

3.11.

Formularios

Maestro –

Detalle.

Cálculos


temas.



temas.


5

12.-

29/07/13

–

03/08/13

Acceso al

Sistema

3.12.Formulari

os MDI

3.13. Creación

y manejo de

Menús,

Usuarios


temas.


5

TOTAL DE HORAS DE UNIDAD III 44

UNIDAD IV: PRESENTACIÒN DE RESULTADOS

SEMANAS

DE

TEMAS CONTENIDOS ESTRATEGIAS DE HORAS

ESTUDIO APRENDIZAJE

13.-

05/08/13 –

10/08/13

Crystal

Reports y

Visual C#

4.1. Creación y

ejecución

4.2. Informes

tipo maestro –

detalle

4.3. Informes

con filtros y

quiebre de

control


los temas.


5

14.-

12/08/13 –

17/08/13

Proyecto 4.8. Desarrollo

de un proyecto

dirigido

Práctica de Laboratorio 5

15.-

19/08/13 –

24/08/13

Proyecto 4.8. Desarrollo

de un proyecto

dirigido

Práctica de Laboratorio 5

16.-

26/08/13 –

31/08/13

Proyecto 4.8. Defensa

de Proyectos

Presentación de un informe

técnico escrito y presentación oral

sobre las bondades y

características de la solución

desarrollada para la institución

seleccionada.

5

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 Y

MEJORAMIENTO

TOTAL DE HORAS DE UNIDAD IV 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://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

mailto:[email protected]

mailto:[email protected]

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.

CURRÍCULO

Apellidos: Honores Cun Nombres: Jennifer Honores

Curso: Tercero Semestre: Primer Paralelo: ―A‖ Sección: Diurna

C.I.: 0706418514 Fecha de nacimiento: 14/09/1992

Edad: 18

Correo electrónico: [email protected] Facebook: Jennifer.Honores Convencional: Celular 1: 0998075497 Celular 2: Domicilio: Urb. La Primavera Provincia: El Oro Cantón: Machala Parroquia: Machala Dirección: Referencia: Sexo: Femenino Estado Civil: Soltero Croquis de su domicilio:

Datos del Padre Apellidos y Nombres: Honores Ordoñez Pedro Luis Celular:

Datos de la Madre Apellidos y Nombres: Cun Lopez Luz Emilia Celular: 0998431264 Donde trabaja: Dirección del trabajo: Dirección domiciliaria: Urb. La Primavera

Datos del cónyuge (en caso de tenerlo) Apellidos y Nombres: Celular: Donde trabaja: Dirección del trabajo: Dirección domiciliaria: Número de hijos: Observaciones:

Datos del Trabajo: (en caso de tenerlo) Donde trabaja: Renacer Sector: Dirección del trabajo: Teléfono 1: Teléfono 2:

UNIVERSIDAD TÉCNICA DE

MACHALA FACULTAD DE INGENIERÍA CIVIL

ESCUELA DE INFORMÁTICA Carrera de Ingeniería de Sistemas


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 en las áreas de las tecnologías de la informática y las

comunicaciones.

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

CLASE N°: 1 PERÍODO 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.

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

APUNTES DE CLASE



TIEMPO: 2 Horas

FECHA: 08/05/2013



Contenidos

Historia del C#.

Ventajas de C#.


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.



- 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)


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.

http://es.wikipedia.org/wiki/Turbo_Pascal

http://es.wikipedia.org/wiki/J%2B%2B

http://es.wikipedia.org/wiki/Embarcadero_Delphi

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


No se nos hizo difícil nada.


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.


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

APUNTES DE CLASE



TIEMPO: 1 Horas

FECHA: 10/05/2013



Contenidos

Evolución de los lenguajes de Programación.

Sistemas Automatizados


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#



- 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#.


Creación del Lenguaje

Ensamblador

1 Jan 1950


C# 1 Enero 1980

Reflexionar


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#.


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.


- 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.



TIEMPO: 2 Horas

FECHA: 13/05/2013



Contenidos

Introducción a Visual Estudio 2010

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


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#



- 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.


- Visual Estudio 2010

- C#


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

http://es.wikipedia.org/wiki/Entorno_de_desarrollo_integrado

http://es.wikipedia.org/wiki/Windows

http://es.wikipedia.org/wiki/Visual_C%2B%2B

http://es.wikipedia.org/wiki/C_sharp

http://es.wikipedia.org/wiki/Visual_Basic_.NET

.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


No hubieron temas difíciles con relación a Visual Estudio 2010 C#


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.


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

APUNTES DE CLASE

1. Ingresar a Visual Estudio 2010

http://es.wikipedia.org/wiki/Visual_Basic_.NET

http://es.wikipedia.org/wiki/ASP.NET

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 aparecerá la siguiente

pantalla

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. En esta

ventana podemos cambiar las propiedades de cada componente

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



TIEMPO: 2 Horas

FECHA: 20/05/2013


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#


Aprender a hacer conexiones con una base de datos y Visual Estudio 2010


Competencia General


Aprende a hacer Conexiones BD y C#



- 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



- Base de datos en Visual Studio 2010


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


Al momento de crear conexiones de base de datos como programador uno debe saberse el código de conexión.


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.


- 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. Creamos una base de

datos

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 crea y se agrega al Explorador de 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 la ventana Orígenes de datos, seleccione Agregar nuevo origen de datos.

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 la ventana Elegir un modelo de base de datos, seleccione Conjunto de datos y, a

4.5. continuación, haga clic en Siguiente.

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.

O bien

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

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



TIEMPO: 2 Horas

FECHA: 27/05/2013


TEMA DISCUTIDO: UNIDAD II: BASE DE DATOS SQL Y ADO .NET

Contenidos


Creación de Base de datos en Microsoft Acces

Conexiones de Base de datos mediante Código


Aprender a hacer conexiones con una base de datos y Visual Estudio 2010


Competencia General


Aprende a hacer Conexiones BD y C#



- 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



- Base de datos en Visual Studio 2010


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


Al momento de crear conexiones de base de datos como programador uno debe saberse el código de conexión.


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.


- 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. Llenamos los campos según el tipo de

dato

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 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 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#


CLASE N°: 7 PERÍODO 27/05//2013 al 31/05/2012

TIEMPO: 2 Horas

FECHA: 29/05/2013


TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y

PROGRAMACIÓN EN C#

Contenidos

Windows Forms

Principales controles

Propiedades


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.



- Hubieron exposiciones de Compañeros

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

CheckBox

CheckBoxList

ComboBox

DateTimePicker.

MonthCalendary.

Listbox

ListView


- CheckBox

- Check BoxList

- ComboBox

- DateTimePicker.

- MonthCalendary.

- ListBox

- ListView


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.

http://msdn.microsoft.com/es-es/library/system.windows.forms.checkedlistbox.aspx

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


Todo estuvo bien explicado


Realizar las practicas

¿Por qué?

Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los

talleres


- 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


y escribimos

y escribimos


y escribimos

y escribimos

Para cambiarle el nombre a los Button seleccionamos:

button1 y en Propiedades buscamos:

y escribimos

y escogemos

y escribimos


y escribimos

y escribimos


y escribimos

y escribimos


y escribimos

y escribimos


y escribimos

y escribimos


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


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.

http://msdn.microsoft.com/es-es/library/system.windows.forms.monthcalendar(v=vs.90).aspx

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.



TIEMPO: 1 Horas

FECHA: 31/05/2013



PROGRAMACIÓN EN C#

Contenidos

Windows Forms


Propiedades







cohesión.


información

Competencia General










MaskedTextBox

NotifyIcon

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

Tooltip.


- MaskedTextBox

- NotifyIcon

- Tooltip.


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



http://librosweb.es/javascript/capitulo_8/tooltip.html

http://msdn.microsoft.com/es-es/library/system.windows.forms.maskedtextbox.maskedtextbox(v=vs.80).aspx

http://msdn.microsoft.com/es-es/library/system.windows.forms.maskedtextbox(v=vs.80).aspx



¿Por qué?


talleres



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")



TIEMPO: 2 Horas

FECHA: 03/06/2013



PROGRAMACIÓN EN C#

Contenidos

Windows Forms


Propiedades



Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la

posterior lectura del código.



cohesión.

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

Competencia General




Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento

de los sistemas.





PictureBox

ProgressBar

RadioButton

TreeView

NumericUpDown

GroupBox

TabControl

MenuStrip

ContextMenuStrip


- PictureBox

- ProgressBar

- RadioButton

- TreeView

- NumericUpDown

- GroupBox

- TabControl

- MenuStrip

- ContextMenuStrip


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 Nombre Descripción

ErrorImage 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


Step 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


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

Checked Indica si el botón de

radio esta activado o no.

TextAlign 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:

http://msdn.microsoft.com/es-es/library/system.windows.forms.treeview.nodes(v=vs.80).aspx

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





¿Por qué?


talleres



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:



y escribimos

y escribimos

Button2 y en Propiedades buscamos:

y escribimos

y escribimos

Picturebox1 y en Propiedades buscamos:

y escribimos

4 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:



y escribimos

y escribimos


y escribimos

y escribimos


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 <= 0) { MessageBox.Show("No ahi como eliminar porque no se agregado pestañas"); } else { TabPage vacio = tabControl1.SelectedTab; pestana.Remove(vacio); tabControl1.TabPages.Remove(vacio); contarPestana--; } }

private void button1_Click(object sender, EventArgs e) { crearPestana(); } private void button2_Click(object sender, EventArgs e) { EliminarPestana(); } public string mbox { get; set; } } }

Ahora probaremos si funciona.

Si no se agregado pestañas y se desea eliminar se muestra un mensaje, esto permite que el

programa no se cuelgue.

Aquí eh agregado 3 pestañas

Aquí eliminare la pestaña 1

Propiedades TabControl

La forma más sencilla para establecer las propiedades es de la ventana Propiedades. Puede abrir

la ventana Propiedades presionando F4 o haga clic derecho en un control y seleccione la opción

del menú Propiedades.

Entre las propiedades más importantes tenemos:

- Name: Indica el nombre con el que vamos a manejar nuestro tabControl.

- Appeance: podemos cambiar la apariencia de nuestro tabControl

- Dock: le da la posición dentro de nuestra ventana.

- Font: Permite personalizar el tipo y tamaño de letra

- ItemSize: Permite modificar el tamaño del tabPage

- Size: permite modificar el tamaño de nuestro tabControl

- TabPage: permite personalizar por separado cada una de nuestras pestañas.

- Multiline: Al ponerla true permite que si son bastantes pestañas las alinee.

TabPages

Propiedad TabPages, un tipo de objeto TabPageColleciton es la puerta de acceso y agregar

páginas de fichas a un TabControl. Al igual que cualquier otra colección, TabPageCollection tiene

toda la funcionalidad de colección que incluye agregar, eliminar y buscar.

Podemos añadir y acceder a páginas de fichas de TabControl en tiempo de diseño de la ventana

Propiedades, haga clic en TabPagesCollection.

Al hacer clic en las colecciones, la ventana del Editor de la colección Pages Tab se abrirá donde

usted puede añadir y eliminar páginas con pestañas y también se puede establecer estas páginas

de propiedades y eventos de ficha.

En las propiedades más importantes tenemos:

- Name: Nombre con el que se manejara esa pestaña

- BackColor: Imagen de fondo de la pestaña.

- BackgroundImage: Nos permite poner una imagen de fondo a la pestaña.

- BackgroundImageLayout: permite ubicar la imagen como nosotros deseemos.

- BorderStyle: permite poner un estilo de borde a la pestaña

- Cursor: Permite definir el tipo de cursor que deseemos usar dentro de la pestaña

- Font: el tipo y tamaño de letra dentro de la pestaña

- ForeColor: el color de las letras dentro de las pestañas

- ImagenIndex: Permite poner una imagen como icono (procederé a explicar más adelante)

- Text: Permite poner un nombre a nuestra pestaña.

Como poner un icono o imagen al TabPages

Primero arrastramos desde el cuadro de

herramientas hasta nuestra ventana un Imagelist,

que nos permitirá guardar nuestras imágenes, luego

en las propiedades del ImageList buscamos la

opción Images y se nos abrirá una ventana al

seleccionarla. Ahí podremos agregar o quitar

imágenes.

Luego el siguiente paso es cargar esas imágenes a

nuestro TabControl de la siguiente manera lo hare.

Me ubico en las propiedades del TabControl y busco la opción ImageList y selecciono mi

ImageList que arrastre a mi ventana yo la tengo con nombre ImageList1

Luego dentro del modo diseño selecciono la pestaña que deseo ponerle el icono y dentro de las

propiedades del TabPages busco la opcion ImageIndex (es donde se encuentran nuestras

imágenes cargadas en el ImageLis).

Luego desplegamos y escogemos la imagen deseada. Puedo ponerle icono a todas mis pestañas.

El resultado final es:



TIEMPO: 2 Horas

FECHA: 05/06/2013



PROGRAMACIÓN EN C#

Contenidos

Windows Forms


Propiedades







cohesión.


información

Competencia General










Tool strip

Status strip

Timer

ErrorProvider

ColorDialog

FolderBrowserDialog

OpenFileDialog

SaveFileDialog


- Tool strip

- Status strip

- Timer

- ErrorProvider

- ColorDialog

- FolderBrowserDialog

- OpenFileDialog

- SaveFileDialog


TOOL STRIP

Según (Ferguson, 2010) Este control proporciona una barra de herramientas en la

interfaz de usuario, lo arrastramos de la misma manera que el control anterior, al

formulario; luego se puede observar cómo se aparece una barra de herramientas en

la parte superior.

STATUS STRIP

Según (Microsoft, 2013) ―StatusStrip reemplaza el control StatusBar. Las características especiales de StatusStrip incluyen un diseño de tabla personalizada, compatibilidad con los controles de tamaño y movimiento del formulario y con la propiedad Spring, que permite que ToolStripStatusLabel rellene automáticamente espacio disponible.

TIMER

http://msdn.microsoft.com/es-es/library/system.windows.forms.statusbar(v=vs.80).aspx

http://msdn.microsoft.com/es-es/library/system.windows.forms.toolstripstatuslabel.spring(v=vs.80).aspx

http://msdn.microsoft.com/es-es/library/system.windows.forms.toolstripstatuslabel(v=vs.80).aspx

El componente Timer es un temporizador basado en servidor que

permite especificar un intervalo recurrente en el que se provoca el

evento Elapsed en la aplicación. Entonces, se puede controlar este

evento para proporcionar un procesamiento normal. Por ejemplo,

supongamos que un servidor crítico debe mantenerse en

funcionamiento las 24 horas del día y los 7 días de la semana.

Puede crearse un servicio que utilice Timer para comprobar

periódicamente el servidor y asegurarse de que el sistema se

encuentra en funcionamiento. Si el sistema no responde, el servicio

podría intentar reiniciar el servidor o notificárselo a un administrador.

El Timer basado en servidor está diseñado para utilizarlo con

subprocesos de trabajo en un entorno multiproceso.

ERRORPROVIDER

ErrorProvider presenta un mecanismo simple para indicar al usuario final que un control de

un formulario tiene un error asociado. Si se especifica una cadena de descripción de error

para el control, se muestra un icono junto a éste. El icono parpadea de la manera que

especifica BlinkStyle, con la frecuencia que especifica BlinkRate. Cuando el mouse (ratón)

pase por encima del icono, se mostrará la información sobre herramientas con una cadena

de descripción del error.

Normalmente, ErrorProvider se utiliza con controles enlazados a datos. Si utiliza

ErrorProvider con controles enlazados a datos, debe especificar la propiedad

ContainerControl en el constructor o estableciendo la propiedad ContainerControl.

COLORDIALOG

Representa un cuadro de diálogo común que muestra los colores disponibles, así como los

controles que permiten a los usuarios definir colores personalizados. Se debe invocar al

miembro heredado ShowDialog para crear este cuadro de diálogo común específico. Se

utiliza Color para recuperar el color seleccionado por el usuario.

Cuando se crea una instancia de ColorDialog, se establecen algunas propiedades de lectura

y escritura en sus valores iniciales. Para obtener una lista de esos valores, vea el constructor

ColorDialog.

FOLDERBROWSERDIALOG

Con frecuencia, en las aplicaciones para Windows que cree, deberá pedir a los usuarios que

seleccione una carpeta; en la mayoría de los casos para guardar un conjunto de archivos. El

componente FolderBrowserDialog de formularios Windows Forms permite realizar esta tarea

con facilidad.

OPENFILEDIALOG

OpenFileDialog permite a los usuarios navegar por las carpetas y seleccione los archivos.

Está disponible en Windows Forms y se puede utilizar con el código C #. Se muestra el

cuadro de diálogo estándar de Windows. Los resultados de la selección se pueden leer en el

código C #.

http://msdn.microsoft.com/es-es/library/system.timers.timer.elapsed(v=vs.80).aspx

SAVEFILEDIALOG

El componente SaveFileDialog permite a los usuarios examinar el sistema de archivos y

seleccionar los archivos que deseen guardar. El cuadro de diálogo devuelve la ruta de

acceso y el nombre del archivo que seleccionó el usuario en el cuadro de diálogo. Sin

embargo, debe escribir el código para escribir realmente los archivos en el disco.

Reflexionar





¿Por qué?


talleres



APUNTES DE CLASE

Práctica con la herramienta:

TOOL STRIP


Arrastramos los controles desde

ToolBox hasta el formulario:

1 toolStrip1

1 Button

1 richTextBox1

Luego procedemos a insertar los elementos estándar

Cambiamos el valor por defecto de la propiedad CheckOnClick a true

Ahora damos doble clic en:

Botón de ayuda y escribimos este código

Botón Nuevo y escribimos este código

Botón Abrir y escribimos este código

Botón Guardar y escribimos este código

Botón agregar item y escribimos este código


STATUS STRIP

Arrastramos la propiedad Status Strip.

Y nos queda así:

Seleccionamos StatusLabel

Ahora seleccionamos un ProgressBar

Le cambiamos el nombre al StatusLabel:

Y nos queda así:

Lo usado en statusStrip

El método barra para que cada vez que llame al método el statusLabel creado cambie al

especificado y el progressBar también.

El Timer lo encontramos en la barra de herramientas y nos ayuda con la herramienta de

progressBar y en el if indicamos que ProgressBar va a incrementar de 2 en 2 hasta completar

el máximo y asi se muestra y presenta el mensaje.

Código de toda la práctica:

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.IO;

namespace WindowsFormsApplication13

{

public partial class Form1 : Form

{

String nombre;

public Form1()

{

InitializeComponent();

}

private void ayudaToolStripButton_Click(object sender, EventArgs e)

{

MessageBox.Show(String.Format("checked: (0)",

ayudaToolStripButton.ToString()));

}

private void button1_Click(object sender, EventArgs e)

{

toolStrip1.Items.Add("Nuevo Boton", Properties.Resources.exit);

}

private void guardarToolStripButton_Click(object sender, EventArgs e)

{

toolStripProgressBar1.Value = 0;

barra();

StreamWriter sw = new StreamWriter(nombre,true);

sw.WriteLine(txt.Text);

sw.Close();

}

private void abrirToolStripButton_Click(object sender, EventArgs e)

{

OpenFileDialog f = new OpenFileDialog();

f.ShowDialog();

nombre = f.FileName;

StreamReader sr = new StreamReader(nombre);

txt.Text = sr.ReadToEnd();

sr.Close();

}

private void nuevoToolStripButton_Click(object sender, EventArgs e)

{


barra();

txt.Text = "";

nombre = "";

}

private void Form1_Load(object sender, EventArgs e)

{

barra();

}

public void barra()

{

toolStripStatusLabel1.Text = "Cargando....Por favor espere";

timer1.Enabled = true;

toolStripProgressBar1.Minimum = 0;

toolStripProgressBar1.Maximum = 100;

timer1.Interval = 50;

}

private void timer1_Tick(object sender, EventArgs e)

{

toolStripProgressBar1.Value = toolStripProgressBar1.Value + 2;

if (toolStripProgressBar1.Value >= 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)

{


timer1.Enabled = true;

timer1.Interval = 50;

toolStripStatusLabel1.Text = "Cargando nuevamente...";

}

private void limpiarBarraToolStripMenuItem_Click(object sender, EventArgs e)

{


toolStripStatusLabel1.Text = "Barra de progreso";

}

}

}


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


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.


COLORDIALOG

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

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

1 2

3

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:


{

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

}

}


{

if (colorDialog1.ShowDialog() == DialogResult.OK)

{

textBox1.BackColor = colorDialog1.Color;

//cambia de color de fondo de la caja de texto

}

}


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

http://msdn.microsoft.com/es-ec/library/system.windows.forms.form.dialogresult.aspx

http://msdn.microsoft.com/es-ec/library/system.windows.forms.folderbrowserdialog.aspx

http://msdn.microsoft.com/es-ec/library/system.windows.forms.folderbrowserdialog.selectedpath.aspx

http://msdn.microsoft.com/es-ec/library/system.windows.forms.folderbrowserdialog.aspx

http://msdn.microsoft.com/es-ec/library/system.windows.forms.folderbrowserdialog.rootfolder.aspx

http://msdn.microsoft.com/es-ec/library/system.environment.specialfolder.aspx

http://msdn.microsoft.com/es-ec/library/system.windows.forms.folderbrowserdialog.description.aspx

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:


{

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

}

}


{

//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();

}


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



TIEMPO: 2 Horas

FECHA: 10/06/2013



PROGRAMACIÓN EN C#

Contenidos

Windows Forms


Propiedades







cohesión.


información

Competencia General










FontDialog

PrintDialog

LineShape

OvalShape

RectangleShape


- FontDialog

- PrintDialog

- LineShape

- OvalShape

- RectangleShape


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





¿Por qué?


talleres


http://msdn.microsoft.com/es-es/library/system.printing.printticket.aspx

http://msdn.microsoft.com/es-es/library/system.printing.printqueue.aspx


APUNTES DE CLASE


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.

http://msdn.microsoft.com/es-es/library/system.windows.forms.form%28v=vs.80%29.aspx

http://msdn.microsoft.com/es-es/library/system.windows.forms.textbox%28v=vs.80%29.aspx

http://msdn.microsoft.com/es-es/library/system.drawing.font%28v=vs.80%29.aspx

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.


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.



TIEMPO: 2 Horas

FECHA: 12/06/2013



PROGRAMACIÓN EN C#

Contenidos

Windows Forms

Manejo de Excepciones en Visual Estudio C#






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


Competencia General





de los sistemas.





Manejo de Excepciones


- Excepciones en C#


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

{


}

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

{


}

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

{


}

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





¿Por qué?


talleres



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(); } } }



TIEMPO: 2 Horas

FECHA: 01/07/2013



PROGRAMACIÓN EN C#

Contenidos

Revision de temas para expsiciones








Competencia General





de los sistemas.



A cada grupo les dio tema para exposición



TIEMPO: 2 Horas

FECHA: 03/07/2013



PROGRAMACIÓN EN C#

Contenidos

Examen Objetivo de Hemisemestre








Competencia General





de los sistemas.



La Ing. Realizo a los estudiantes un examen objetivo de fin de

Hemisemestre.



TIEMPO: 2 Horas

FECHA: 15/07/2013



PROGRAMACIÓN EN C#

Contenidos

Revision de Examen Objetivo de Hemisemestre








Competencia General





de los sistemas.



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



TIEMPO: 2 Horas

FECHA: 17/07/2013



PROGRAMACIÓN EN C#

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

Contenidos

Windows Forms









Competencia General





de los sistemas.





Valores automáticas y validación de datos


- 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





¿Por qué?


talleres



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");

}



TIEMPO: 2 Horas

FECHA: 22/07/2013



PROGRAMACIÓN EN C#

Contenidos

Windows Forms









Competencia General





de los sistemas.





Validacion de llaves primarias y ajenas

Formularios MDI


- 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.

http://es.wikipedia.org/wiki/Interfaz_de_documento_%C3%BAnico

http://es.wikipedia.org/wiki/Microsoft

http://es.wikipedia.org/wiki/Microsoft_Office

http://es.wikipedia.org/wiki/Barra_de_tareas

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





¿Por qué?


talleres



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.

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

Factura

Cliente

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á:


{

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.



TIEMPO: 2 Horas

FECHA: 24/07/2013



PROGRAMACIÓN EN C#

Contenidos

Windows Forms




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




Competencia General




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





Busquedad de Registros

Formulario Maestro Detalle


- 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





¿Por qué?


talleres



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

5: lregistros

6: lerror

7: button2

27: button4

28: button1

29: button3

1: comboBox1

2: comboBox2

19: csueldo

21: cfecha

24: cordenacion

3: tbuscar

8: tcedula

9: tnombre

10: tapellido

12: tciudad

13: ttelefono

14: tsueldo

15: fced

16: fnom

17: fape

18: fciu

DateTimePicker RadioButton Datagridview

11: tfecha

22: fdate1

23: fdate2 (oculto)

25: asc

26: desc

4: dataGridView1

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;


{

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 = "";



OleDbDataAdapter da = new OleDbDataAdapter(sql, con);




lregistros.Text = (dataGridView1.Rows.Count - 1) + " de " + totalRegistros;

if ((dataGridView1.Rows.Count - 1) == 0)

{

lerror.Text = "¡No hay registros!";

}

}

catch (Exception ex)

{


}

}

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 = "";









{


}

}


{


}

}

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.



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 = "";




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;

}


{


}

}

12. Evento button2

Este botón únicamente ajustará el tamaño del formulario y deshabilitará tbuscar.

Código:


{

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:


{

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



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 = "";









{


}

}


{


}

}

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:


{

llenarTabla();

}

16. Evento button3

Este evento ajustará el formulario para que su tamaño se reduzca y habilitará el

tbuscar

Código:


{

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

Hacemos click en el botón FACTURACION.

Si no recordamos los códigos de producto podemos hacer click en INVENTARIO y doble

click para agragar el producto a la factura.

A

B

C

D

G

F E

H

Ingresamos la cantidad y aceptamos.

I

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) { MessageBox.Show("Error: <1. No hay cantidad en Stock> <2. Cantidad debe ser Mayor que 0>"); } else { if (Vector[0] == null) { //No se ha ingresado nada a la columna //Si se puede vender this.CreacionFila(codigo, descripcion, pu, int.Parse(cantidad)); Vector[0] = codigo; } else { int i=0; // int j = 0; do { if (Vector[i].Equals(codigo)) { MessageBox.Show("No se puede Agregar Ya esta en lista"); aux = 1; } i = i + 1; } while (Vector[i] != null); if (aux != 1) { Vector[i] = codigo;

this.CreacionFila(codigo, descripcion, pu, int.Parse(cantidad)); } } } } } }



TIEMPO: 2 Horas

FECHA: 29/07/2013



PROGRAMACIÓN EN C#

Contenidos

Windows Forms








Competencia General








- Cada estudiante iba haciendo sus prácticas de cada tema expuesto Servicios Web Validacion de usuarios


- Servicios WEB - Validacion de Usuarios

CREAR SERVICIOS WEB

El desarrollo de aplicaciones en entorno Internet ha pasado por distintas etapas desde los inicios con

el protocolo HTTP, los navegadores y los documentos HTML.

El panorama del desarrollo de aplicaciones .Net se caracteriza por la gran sofisticación que han

alcanzado los servidores y las herramientas de desarrollo asociadas. Por un lado, desde el punto de

vista diseño, en el que contamos con herramientas visuales de todo tipo y editores HTML que vacían

las delicias de los viejos programadores de ‗Bloc de Notas‘.

En resumen podríamos decir:

Son componentes que nos permiten crear aplicaciones independientes de la

plataforma.

Se pueden usar servicios Web para integrar aplicaciones escritos en lenguajes

diferentes.

Un servicio Web consta de los siguientes 3 elementos:

El Servicio:

Software que procesa ciertos documentos XML bien definidos recibidos mediante alguna

combinación de protocolos de transporte y de aplicación.

El Documento XML:

Contiene toda la información específica de la aplicación que el consumidor del servicio envía al

servicio para procesar.

La Dirección:

Una dirección de red junto con un binding de protocolo que puede utilizarse para acceder al servicio.

En la práctica, hace falta un cuarto elemento:

La Envoltura:

Un protocolo de encapsulación de mensajes que separa el documento UML de la otra información

que se quiere intercambiar.

Herramientas de desarrollo para un Web Services

Usando un editor de textos o WebMatrix

Usando Visual Studio.Net

Comportamiento de un Aplicación Web

Una aplicación Web es aquella en la que los usuarios se conectan a través de un servidor Web

mediante una Intranet o Internet. Los servicios Web pueden involucrarse dentro de ella haciendo

referencia al servidor de servicios Web mediante una referencia Web.

Comportamiento de una aplicación Windows

Las aplicaciones Windows, de igual modo, hacen referencia a un servicio Web, ya que poseen la

opción de hacer referencia Web que cargara todas las funcionalidades que nos proporcionaran, al

igual que hacer una referencia a un componente.

VALIDACION DE USUARIOS

La validación de usuarios o Autenticación es, en otras palabras, la autorización que tienen las

diferentes personas que manipulan el sistema, lo cual permite asignarles restricciones a dichas

personas. Por ejemplo: un usuario puede observar datos mas no dar mantenimiento al sistema, en

cambio un administrador tiene acceso a todos los datos disponibles dentro del mismo.

El objetivo de los sistemas de identificación de usuarios no suele ser identificar a una persona, sino

autenticar que esa persona es quien dice ser realmente.

Un ejemplo familiar es el control de acceso. Un sistema informático supuesto para ser utilizado

solamente por aquellos autorizados, debe procurar detectar y excluir el desautorizado. El acceso a él

por lo tanto es controlado generalmente insistiendo en un procedimiento de la autentificación para

establecer con un cierto grado establecido de confianza la identidad del usuario, por lo tanto

concediendo esos privilegios como puede ser autorizado a esa identidad. Los ejemplos comunes del

control de acceso que implican la autenticación incluyen:

- Retirar de dinero de un cajero automático.

- Control de un computador remoto sin Internet.

- Uso de un sistema Internet banking.

Sin embargo, observar que mucha de la discusión sobre estos asuntos es engañosa porque los

términos se utilizan sin la precisión. Parte de esta confusión puede ser debido ―al tono de la aplicación

de ley‖ de mucha de la discusión. Ninguna computadora, programa de computadora, o poder del

usuario de la computadora ―confirman la identidad‖ de otro partido. No es posible ―establece‖ o

―probar‖ una identidad, cualquiera. Hay ediciones difíciles que están al acecho debajo de qué aparece

ser una superficie directa.

MANEJO DE MENUS

Para ser más específicos, el control Context Menú Strip es un control que proporciona un menú

contextual, los menús contextuales aparecen en la posición del mouse, cuando el mouse hace clic

sobre el botón secundario. Los menús contextuales, proporcionan opciones para el área del cliente o

el control en la ubicación del puntero del mouse.

En nuestro proyecto, los usaremos como se los utilizaría dentro de la validación de usuarios, es decir,

ciertos usuarios tendrán los privilegios para acceder a las funciones del sistema.

Reflexionar





¿Por qué?

Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres



APUNTES DE CLASE

EJERCICIO PRACTICO: Servicios WEB

GENERAR UN NUMERO DE LOTERIA

Creamos un nuevo proyecto Windows forms aplication.

Procedemos a crear :

4 labels

4 textbox pero uno de ellos le habilitaremos la propiedad multilinea.

1 button

Ahora deberemos proceder a importar nuestro webservice que vamos a consumir de la red.

Escribimos la dirección web de la cual vamos a importar el webservice y damos clic en go, allí nos

daremos cuenta los métodos con los cuenta nuestro webservice.

Ahora creamos un objeto del servicio que importamos.

También creamos variables de tipo entero y le asignamos el valor que se ingrese en cada una de los

textbox.

Presentamos en el último textbox el número se generó.

EJERCICIO 2:

Desarrollar una aplicación Web que permita el ingreso eliminación y búsqueda de estudiantes en

usa Base de Datos de Microsoft Access haciendo uso de servicios web

1. Creamos un nuevo proyecto de Aplicación Web de ASP.Net

2. Seguido creamos los métodos necesarios para nuestra aplicación que se detallan a continuación

Buscar

Eliminar

Insertar

BuscarTodo

3. Una vez codificados los métodos y si ejecutamos el servicio tendremos lo siguiente

4. Creamos un nuevo proyecto de tipo Aplicación Web de ASP.NET para poder consumir los servicios

creados.

5. Diseñamos un formulario Web sencillo como el que presentamos a continuación

6. Seguidamente agregamos a nuestro proyecto la referencia Web para poder hacer uso de los servicios

creados en el paso 2, nos situamos sobre el explorador de soluciones y damos clic derecho sobre

referencias y damos cli en agregar referencia Web.

Dirección URL del servicio web

Métodos del servicio web

Agregamos la Referencia Web al

proyecto

7. Codificación de los eventos del formulario

namespace Cliente_web { public partial class WebForm1 : System.Web.UI.Page { localhost.Service1 servicio = new localhost.Service1(); protected void Page_Load(object sender, EventArgs e) { actualizar(); btnregistrar.Enabled = false; txtnombre.Enabled = false; txtnota1.Enabled = false; txtnota2.Enabled = false; txtnota3.Enabled = false; lista.Enabled = false; btncancelar.Enabled = false; btnnuevo.Enabled = true; } protected void btnregistrar_Click(object sender, EventArgs e) { String nombre = txtnombre.Text; String curso = (String)lista.SelectedValue; String nota1 = txtnota1.Text.Trim(); String nota2 = txtnota2.Text.Trim(); String nota3 = txtnota3.Text.Trim(); if (nombre.Equals("") || nota1.Equals("") || nota2.Equals("") || nota3.Equals("")) { lblmensaje.Text = "Llene todos los campos !"; } else { if (servicio.Insertar(nombre, curso, nota1, nota2, nota3)) { lblmensaje.Text = "Alumno Registrado"; } else { lblmensaje.Text = "Alumno no Registrado"; } txtnombre.Text = ""; txtnota1.Text = ""; txtnota2.Text = ""; txtnota3.Text = ""; actualizar(); btncancelar_Click(null, null);

} } protected void btneliminar_Click(object sender, EventArgs e) { String id = txteliminar.Text.Trim(); if (!id.Equals("")) { if (servicio.Eliminar(id)) { lblmensaje.Text = "Alumno Eliminado"; } else { lblmensaje.Text = "Alumno no Eliminado"; } } else { lblmensaje.Text = "Ingrese un Id para eliminar"; } actualizar(); } protected void btnbuscar_Click(object sender, EventArgs e) { String texto = txtbuscar.Text.Trim(); if (texto.Equals("")) { lblmensaje.Text = "Ingrese datos para buscar"; } else { DataSet ds = new DataSet(); if (servicio.Buscar(texto, ref ds)) { GridView1.DataSource = ds; GridView1.DataBind(); lblmensaje.Text = " "; } else { lblmensaje.Text = "No hay registros"; actualizar(); } } } protected void btnnuevo_Click(object sender, EventArgs e) { btnnuevo.Enabled = false; btnregistrar.Enabled = true;

txtnombre.Enabled = true; txtnota1.Enabled = true; txtnota2.Enabled = true; txtnota3.Enabled = true; lista.Enabled = true; txteliminar.Enabled = false; btneliminar.Enabled = false; btnbuscar.Enabled = false; txtbuscar.Enabled = false; btncancelar.Enabled = true; } protected void btncancelar_Click(object sender, EventArgs e) { txteliminar.Enabled = true; btneliminar.Enabled = true; btnbuscar.Enabled = true; txtbuscar.Enabled = true; btnregistrar.Enabled = false; txtnombre.Enabled = false; txtnota1.Enabled = false; txtnota2.Enabled = false; txtnota3.Enabled = false; lista.Enabled = false; btncancelar.Enabled = false; btnnuevo.Enabled = true; } public void actualizar() { DataSet ds = new DataSet(); servicio.BuscarTodo(ref ds); GridView1.DataSource = ds; GridView1.DataBind(); } protected void lista_SelectedIndexChanged(object sender, EventArgs e) { } protected void txtbuscar_TextChanged(object sender, EventArgs e) { try { if (Convert.ToInt32(txtbuscar.Text) >= 0 && (Convert.ToInt32(txtbuscar.Text) <= 1000)) { }

else { txtbuscar.Text = ""; } } catch (Exception) { txtbuscar.Text = ""; } } }

8. Compilación y pruebas del Formulario

Ejemplo Validación de Usarios:

Se realizara un programa para validar o controlar el acceso de los usuarios al sistema, el que se tendrán

dos tipos de acceso (USUARIO Y ADMINISTRADOR):

1. Creamos nuestro proyecto

Seleccionamos Windows Form Aplication

2. Primero crearemos el formulario de usuario y contraseña, el cual se lo realizara arrastrando los

componentes necesarios para este formulario (Textbox, Label, Button).

3. Ahora, se creara el formulario para controlar el ingreso de los usuarios, para crear un nuevo

formulario realizamos lo siguiente:

Damos clic en el menú proyecto, seleccionamos agregar Windows Forms:

4. Primero agregaremos un DataGridView en el Form2

5. También, crearemos un pequeño formulario debajo del DataGridView, el cual se lo utilizara para

la edición de datos del DataGridView:

6. Dentro del Form2, se manejaran menús, los mismos que se insertan de la siguiente manera:

Una vez insertado el MenuStrip en el formulario, procedemos a escribir los menús que se utilizaran en el programa:

7. Dentro de los menús podemos colocar teclas de acceso rápido lo cual se hace lo siguiente:

a. Dentro de cada menú le colocamos el método de teclas de acceso, la cual se la realiza

por la propiedades Short Curt Key que heredan todos los menú :

b. También se colocan iconos en cada menú el cual se lo puede realizar dándole clic

derecho al menú y eligiendo la opción Elegir Imagen.

c. La otra manera de colocar un icono dentro de los menús es dentro de la ventana de

propiedades.

8. Por último, se necesitara de un formulario para poder actualizar los datos del usuario que ingresa

al sistema, el mismo que quedaría de la siguiente manera:

Una vez hechos los formularios, necesitaremos de una base de datos y a su vez de una clase que maneje todas las sentencias sql, que permita el manejo de la base de datos para el sistema.

9. Se creara una nueva clase, a la que llamaremos conexión:

Le damos clic derecho en la solución de nuestro proyecto, elegimos agregar y a su vez Nuevo elemento

En el dialogo, elegimos la opción Clase y ponemos el nombre de conexión

10. Crearemos una clase en Acces, y tendrá que tener los siguientes campos:

11. Ahora, entrando en la parte lógica del sistema, lo primero que vamos a hacer es crear los

métodos en la clase conexión.cs:

Instanciamos variables globalmente: public static DataRow dr;

public static OleDbConnection con; public static DataSet ds; public static String sql; public static OleDbDataAdapter da; public static OleDbCommand comando; public String tipo; public String nombre;

public conexion() { //se establece la conexion a la base de datos

con = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Users\Personal\Desktop\Programacion\Datos.accdb");

} Crearemos un método que nos retorne un modelo de tabla, el cual será visualizado en el DataGrdiView del form2: public static DataTable llenar_tabla()

{ da = new OleDbDataAdapter("SELECT * FROM Personal", con); ds = new DataSet(); //Se llena el dataset

da.Fill(ds, "Personal"); return ds.Tables["Personal"]; //retorna las tablas de dataSet }

El método ValidacionIngreso controla la entrada de los datos de los usuarios al iniciar sesión public Boolean ValidacionIngreso(String id,String cont){

int numDatos = 0;

sql = "SELECT * FROM Personal WHERE Cedula='" + id + "' AND Pass='" + cont + "'"; try{ da = new OleDbDataAdapter(sql, con); ds = new DataSet(); da.Fill(ds, "Personal"); numDatos =ds.Tables["Personal"].Rows.Count dr = ds.Tables["Personal"].Rows[0]; tipo = dr["Tipo"].ToString(); nombre = dr["Nombre"].ToString(); }catch(Exception e){ } if ((numDatos) == 0)//si no hay filas , no encontro datos { return false; }else{ return true; } }



TIEMPO: 2 Horas

FECHA: 31/07/2013



PROGRAMACIÓN EN C#

Contenidos

Windows Forms








Competencia General








- Cada estudiante iba haciendo sus prácticas de cada tema expuesto Respaldar y restaurar archivos


- Respaldar y restaurar archivos

Respaldar y restaurar una base de datos

Respaldo de Base de Datos

Según la página de Microsoft (2013) ―Indica que el respaldo ayuda a proteger una base de datos

frente a problemas del sistema y a errores que el comando Deshacer no puede resolver En

Microsoft Office Access 2007, puede usar el comando Deshacer 20 veces como máximo para

revertir los cambios que ha realizado desde la última vez que guardó el archivo de base de datos.

Sin embargo, cuando se utiliza una consulta de acción para eliminar registros o cambiar

datos, no puede deshacer esos cambios con el comando Deshacer.

Es esencial realizar copias de seguridad periódicas

Para decidir con qué frecuencia debe realizar copias de seguridad, considere la frecuencia con la

que cambia la base de datos:

Si la base de datos es una base de datos de archivo, o se utiliza sólo como referencia y apenas

cambia, debe realizar una copia de seguridad cada vez que cambien los datos.

Si la base de datos está activa y los datos cambian frecuentemente, debe realizar una copia de

seguridad según una programación.

Si la base de datos no contiene datos, sino que utiliza tablas vinculadas, debe realizar una copia

de seguridad de la base de datos siempre que cambie su diseño.‖

Restaurar una base de datos

Según la página de Microsoft(2013) ―Para restaurar una base de datos, debe disponer de una

copia de seguridad de la base de datos.

Una copia de seguridad recibe a menudo el nombre de "copia válida conocida" de un archivo de

base de datos, es decir, una copia de la que está seguro de su diseño y de la integridad de sus

datos. Debe usar el comando Realizar copia de seguridad de la base de datos de Microsoft

Office Access para hacer copias de seguridad, pero puede usar cualquier copia válida conocida

para restaurar una base de datos. Por ejemplo, puede restaurar una base de datos a partir de

una copia almacenada en un dispositivo USB externo de copia de seguridad.

Puede restaurar toda la base de datos o algunos de sus objetos.

Si no dispone de una copia de seguridad, existe el peligro de que se pierdan datos, se efectúen

cambios no deseados o se dañe el diseño de la base de datos. Por este motivo, debe hacer

copias de seguridad periódicamente. Para obtener más información sobre cómo planear y crear

copias de seguridad de bases de datos, vea el artículo Hacer una copia de seguridad de una

base de datos.

Restaurar una base de datos completa

Cuando se restaura una base de datos completa, se reemplaza el archivo de base de datos que

está dañado, que tiene problemas en los datos o que falta, por una copia de seguridad de toda la

base de datos.

Si no dispone del archivo de base de datos, coloque la copia de seguridad en la ubicación donde

debe estar la base de datos.

Restaurar parte de una base de datos

Para restaurar un objeto de base de datos, el objeto se importa de la copia de seguridad a la

base de datos que contiene (o al que le falta) el objeto que desea restaurar. Puede restaurar

varios objetos a la vez.

Abra la base de datos en la que desea restaurar un objeto.

Si desea restaurar un objeto que falta, como una tabla eliminada por error, vaya al paso 3. Si

desea reemplazar un objeto que contiene datos erróneos o inexistentes, o que ha dejado de

funcionar correctamente, siga uno de estos procedimientos:

Si desea conservar el objeto actual (por ejemplo, para compararlo con la versión restaurada

cuando finalice la operación), debe cambiar el nombre del objeto antes de restaurarlo. Por

ejemplo, si desea restaurar un formulario dañado denominado Desprotección, puede cambiar el

nombre del formulario dañado aDesprotección_inservible.

http://office.microsoft.com/es-es/access-help/redir/HA010235586.aspx?CTT=5&origin=HA010235588

http://office.microsoft.com/es-es/access-help/redir/HA010235586.aspx?CTT=5&origin=HA010235588

Elimine el objeto que desea reemplazar.

CORREOS ELECTRÓNICOS

¿De qué trata?

Es un servicio de red que permite a los usuarios enviar y recibir mensajes y archivos rápidamente

(también denominados mensajes electrónicos o cartas electrónicas) mediante sistemas de

comunicación electrónicos.

Principalmente se usa este nombre para denominar al sistema que provee este servicio en

Internet, mediante el protocolo SMTP, aunque por extensión también puede verse aplicado a

sistemas análogos que usen otras tecnologías.

Por medio de mensajes de correo electrónico se puede enviar, no solamente texto, sino todo tipo

de documentos digitales (imágenes, músicas, etc.) dependiendo del sistema que se use.

Su eficiencia, conveniencia y bajo coste están logrando que el correo electrónico desplace al

correo ordinario para muchos usos habituales.

Estructura General

Destinatario: una o varias direcciones de correo a las que ha de llegar el mensaje.

Asunto: una descripción corta que verá la persona que lo reciba antes de abrir el correo.

Adjunto: Cualquier tipo de archivo que se desee enviar.

El propio mensaje: Puede ser sólo texto, o incluir formato, y no hay límite de tamaño.

Reflexionar





¿Por qué?




APUNTES DE CLASE

Respaldar una base de datos en Sql Server

Para crear una base de datos en SQL Server

Respaldar Restaurar Base de datos Desde Microsoft Visual C#

http://es.wikipedia.org/wiki/Mensaje

http://es.wikipedia.org/wiki/Carta

http://es.wikipedia.org/wiki/TIC


http://es.wikipedia.org/wiki/Internet

http://es.wikipedia.org/wiki/SMTP

http://es.wikipedia.org/wiki/Correo_ordinario

Para hacer un respaldo de cierta base de datos se realiza lo siguiente:

En primer lugar creamos la base de datos en SQL Server 2008 como observaremos a

continuación:

Después de abierto el SQL Server 2008 nos conectamos con el Motor de Base de datos Y

agregamos el nombre del Servidor: CRISTHIAN-PC\SQLEXPRESS y en Autenticación

designamos: Autenticación de Windows.

Una vez conectado el Motor de Base de datos del SQL Server 2008 con su respectivo

servidor creamos las BD con sus tablas; primero le damos click derecho en Base de Datos

y elegimos Nueva base de datos.

Luego colocamos el nombre de la Base de datos en este caso Ejemplos y le damos Aceptar

De esta manera se crea la Base de datos Ejemplo luego de esto crearemos las tablas de la

siguiente manera: Click en BD Ejemplos, click derecho en Tablas y Nueva Tabla

Aquí crearemos una tabla llamada Factura

Y observaremos las 3 tablas creadas de la Base de Datos Ejemplos.

Luego ya nos dirigimos a Microsoft Visual C# para hacer la conexión: En Explorador de

servidores; Click derecho en Conexiones de datos y elegimos Agregar conexión

Vamos a elegir el origen de Datos le daremos Click en Cambiar

Luego de dar Click en Cambiar elegiremos lo siguiente: la opción Microsoft SQL Server y

Aceptar

En esta ventana elegiremos el Nombre del Servidor que usamos y el nombre de la Base de

Datos y Aceptar

Eso es todo y verificaremos la Conexión y automáticamente la Bd de SQL Server 2008

aparecerá en Microsoft Visual Studio C#

Luego de tener la Base de Datos conectada a C# creamos un Proyecto y Formulario

agregamos 2 botones que serán RESPALDAR BD y RESTAURAR BD

Nos dirigimos al botón RESPALDAR DB le damos doble click y procedemos a color el siguiente

código:

El siguiente código hace referencia al evento que maneja el botón ―RESPALDAR BD‖, como el

mismo lo indica permite respaldar un base de datos.

private void button1_Click(object sender, EventArgs e) { Se presenta un mensaje que informa la operación que se realizará MessageBox.Show("RESPALDAR");

Para evitarnos errores de ejecución utilizamos el boque de captura try{}, catch{} try { La clase SqlConnetion permite crear la conexión con la base de datos SqlConnection cn = new SqlConnection(@"Data Source=CRISTHIAN-PC\SQLEXPRESS;Initial Catalog=Ejemplos;Integrated Security=True"); Luego usamos la clase que nos permite crean sentencias en SQL para poder operar sobre la base de datos: En nuestro caso el commando que nos permitirá crear el respaldo es BACKUP SqlCommand cmd = new SqlCommand(@"Backup database [Ejemplo] to disk='c:\copia\Ejemplo.bak'", cn); cn.Open(); cmd.ExecuteNonQuery(); cn.Close(); } catch(Exception ex) { MessageBox.Show(ex.Message); } }

Al ejecutar el formulario damos click en Respaldar y la Base de Datos se creara en determinada

ruta con formato .bak

Aquí observamos el respaldo de la Base de Datos

Luego le damos Click a RESTAURAR BD y se realiza el siguiente código:

El siguiente código corresponde al evento de restaurar la base de datos private void button2_Click(object sender, EventArgs e) { MessageBox.Show("RESTAURAR"); try { SqlConnection connect = new SqlConnection(@"Data Source=CRISTHIAN-PC\SQLEXPRESS;Initial Catalog=Ejemplo;Integrated Security=True"); connect.Open(); La clase SqlCommand permite ejecutar comandos SQL SqlCommand command; command = new SqlCommand("use master", connect); command.ExecuteNonQuery(); El comando RESTORE permite restaurar la base de datos tal como lo indica la siguiente línea de código command = new SqlCommand(@"restore database Ejemplo from disk = 'C:\copia\Ejemplo.bak'", connect); command.ExecuteNonQuery(); Cerramos la conexión a la base de datos

connect.Close(); } catch (Exception ex) { MessageBox.Show(ex.Message); } } } }

Y verificaremos si se Restauró la Base de Datos primero eliminamos una tabla de la base datos actual para luego verificar si se restaura

Aquí Ejecutamos el programa.

Aquí se debe cerrar todas las conexiones para que no suceda ningún problema y aquí verificamos la restauración

Respaldar Restaurar Base de datos Desde Microsoft Visual C#

Para hacer un respaldo de cierta base de datos se realiza lo siguiente:

Luego de tener la Base de Datos conectada a C# creamos un Proyecto y Formulario

agregamos 2 botones que serán RESPALDAR BD y RESTAURAR BD

Anteriormente no hemos realizado este tipo de ejemplo además luego de tener el primer

paso verificamos la conexión a la Base de Datos

Nos dirigimos al botón RESPALDAR DB le damos doble click y procedemos a color el siguiente

código:

private void button1_Click(object sender, EventArgs e) { MessageBox.Show("RESPALDAR"); try { SqlConnection cn = new SqlConnection(@"Data Source=CRISTHIAN-PC\SQLEXPRESS;Initial Catalog=Ejemplo;Integrated Security=True"); SqlCommand cmd = new SqlCommand(@"Backup database [Ejemplo] to disk='c:\copia\Ejemplo.bak'", cn); cn.Open(); cmd.ExecuteNonQuery(); cn.Close(); } catch(Exception ex) { MessageBox.Show(ex.Message); } }

Al ejecutar el formulario damos click en el formulario y la Base de Datos se creara en determinada

ruta con formato .bak

Aquí observamos el respaldo de la Base de Datos

Luego le damos Click a RESTAURAR BD y se realiza el siguiente código:

private void button2_Click(object sender, EventArgs e) { MessageBox.Show("RESTAURAR"); try { Creamos la conexión a la base de datos utilizando la clase SqlConnection, enviando la ruta de conexión a la base de datos. SqlConnection connect = new SqlConnection(@"Data Source=CRISTHIAN-PC\SQLEXPRESS;Initial Catalog=Ejemplo;Integrated Security=True"); Abrimos la conexión a la base de datos connect.Open(); //-------------------------------------------------------------------------- //esto es un método aparte para ejecutar comandos SQL---------------- La siguiente variable nos permite utilizar comandos en SQL SqlCommand command; command = new SqlCommand("use master", connect); command.ExecuteNonQuery(); command = new SqlCommand(@"restore database Ejemplo from disk = 'C:\copia\Ejemplo.bak'", connect); command.ExecuteNonQuery(); //--------------------------------------------------------------------------

connect.Close(); } catch (Exception ex) { MessageBox.Show(ex.Message); } } } }



TIEMPO: 2 Horas

FECHA: 05/08/2013



PROGRAMACIÓN EN C#

Contenidos

Windows Forms








Competencia General








- Cada estudiante iba haciendo sus prácticas de cada tema expuesto Creacion y envio de email


- Creacion y envio de email

CORREOS ELECTRÓNICOS

¿De qué trata?

Es un servicio de red que permite a los usuarios enviar y recibir mensajes y archivos rápidamente

(también denominados mensajes electrónicos o cartas electrónicas) mediante sistemas de

comunicación electrónicos.

Principalmente se usa este nombre para denominar al sistema que provee este servicio en

Internet, mediante el protocolo SMTP, aunque por extensión también puede verse aplicado a

sistemas análogos que usen otras tecnologías.

Por medio de mensajes de correo electrónico se puede enviar, no solamente texto, sino todo tipo

de documentos digitales (imágenes, músicas, etc.) dependiendo del sistema que se use.

Su eficiencia, conveniencia y bajo coste están logrando que el correo electrónico desplace al

correo ordinario para muchos usos habituales.

http://es.wikipedia.org/wiki/Mensaje

http://es.wikipedia.org/wiki/Carta



http://es.wikipedia.org/wiki/Internet

http://es.wikipedia.org/wiki/SMTP

http://es.wikipedia.org/wiki/Correo_ordinario

Estructura General

Destinatario: una o varias direcciones de correo a las que ha de llegar el mensaje.

Asunto: una descripción corta que verá la persona que lo reciba antes de abrir el correo.

Adjunto: Cualquier tipo de archivo que se desee enviar.

El propio mensaje: Puede ser sólo texto, o incluir formato, y no hay límite de tamaño.

CREACIÓN Y ENVÍO DE CORREOS ELECTRÓNICOS.

Para crear y enviar un mensaje de correo electrónico, siga estos pasos:

Crear el objeto MailMessage. MailMessage y otras clases relacionadas al mail están en el

namespace System.Net.Mail. Si no ha especificado los beneficiarios en la MailMessage

constructor, añadirlos al objeto MailMessage.

Si es necesario, crear uno o más objetos Adjunto y añadirlos al objeto MailMessage.

Crear un objeto smtpclient y especificar el servidor SMTP. Si este servidor requiere para la

autenticación de clientes, añadir credenciales al objeto smtpclient.

Pase su objeto MailMessage al método SmtpClient.Send. Si lo prefiere, pueden utilizar

SmtpClient. SendAsync para enviar el mensaje asincrónicamente.

Como crear un mensaje (objeto MailMessage):

Para crear un eMail, cree un objeto MailMessage, especifiquen el remitente, el asunto, el cuerpo

del mensaje y el destinatario o destinatarios; y los archivos adjuntos si es que quieren enviarlos.

El Objeto MailMessage tiene cuatro diferentes constructores que permiten crear un espacio en

blanco, especificar tanto el remitente y el destinatario, o bien especificar el remitente,

destinatario, asunto y el cuerpo del mensaje. Si está creando un mensaje sencillo con un único

destinatario, puede hacer la mayor parte del trabajo en la MailMessage constructor:

Para adjuntar un archivo, añadirlo a la MailMessage.Attachments AttachmentCollection llamando

al método MailMessage.Attachments.Add. La manera más simple de añadir un archivo es

especificar el nombre del archivo:

Como enviar un mensaje (servidor SMTP)

MailMessage m1 = new MailMessage (“[email protected]”,

“[email protected]”, “Informe de Ingresos Trimestrales.”,

“Vease documento de Informacion Adjunto”);

MailMessage m2 = new MailMessage ();

m2.Attachments.Add (new Attachment (“C:/boot.ini”));

Para enviar un mensaje, cree una instancia de SmtpClient. Configúrelo con el hostname del

servidor SMTP y llame al método SmtpClient.Send.

Si llama al método SmtpClient.Send sin definir el hostname del servidor, el CLR lanzara una

InvalidOperationException. Si el hostname está definido, pero no puede alcanzarse (por el motivo

que sea), el CLR lanzara una SmtpExeption anidada. Si el servidor SMTP responde diciendo que

alguno de los destinatarios es invalido, el CLR lanzara una SmtpFailedRecipientException.

Para usar las credenciales de red por defecto, marque SmtpClient.UseDefaultDredentials como

True. Para especificar un nombre de usuario y contraseña, cree una instancia de la clase

System.Net.NetworkCredential y úselo para definir la propiedad SmtpClient.Credentials.

Una vez que haya creado un mensaje, tendrá que enviarlo a través de SMTP (Simple Message

Transfer Protocol) del servidor, lo que a su vez lo remitirá al destinatario. En el .NET Framework,

la clase smtpclient representa el servidor SMTP. La mayor parte del tiempo, el envió de un

mensaje es tan simple como este código demuestra (donde ―smtp.gmail.com‖ es el nombre del

servidor SMTP local):

La creación y envío de correos electrónicos se da en cualquier momento, ya sea para enviar

información como texto, imágenes, músicas, entre otros, por tal motivos a continuación

mostraremos un ejemplo desarrollado en lenguaje de programación C#, donde veremos el

funcionamiento y el código del mismo.

Reflexionar





¿Por qué?




APUNTES DE CLASE

PRACTICA PARA LA CREACIÓN Y ENVÍO DE CORREOS ELECTRÓNICOS.

MailMessage m = new MailMessage (“[email protected]”,

“[email protected]”,

“Informe de Ingresos Trimestrales.”,

“Vease documento de Informacion Adjunto”);

SmtpClient client = new SmtpClient (“smtp.gmail.com”);

Client. Send (m);

CREACION DE APLICACIÓN

Creamos nuestro proyecto en lenguaje C#, en nuestro caso lo nombraremos ―Mensajería

Instantánea‖, nuestro proyecto estará compuesto por dos formularios, Login y Mensaje.

Explicación de la INTERFAZ GRAFICA DE LA CREACIÓN Y ENVÌO CORREO ELECTRÓNICO

Formulario1: INICIAR SESIÓN

Entrar: Primero verifica que el correo electrónico y el password sean correctos y nos llevara al

formulario ―MENSAJE‖, el cual tendrá la función de llenar los datos generales para el envío de un

correo electrónico.

Correo Electrónico: Ingresaremos el correo electrónico del cual queremos enviar el mensaje.

Password: La contraseña correspondiente al correo que hemos ingresado.

Código que utilizamos en el formulario 1:

Cada vez que se de clic en el botón Iniciar, se comprobara que los text no estén vacíos y guardara

los datos ingresados en variables, para después guardarlos y usarlos en una instancia de la clase

Mensaje. En el caso que los text estén vacíos se enviara un error que nos indique que debemos

llenar los datos antes de ingresar.

Formulario2: MENSAJERÍA

El form2, tendrá el nombre de ―MENSAJERÍA‖, permitirá ingresar los datos básicos de un correo

electrónico como:

Remitente (PARA): Correo de la persona a quien le vamos a enviar el mensaje.

Asunto: Tema del mensaje.

Archivo: Adjunto que queramos enviar, ya sea un documento de texto, música, imágenes, entre

Mensajería

Error

Provider

otros.

Área en blanco: Escribiremos un mensaje cualquiera que queramos enviar donde tendremos la

fuente (negrita, cursiva, subrayado), que queramos darle al texto.

Su interfaz estará de la siguiente forma, como lo ilustra la imagen:

Como vemos, tenemos cuatro opciones enviar, insertar, limpiar y salir, veremos el código que

utilizamos para realizar estos procesos.

ENVIAR: Una vez creado el MailMessage debemos utilizar las propiedades necesarias para

obtener el contenido que hemos ingresado en nuestra interfaz, para así poder hacer el envío

respectivo.

INSERTAR: Creamos una nueva clase OpenFileDialog en la cual comprobaremos que al dar OK

se guardara en una variable dicho archivo seleccionado. Luego creamos una clase Attachment y le

enviamos el archivo adjunto.

LIMPIAR: Borra los datos de las cajas de texto.

SALIR: Sale del sistema.

Utilizando las

propiedades del

MailMessage

Utilizamos la propiedad

del SmtpClient para

enviar los datos.

Creamos una clase

OpenFieDialog

Adjuntamos el archivo

que deseamos

Para poder realizar la creación y el envío mediante el servidor SMTP debemos declara de forma

pública o privada las clases y variables a utilizar, de acuerdo al uso que le demos, en este caso las

declaramos de forma pública:

Como notamos con el correo que ingresamos en el formulario de LOGIN será el usuario en el

Limpiar

Salir

Variables

Clase

nuevo formulario, también se mostrara la fecha y hora de ingreso.

El código para realizar esto es el siguiente, primero antes debemos aclarar que en esta parte

guardamos los datos ingresados como son el correo, el password y el host, que lo obtendremos de

un método. El correo se lo utilizara para en el formulario 2 mostrar el usuario que ingreso al

sistema.

Por último creamos la clase SmtpClient enviándole el servido que usaremos y el host para envío de

correos electrónicos y utilizaremos unas propiedades de la misma,

Mostramos el

usuario, y

obtenemos los

datos del host.

Método, para

saber con qué

servidor

trabajaremos.

Una vez ingresado los datos y damos clic en enviar debemos revisar nuestra cuenta respectiva

para verificar nuestro correo electrónico, en el caso de que tenga un inconveniente las clases

envían mensajes de errores correspondientes.

A continuación los pasos para utilizar el programa:

Paso1

Ingresar al sistema

Obtiene el servidor que

vayamos a utilizar de acuerdo

al usuario ingresado.

Enviamos el servidor y el host

587.

Paso 2

Ingresar el destinatario y el Asunto

Paso 3

Adjuntar un archivo si deseamos

Paso 4

Agregamos un texto y damos clic en enviar y le colocamos una fuente si deseamos.

Debemos recordar que debemos estar conectados a internet para hacer este envío, si no, no

funcionará y saldrá un mensaje de error.



TIEMPO: 2 Horas

FECHA: 07/08/2013



PROGRAMACIÓN EN C#

Contenidos

Windows Forms








Competencia General








- Cada estudiante iba haciendo sus prácticas de cada tema expuesto Creacion OCX Formas de Formularios


- Creacion OCX - Formas de Formularios

OCX es un acrónimo que significa "OLE Control Extension". OLE a su vez significa Object

Linking and Embedding.

OCX hace referencia a módulos que publican controles y funciones para ser utilizados en

programas para Windows, incluyendo especialmente el navegador Internet Explorer.

Típicamente, estas librerías se presentan en librerías de enlace dinámico (DLL) almacenadas

con extensión .OCX.

Aunque la popularidad de estos controles se debe principalmente al entorno de desarrollo de

Visual Basic, las librerías OCX pueden utilizarse desde la práctica totalidad de plataformas de

desarrollo generalistas para Windows, lenguajes de scripting como VBScript y ECMAScript, o

lenguajes de macro como Visual Basic for Applications. También pueden ser incrustados en

documentos que soporten la tecnología OLE, por ejemplo, documentos de Microsoft office o

páginas web.

Reflexionar





¿Por qué?




UNIDAD IV: PRESENTACIÓN DE

RESULTADOS



TIEMPO: 2 Horas

FECHA: 09/08/2013


TEMA DISCUTIDO: UNIDAD IV: PRESENTACION DE RESULTADOS

Contenidos

Windows Forms

Creación y ejecución

Informes tipo maestro – detalle

Informes con filtros y quiebre de control


Crea interfaces que permiten parametrizar los informes.

Presenta la información para toma de decisiones de una Base de Datos en un medio impreso.

Competencia General

Crear y generar informes necesarios para la toma de decisiones.




- Cada estudiante iba haciendo sus prácticas de cada tema expuesto Crystal Reports


- Crystal Repots

INSTALACION DE CRYSTAL REPORTS

“Este trabajo fue realizado en MICROSOFT VISUAL STUDIO 2010 (lenguaje C#), con la versión

13.0.1 de CRYSTAL REPORTS (la cual no bien integrada en visual studio 2010).”

Primeramente vamos a instalar la versión de CRYSTAL REPORTS e integrarla en VISUAL

STUDIO 2010 para poder trabajar.

“Importante que la versión a descargar depende del Framework con el cual amos a

trabajar nuestra aplicación, en este ejemplo trabajamos con Framework 4.0”

Reflexionar





¿Por qué?




APUNTES DE CLASE

CREACIÓN Y EJECUCIÓN DE REPORTES CON CRYSTAL REPORT

En este manual Aprenderemos a crear Reportes con CrystalReport de una sola Tabla, para ello

comenzaremos creando un nuevo Proyecto.

Lueg

o de

Habe

r

Crea

do

Un

nuev

o

Proy

ecto,

proc

ede

mos

a

agregar un WindowsFormApplication llamado Report1Tabla.

Dentro de este formulario Agregaremos los siguientes componentes:

1 dataGridView = grilla

2 Botones = atrás, Generar Reporte

Luego de haber agregado estos componentes, pasamos a crear otro Formulario llamado

Visualizar1Tabla.cs

Dentro de este formulario Pasaremos a agregar el siguiente componente a nuestro formulario.

Este CrystalreportViewer nos permitirá más adelante poder visualizar el reporte con los datos de la

base de datos que se esté consultando. Y este formulario quedará diseñado de la siguiente

manera.

Ahora sí, una vez concluida la parte del diseño, la misma que nos permitirá visualizar los datos,

pasemos a codificar los componentes agregados.

Comenzamos con el formulario Report1Tabla.

Dentro de este formulario ira agregado los siguientes

métodos.

Una vez

realizada

esta

codificaci

ón

llamamos

al método

cargarDatos(); al evento Load del Formulario.

Con todas estas líneas de código, en nuestro dataGriedView que agregamos a este formulario, se

mostrara la información que poseemos en nuestra base de datos de la tabla Empleado.

Esta es la tabla con sus respectivos campos que posee la base de datos creada en Access 2010

Una vez que ya se ha cargado los datos de la base de datos a nuestra grilla, procedemos a

agregar a nuestro proyecto 2

componentes más:

Conjunto de datos = Dataset1

Archivo CrystalReport =

rpt1Tabla.rpt

Como primer Punto Agregamos el

conjunto de datos, una vez ya

agregado a nuestro proyecto se

cargara una vista, donde comenzaremos a agregar una tabla que ira almacenando los datos que

tenemos de la base de datos.

Una vez dado clic derecho sobre el espacio de trabajo agregaremos una tabla de datos llamada

Empleados, que como se mencionó anteriormente almacenará los datos de la base de datos.

En esta grafica ya nos muestra el dataTable que se utilizara para trabajar.

Una vez que ya está agregado el dataTable procederemos a agregar columnas que se agregaran

de acuerdo a los campos que posee nuestra base de datos.

Ya agregadas todas las columnas a nuestra tabla, procedemos a crear el segundo archivo,

CrystalReport, que nos permitirá visualizar los datos de nuestra base de datos.

Ya creado nuestro componente, se abrirá un asistente de creación de reportes, la cual nos muestra

3 opciones:

Usar asistente de informes

Como Informe en Blanco

A partir de un informe existente

De estas tres opciones escogeremos Como Informe en

Blanco, y damos a aceptar

Ahora se nos muestra el informe en blanco, de aquí en

adelante seguiremos los siguientes pasos para enlazar

este visor de reportes con el conjunto de datos que se

creó anteriormente.

En la parte derecha se Muestra un menú que dice ―EXPLORADOR DE CAMPOS‖ damos clic

derecho, seleccionamos la opción ―asistente de base de datos‖

Ahora se visualizará la siguiente ventana, en esta ventana

escogeremos la primera opción ―Datos del Proyecto‖ y

desplegamos la carpeta que dice ―ADO .Net Dataset ‖.

Seleccionamos la opción con nombre ―Empleado‖ y lo

pasamos al otro lado con el botón de Mayor Que > 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.

<startup useLegacyV2RuntimeActivationPolic

y="true">

<supportedRuntime version="v4.0"/>

</startup>

Y comentando la línea

<!–<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup>–>

Quedando el App.config como sigue:

//////////////////////

<?xml version="1.0"?>

<configuration>

<!--<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup>-

->

<startup useLegacyV2RuntimeActivationPolicy="true">

<supportedRuntime version="v4.0"/>

</startup>

</configuration>

/////////////////////

Con esto ya se ejecuta nuestro reporte.

ACTIVIDADES DE APRENDIZAJE

INTRA Y EXTRA CLASE

UNIDAD I: INTRODUCCIÓN

A .NET

Actividad N° 1

ACTIVIDAD N°: 1 FECHA: 08/05/2013

TEMA:

Plantearse un objetivo para este módulo.

Plenaria: Los alumnos compartirán el objetivo que se han

planteado para este módulo

Los alumnos en forma individual contestarán un caso.

Plenaria: Los alumnos expondrán sus respuestas ante sus

compañeros y debatirán sus acuerdos o desacuerdos con la

selección presentada. Se revisará las características de los


UNIDAD N° 1: INTRODUCCIÓN A .NET

OBJETIVO: Describir los conceptos y terminologías sobre el lenguaje de

programación.

PROBLEMA: Desconocimiento de terminologías de lenguaje de Programación

INDICADOR DE

EVALUACION:

m) Comunicación efectiva

n) Asuntos contemporáneos

VALORES: Respeto, Honestidad, Responsabilidad.

TIPO DE ACTIVIDAD

LUGAR ALCANCE FORMA

□Intraclase

□Extraclase

□Individual

□Grupal

□Taller

□Síntesis, esquemas

□Caso de estudio

□Investigativa

□Vinculación con la colectividad

□Práctica de laboratorio

□Práctica de clase

□Resolución de problemas,

ejercicios

□Ensayo, artículo

□Informe e exposición

CALIFICACIÓN

DESARROLLO DE LA ACTIVIDAD, SOLUCIÓN O PRECEDIMIENTO

1. Plantearse un objetivo para este módulo.

- En este modulo el objetivo es afianzar mas mis conocimientos con todo lo que tenga que

ver con la Programación y aprobar.

2. Plenaria: Los alumnos compartirán el objetivo que se han planteado para este módulo

3. Los alumnos en forma individual contestarán por escrito lo siguiente:

Tarea1: Un nuevo virus apareció y dañó específicamente todos los lenguajes de programación

utilizados (Ejemplo, Visual Basic, Visual FoxPro, C++, Java, C#, entre otros.), de tal manera

que después de un tiempo no se podrá ejecutar ningún programa, usted ha sido designado por

su compañía para desarrollar un nuevo lenguaje de programación. ¿Qué características

tendría dicho lenguaje? ¿Por qué?

- Modo Diseño: Debería ser más fácil para el desarrollador una manera más

sencilla.

- Español: La mayoría de Lenguaje son en Inglés

- Multiplataforma: Para que se pueda utilizar en todos los SO

- Auto Programable: Para que al momento de ir escribiendo las líneas de código

muestre las sugerencias.

Tarea2: En grupo de máximo 4 personas, comparta sus respuestas, discuta con sus

compañeros y seleccione el lenguaje de programación más conveniente para la empresa,

explique por escrito el porqué de sus decisiones. ¿Qué características deben proporcionar los

lenguajes de programación a los sistemas automatizados? ¿Por qué? (Elabore una lista de al

menos 5 características).

- Por qué?: Facilitaría a los usuarios (Programadores) a la mejor adaptación a

los conocimientos de cada persona lo cual pueda trabajar en varios sistemas

Operativos y el lenguaje de su preferencia.

- Las características son:

Multiplataforma.

Modo Gráfico.

Que no haya restricción entre mayúscula y minúscula.

Auto llenado de código.

Multilenguaje.

4. Plenaria: Los alumnos expondrán sus respuestas ante sus compañeros y debatirán sus

acuerdos o desacuerdos con la selección presentada. Se revisará las características de los


Actividad N° 2

ACTIVIDAD N°: 2 FECHA

ENVIO: 08/05/2013 FECHA

ENTREGA: 10/05/2013

TEMA: Introducción a la Computadora

UNIDAD N°1: Introducción a.Net


programación.

PROBLEMA: Identifica los objetivos del lenguaje de programación C#.

INDICADOR DE EVALUACION:

CALIFICACIÓN

Comprometerse con el aprendizaje continuo.

Diseñar conducir experimentos analizar e interpretar datos

Comunicarse Efectivamente

Cuadro comparativo

1 punto 0,5 puntos 0,1 puntos

Profundización del tema

Descripción clara y sustancial del cuadro y buena cantidad de detalles.

Descripción ambigua del tema, algunos detalles que no clarifican el tema.

Descripción incorrecta del tema, sin detalles significativos o escasos.

Aclaración sobre el tema

Cuadro bien organizado y claramente presentado así comode fácil seguimiento.

Cuadro sinóptico bien focalizado pero no suficientemente organizado.

Cuadro sinóptico impreciso y poco claro, sin coherencia entre las partes que lo componen.

Alta calidad del diseño

Cuadro sobresaliente y atractivo que cumple con los criterios de diseño planteados, sin errores de ortografía.

Cuadro sinóptico simple pero bien organizado con al menos tres errores de ortografía.

Cuadro sinóptico mal planteado que no cumple con los criterios de diseño planteados y con más de tres errores de ortografía.

Elementos propios del cuadro comparativo

Los temas centrales se ubicaron en la columna izquierda y encorrecto orden y en la partesuperior se colocaron las variablesy la información fue acertada

Se ubicaron los temas centrales enla columna izquierda pero lasvariables no se colocaron de formaordenada. La información hacereferencia al tema.

No se ubicaron o se ubicaron deforma incorrecta los temascentrales y las variables no tienenrelación con el tema principal.

Presentación del cuadro sinóptico

La presentación/exposición fuehecha en tiempo y forma, ademásse entregó de forma limpia en elformato pre establecido (papel odigital).

La presentación/exposición fuehecha en tiempo y forma, aunquela entrega no fue en el formato preestablecido.

La presentación/exposición no fuehecha en tiempo y forma, ademásla entrega no se dio de la formapre establecida por el docente.

TIPO DE ACTIVIDAD

LUGAR ALCANCE FORMA

□Intraclase

□Extraclase

□Individual

□Grupal

□Taller


□Caso de estudio

□Investigativa


□Práctica en laboratorio

□Práctica en clase


ejercicios


□ nfo me de xposición

ROLES Y RESPONSABILIDADES DE LOS PARTICIPANTES EN LA TAREA:

NOMBRE ROL DESCRIPCIÓN

Jennifer Honores Investigador - Analista Investigación

Desarrollo de la Actividad, solución procedimiento

Introducción

Los lenguajes de Programación son muy extensos en características, evolución, es por

ello que este trabajo nos ayudara de a entender todo esto con investigaciones hechas en

la WEB.

Marco Teórico

Según (Laboda, Javier; Josep Galimany, Rosa María Pena, Antoni Gual (1985)). En sus

inicios las computadoras interpretaban sólo instrucciones en un lenguaje específico, del

más bajo nivel, conocido como código máquina, siendo éste excesivamente complicado

para programar. De hecho sólo consiste en cadenas de números 1 y 0 (sistema binario).

Para facilitar el trabajo de programación, los primeros científicos que trabajaban en el área

decidieron reemplazar las instrucciones, secuencias de unos y ceros, por palabras o letras

provenientes del inglés; las codificaron y crearon así un lenguaje de mayor nivel, que se

conoce como Assembly o lenguaje ensamblador. A medida que la complejidad de las

tareas que realizaban las computadoras aumentaba, se hizo necesario disponer de un

método sencillo para programar. Entonces, se crearon los lenguajes de alto nivel.2

2 Laboda, Javier; Josep Galimany, Rosa María Pena, Antoni Gual (1985). «Software». Biblioteca práctica de

la computación. Barcelona: Ediciones Océano-Éxito, S.A..

http://es.wikipedia.org/wiki/C%C3%B3digo_m%C3%A1quina

http://es.wikipedia.org/wiki/Sistema_binario

http://es.wikipedia.org/wiki/Idioma_ingl%C3%A9s

http://es.wikipedia.org/wiki/Lenguaje_ensamblador

http://es.wikipedia.org/wiki/Lenguaje_de_alto_nivel

Solución o Resultados

Los alumnos individualmente deben desarrollar los siguientes problemas, elaborando un

informe sobre lo que han investigado:

1. Lectura Complementaria. Introducción a la Computación. Peter Norton. McGraw Hill.

3era. Edición. Capítulo 11. Desarrollo de Sistemas de Información. Subtema: Dos

enfoques de programación. Páginas 423 – 431.

2. Si usted quiere aprender a programar, existen muchos recursos, hay libros, tutoriales

de bolsillo, tutoriales en el WEB. Visite algunos tutoriales de los lenguajes de

programación arriba mencionados (Trate de centrarse en el lenguaje que será materia

de este módulo). Realice un informe y conteste lo siguiente en forma de reflexión:

a. ¿Qué tipo de apoyo proporcionan? Rpt: Los sitios en internet, videos nos

proporcionan que al momento de buscar datos será de una manera rápida

eficiente.

b. ¿Qué tanta ayuda proporcionan estos sitios? Rpt: Con tanta información

disponible en el internet lo que debemos saber es cual es real, cierta, como

obtenerla, como clasificarla y la mejor manera de administrarla.

c. ¿Terminó usted sabiendo más acerca de la programación que antes? Rpt:

Si ¿Por qué? En la Web hay tanta información que uno puede con buscar

frases palabras cortas para un mejor aprendizaje por consiguiente se ha ce más

fácil captar la idea de la programación en sí.

d. ¿Qué piensa acerca de estos tutoriales en línea, comparados con

aprender de un libro o en una clase? Rpt: Yo pienso que los tutoriales en

línea son muchos mejor comparado con biblioteca, libros ya que a veces la falta

de tiempo que nos impide al trasladarnos a una biblioteca cada vez que la

necesitemos…

e. ¿De qué manera estos tutoriales contribuyeron a su aprendizaje? Rpt: Los

tutoriales en internet ahora se podría considerar como una fuente de

investigación muy importante ya que uno aprende de manera más rápida y así

conocer los lenguajes de programación de forma más llamativa por lo que en

internet se puede acceder mucho más rápido a una fuente libro, respuestas de

estudiantes que tienen dudas e infinidad de información.

3. Guarde en un dispositivo de almacenamiento secundario todos los manuales o

tutoriales de C# que haya encontrado en el Internet. Este material será utilizado más

adelante en las futuras clases por lo que debe llevarlo siempre consigo.

4. Una gran cantidad de información relacionada con la programación se encuentra

disponible en Internet. Localice páginas Web dedicadas a los siguientes productos:

Visual Basic, Visual Fox Pro, C++, Java, HTML, C#, Visual Studio.NET. Realice un

cuadro comparativo con las principales características de cada uno de los lenguajes

descritos. (mínimo 10 características por cada lenguaje).

CUADRO COMPARTIVO

Descripciones / programas

Visual basic Visual fox pro C++ Java Html C# Visual studio.net.

Programación Limitada programación orientada a Objetos

Orientado a Objetos

Estructurado Orientado a Objeto

----------------- Programación orientada a Objetos

------------------

Conexión a Base de Datos

Posee varias Bibliotecas para las conexiones

SI. Oracle, Sql, Server, Mysql

Si Si Si

Ultima Versión Visual Basic 6.0 (1998)

Visual Fox Pro 9.0 (2004)

C++11 (2011) Modo Prueba

Java Se 7 (2011)

HTML5 (2012)

En el año 2000, Microsoft presenta su plataforma .NET junto con un nuevo lenguaje, C#

Visual Studio 2010 (2010)

Desventajas Incapacidad para crear aplicaciones multihilo, sin tener que recurrir a llamadas del api de Windows.

----------------- No es atractivo visualmente

Esperar la actualización siguiente para que sea más rápido.

La interpretación de cada navegador puede ser diferente.

Las desventajas que se derivan del uso de este lenguaje de programación son que en primer lugar se tiene que conseguir una versión reciente de visual studio .net.

La demanda de grandes cantidades de recursos computacionales debido a q la característica de reutilización de los frameworks tiende a generalizar la función.

Sistemas operativos Microsoft Visual Basic 1.0 desarrollada para el sistema operativo MS-DOS las demás para Windows.

Microsoft Windows

Sirve para todos los sistemas operativo pero cada uno con su respectiva versión para dicho sistema

Microsoft, Mac Os, Gnu/Linux

Se pueden ver en todos los sistemas operativos, pero la interpretación varía según el navegador que esté utilizando.

Multiplataforma Sirve para trabajar la mayoría de las aplicaciones y programas creados para la plataforma Windows, permitiendo una integración más

312

Bibliografí

a

partespcsena.blogspot.com. (s.f.). Recuperado el 09 de 05 de 2013, de http://partespcsena.blogspot.com/2012/08/cuadro-comparativo-entre-los-lenguajes.html

Visual Basic. (s.f.). Recuperado el 09 de Mayo de 2013, de https://es.wikipedia.org/wiki/Visual_Basic

Visual Fox Pro. (s.f.). Recuperado el 9 de Mayo de 2013, de http://es.wikipedia.org/wiki/Visual_FoxPro

Marc D'Aoust. «Avoid Writing Tedious, Boring Code». Microsoft.

Developers petition Microsoft to reconsider FoxPro phase out Posted by Mary Jo Foley (April 3rd, 2007) - All about Microsoft - ZDNet.com

https://sites.google.com/site/programacion1electronica/conceptos/lenguajes-de-programacion

Bjarne Stroustrup, The Design and Evolution of C++, Addison-Wesley Pub Cp; Primera edición (29 de marzo de 1994); ISBN 0-201-54330-3

M. Domínguez-Dorado, Guillermo Som. Todo Programación. Nº 11. Págs. 10-20. Editorial Iberprensa (Madrid). DL M-13679-2004. Agosto, 2005.. Imprimir desde Java y .NET..

rápida y ágil entre todo tipo de información

Compilado / interpretado

Interpretado Interpretado Compilado Intermediario Interpretado

Rendimiento Alto Alto Muy alto Muy alto Alto Diseñado por Alan Cooper Microsoft

Corporation Bjarne Stroustrup

Sun Microsystems

World Wide Web Consortium & WHATWG

Microsoft Microsoft

Licencia Propietaria Microsoft EULA

GNU GPL / Java Community Process

Formato abierto

----------------- Propietaria

Extensiones .bas, .frm, .exe, .vbp ----------------- .h .hh .hpp .hxx .h++ .cc .cpp .cxx .c++

.java, .class,

.jar .html, .htm .cs -----------------

http://msdn.microsoft.com/en-us/library/aa227881%28VS.60%29.aspx

https://es.wikipedia.org/wiki/Microsoft

http://blogs.zdnet.com/microsoft/?p=361

https://sites.google.com/site/programacion1electronica/conceptos/lenguajes-de-programacion

http://es.wikipedia.org/wiki/Especial:FuentesDeLibros/0201543303

Actividad N° 3


TEMA:

Elaborar una línea de tiempo sobre la evolución de los


Utilizando la lectura y la investigación realizada responda:

¿En qué generación de los lenguajes de programación ubica

usted a C#? ¿Qué razones lo llevan a pensar eso? ¿Qué

diferencia hay entre C# y los otros lenguajes de

Programación? ¿Por qué? ¿Qué características tendrá un

sistema automatizado con C#? Ponga ejemplos. ¿Cuándo

considera usted que no puede utilizar C# para automatizar un

sistema manual? ¿Explique por qué?

Cada grupo compartirá sus opiniones y cómo llegaron a esas

conclusiones con el resto de compañeros.

UNIDAD N° 1: INTRODUCCIÓN A .NET


programación.

PROBLEMA: Desconocimiento de terminologías de lenguaje de Programación

INDICADOR DE

EVALUACION:

o) Comunicación efectiva

p) Asuntos contemporáneos


TIPO DE ACTIVIDAD

LUGAR ALCANCE FORMA

□Intraclase

□Extraclase

□Individual

□Grupal

□Taller


□Caso de estudio

□Investigativa





ejercicios


□Informe de exposición

CALIFICACIÓN

DESARROLLO DE LA ACTIVIDAD, SOLUCIÓN O PRECEDIMIENTO

1. Los alumnos en grupos máximo de 4, trabajarán para responder las siguientes preguntas, Se

tomarán unos 5 a 15 minutos para pensar individualmente:

2. Tarea1: Elaborar una línea de tiempo sobre la evolución de los lenguajes de programación.

314

Tarea2: Utilizando la lectura y la investigación realizada responda: ¿En qué generación de los

lenguajes de programación ubica usted a C#? ¿Qué razones lo llevan a pensar eso? ¿Qué

diferencia hay entre C# y los otros lenguajes de Programación? ¿Por qué? ¿Qué

características tendrá un sistema automatizado con C#? Ponga ejemplos. ¿Cuándo considera

usted que no puede utilizar C# para automatizar un sistema manual? ¿Explique por qué?

1. ¿En qué generación de los lenguajes de Programación Ubica a C#?

a. Lenguaje de Cuarta Generación. Nor-Jen

2. Qué razones le llevan a pensar eso?

a. Por programación Orientada a Objetos y Eventos.

3. ¿Qué diferencia hay entre C# y los otros lenguajes de programación? Nor-Jen

a. En que C# es una unión de los lenguajes de programación anteriores (C++ y Java) Gio

4. ¿Qué características tendrá un sistema automatizado con C#? Ponga Ejemplos

a. Incluye un conjunto de objetos que podemos incorporar en nuestros programas en vez de tener que crear todo desde cero.

i. La tarea de Programación se simplifica si podemos utilizar componentes prefabricados.

5. ¿Cuándo se considera usted que no puede utilizar C# para automatizar un sistema manual? ¿Explique por qué?

a. Los Sistemas Bancarios

315

i. Porque estos sistemas guardan claves confidenciales que solo el portador debe conocerlas.

Plenaria: Cada grupo compartirá sus opiniones y cómo llegaron a esas conclusiones con el

resto de compañeros.

316

Actividad N° 4


ENVIO: 13/05/2013 FECHA

ENTREGA: 15/05/2013

TEMA:

1. Utilizando los buscadores en Internet, elabore un ensayo acerca de

las fortalezas y limitaciones de C#. Busque ejemplos de sistemas

(aplicaciones comerciales) que han sido automatizados con C#

(mínimo 5). Establezca las características (en cuanto a apariencia

física), funcionalidades que tienen dichos sistemas, requerimientos de

hardware y software de cada ejemplo.

2. Lectura: Quince años de innovación tecnológica. Los desafíos del

programador. Nace la era .NET. C#, un lenguaje actual. Pag. 14 – 17

del libro: Guía Práctica para usuarios Visual C# 2005. Autor:

Francisco Charte Ojeda. Editorial ANAYA.



programación.

PROBLEMA: El estudiante debe identificar los objetivos del lenguaje de programación

C#.


CALIFICACIÓN




Ensayo 1 punto 0,5 puntos 0,1 puntos

Profundizació

n

del tema

Descripción clara y

sustancial del tema y

buena cantidad de

detalles.

Descripción ambigua del

tema a tratar, algunos

detalles que no clarifican el

tema.

Descripción inexacta del tema a

tratar, sin detalles significativos

o escasos.

Aclaración

sobre el tema

Tema bien organizado y

claramente presentado

así como de fácil

seguimiento.

Tema con información bien

focalizada pero no

suficientemente organizado.

Tema impreciso y poco claro,

sin coherencia entre las partes

que lo componen.

Alta calidad

del diseño

Ensayo escrito con

tipografía sencilla y que

cumple con los criterios

de diseño planteados, sin

Ensayo simple pero bien

organizado con al menos

tres errores de ortografía y

Ensayo mal planteado que no

cumple con los criterios de

diseño planteados y con más

317

errores de ortografía. tipografía difícil de leer. de tres errores de ortografía.

Elementos

propios del

Ensayo

El ensayo cumple con los

cuatro criterios de diseño

(Resumen, palabras

clave, cuerpo del ensayo

y referencias

bibliográficas)



pero no con la extensión

solicitada (mínimo 3

páginas) o bien, estos

puntos no han sido

correctamente realizados.

El ensayo no cumple con los

criterios de diseño planteados o

bien no están claramente

ordenados o definidos ni

cumple con la extensión

mínima.

Presentación

del Ensayo

La

presentación/exposición

fue hecha en tiempo y

forma, además se entregó

de forma limpia en el

formato pre establecido

(papel o digital).

La presentación/exposición


forma, aunque la entrega

fue en el formato

preestablecido.

La presentación/exposición no

fue hecha en tiempo y forma,

además la entrega no se dio de

la forma pre establecida por el

docente.

TIPO DE ACTIVIDAD

LUGAR ALCANCE FORMA

□Intraclase

□Extraclase

□Individual

□Grupal

□Taller


□Caso de estudio

□Investigativa





ejercicios







Introducción

Los lenguajes de Programación son muy extensos en características, evolución, es por ello que

este trabajo nos ayudara de a entender todo esto con investigaciones hechas en la WEB.

318

Marco Teórico

Según (James Kovacs 7 septiembre 2007) El nombre C Sharp fue inspirado por la notación

musical, donde '#' (sostenido, en inglés sharp) indica que la nota (C es la nota do en inglés) es un

semitono más alta, sugiriendo que C# es superior a C/C++. Además, el signo '#' se compone de

cuatro signos '+' pegados.3

Durante el desarrollo de la plataforma .NET, las bibliotecas de clases fueron escritas originalmente

usando un sistema de código gestionado llamado Simple Managed C (SMC). En enero de 1999,

Anders Hejlsberg formó un equipo con la misión de desarrollar un nuevo lenguaje de

programación llamado Cool (C orientado a objetos). Este nombre tuvo que ser cambiado debido a

problemas de marca, pasando a llamarse C#.4


Utilizando los buscadores en Internet, elabore un ensayo acerca de las fortalezas y limitaciones de

C#. Busque ejemplos de sistemas (aplicaciones comerciales) que han sido automatizados con C#

(mínimo 5). Establezca las características (en cuanto a apariencia física), funcionalidades que

tienen dichos sistemas, requerimientos de hardware y software de cada ejemplo.

C#

Fortalezas y Limitaciones

Jennifer Honores Cun5

3 James Kovacs (7 de septiembre de 2007). «C#/.NET History Lesson» (en ingles).

4 Visual C# Developer Center, Frequently Asked Questions About Visual C# .NET 2003 (en inglés)

5 Estudiante de la Universidad Técnica de Machala, Escuela de Informática Quinto Quimestre “A”

Resumen

El presente ensayo, hace un análisis acerca del Lenguaje de Programación C# y sobre…

¿Cuáles son sus fortalezas?, ¿Cuáles son sus Limitaciones?, ¿Quién la Creo?, ¿Hay

aplicaciones que se automatizaron con este lenguaje de Programación?, ya que ahora en

el mundo de la Programación es muy interesante ver cómo evolucionan sus lenguajes es

por ello que nos centraremos en un Lenguaje Actual como es el C# para conocer más a

fondo sobre este de Lenguaje de Programación.

http://es.wikipedia.org/wiki/Notaci%C3%B3n_musical


http://es.wikipedia.org/wiki/Sostenido

http://es.wikipedia.org/wiki/Semitono

http://es.wikipedia.org/wiki/Clase_%28inform%C3%A1tica%29

http://es.wikipedia.org/wiki/C%C3%B3digo_gestionado

http://es.wikipedia.org/wiki/Anders_Hejlsberg

http://jameskovacs.com/2007/09/07/cnet-history-lesson/

http://msdn.microsoft.com/en-us/vcsharp/aa336779.aspx

319

Palabras Claves: Automatización, Lenguajes de Programación, Software, Hardware,

Compiladores, Plataforma.Net

Sumario:

Resumen

I. Introducción

II. Historia de C#

III. C# Fortalezas y Limitaciones

a. Fortalezas

b. Limitaciones

IV. Aplicaciones Automatizadas con C#

a. Características (Apariencia Física)

b. Funcionalidades

c. Requerimientos de Software y Hardware

Introducción

C# es un lenguaje de programación orientado a objetos desarrollado y estandarizado por Microsoft

como parte de su plataforma .NET.6

C# es un lenguaje orientado a objetos, seguro, moderno, de alto rendimiento es también la

principal herramienta para programar en la plataforma.NET

Historia C#


http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n

http://es.wikipedia.org/wiki/Programaci%C3%B3n_orientada_a_objetos


http://es.wikipedia.org/wiki/Microsoft_.NET


320

Segun (Zander Jason, 2008).Durante el desarrollo de. NET Framework, las bibliotecas de clases

fueron escritos originalmente con un sistema de compilador de código administrado llamada

Simple C Gestionado (SMC). 7

Diseñador principal C # 's y arquitecto principal de Microsoft es Anders Hejlsberg, que participó

anteriormente en el diseño de Turbo Pascal, Delphi Embarcadero (antes CodeGear Delphi, Inprise

Delphi y Borland Delphi), y Visual J + +.

Seguin (Kovacs James, 2007). El nombre de "C sharp" se inspiró en la notación musical en un

fuerte indica que la nota escrita debe hacerse un semitono más agudo. 8

Esto es similar al nombre del lenguaje de C + +, donde "+ +" indica que una variable debe ser

incrementado en 1.

C# Fortalezas y Limitaciones

Fortalezas

7 Zander, Jason (November 24, 2008). "Couple of Historical Facts". Retrieved February 23, 2009.

8 Kovacs, James (September 7, 2007). "C#/.NET History Lesson". Retrieved June 18, 2009.

•Eliminan muchos elementos que otros lenguajes incluyen y no son necesarios

•No se incluyen elementos poco utiles como Herencia multiple. Sencillez

•Incorpora Propio Lenguaje para el desarrollo de aplicaciones ya que C++ y Java hay que simular. Modernidad

•Encapsulacion, herencia, y polimorfismo Orientada a Objetos

•Para evitar errores muy comunes de C# se ha impuesto una serie de restricciones en el uso de las instrucciones de control mas comunes.

Instrucciones Seguras

•Soporte para internalización. Soporte

http://blogs.msdn.com/jasonz/archive/2007/11/23/couple-of-historical-facts.aspx

http://www.jameskovacs.com/blog/CNETHistoryLesson.aspx

321

Limitaciones

Aplicaciones Automatizadas con C#

Aplicaciones/Descrip

ción

Características Funcionalidades Requerimientos de

Software y Hardware

XobotOS XobotOS es un

sólo proyecto

experimental que

Xamarin ha

donado a la

comunidad

XobotOS es un

proyecto de

investigación que

explora Xamarin

portar Android 4.0 de

Java / C # Dalvik a

explorar los beneficios

de rendimiento y la

memoria de la huella

de C #

Los diferentes elementos del

XobotOS están licenciados

bajo la misma licencia que

sus proveedores inmediatos.

WaveEngine Engine es la

solución definitiva

para el desarrollo

de juegos

multiplataforma

en C #.

Un engine de

desarrollo de juegos

en C#

Android, IOs, Windows Store,

Windows Phone

•Sólo se admiten conversiones entre tipos de datos compatibles.

•No se pueden usar variables no inicializadas. Seguridad de Tipos

•En principio, en C# todo el código incluye numerosas restricciones para asegurar su seguridad y no permite el uso de punteros. Eficiencia

•Se tiene que conseguir una versión reciente de Visual Studio.NET Instalación

•Hay que pagar la licencia para .NET Licencia

•C # no permite el acceso directo al hardware de la computadora Hardaware

322

VRPN Realidad Virtual

periférico de red.

Es un sistema

independiente del

dispositivo y

transparente a la red

para acceder a la

realidad periféricos

virtuales en las

aplicaciones de RV.

C# Corner

Es una de las

comunidades

online más

populares para C

# y. NET

desarrolladores

con más de 3,0

millones de

desarrolladores

en todo el mundo.

Compatible con iPhone 3GS,

iPhone 4, iPhone 4S, iPhone

5, iPod touch (tercera

generación), iPod touch

(cuarta generación), iPod

touch (5ª generación) y iPad.

Requiere iOS 4.3 o posterior.

Esta app está optimizada

para iPhone 5.

Simulador C# de una

maqueta de trenes.

Costo de

desarrollo,

implementación

El modelado de los

componentes de una

maqueta ferroviaria.

Alto consumo de recursos,

tanto de CPU como de

memoria RAM.

Conclusiones

Según lo observado en internet, tutoriales existen información básica acerca de C# es por eso que

al momento de hacer la búsqueda de aplicaciones automatizadas para este lenguaje de

programación se volvió muy complicado.

Bibliografía

Fabian Seoane, David Cañar, Javier Hernández Sánchez, Sebastian Sasías , Gustavo

Novaro. (31 de Marzo de 2005). WikiBooks. Recuperado el 13 de Mayo de 2013, de

http://es.wikibooks.org/wiki/C_sharp_NET

Palanca, M. (05 de Octubre de 2012). Aplicando la filosofía de programación de Foxpro

con C# .NET. Recuperado el 14 de Mayo de 2013, de

http://csharpyfoxpro.blogspot.com/2012/10/noticia-futuro-de-c.html

323

Rodríguez, T. (12 de Mayo de 2012). Xatak Android. Recuperado el 14 de Mayo de 2013,

de http://www.xatakandroid.com/programacion-android/xobotos-android-hecho-usando-c-y-

la-plataforma-mono-prescindiendo-de-java

Seco, J. A. (03 de Octubre de 2006). devjoker. Recuperado el 14 de Mayo de 2013, de

http://www.devjoker.com/contenidos/Tutorial-C/125/Introduccion-a-C.aspx

WAVE Corporation. (2013). WAVE Corporation. Recuperado el 14 de Mayo de 2013, de

http://waveengine.net/Engine/Documentation

Lectura: Quince años de innovación tecnológica. Los desafíos del programador. Nace la era

.NET. C#, un lenguaje actual. Pag. 14 – 17 del libro: Guía Práctica para usuarios Visual C# 2005.

Autor: Francisco Charte Ojeda. Editorial ANAYA.

326

Actividad N° 5 ACTIVIDAD N°: 5 FECHA

ENVIO:

17/05/2013 FECHA

ENTREGA:

20/05/2013

TEMA:

1. Elaborar un informe técnico (tipo manual / ensayo) acerca del IDE de Visual C#, que

indique cuáles son los componentes del IDE, creación de nuevos proyectos y

elementos de una solución, cómo utilizar los asistentes, diseñadores y editores.


OBJETIVO: Reconocer los componentes del IDE de Visual C#

PROBLEMA: El estudiante no tiene mucho conocimiento acerca de los componentes del IDE de Visual

C#


CALIFICACIÓN





Profundización

del tema


sustancial del tema y buena

cantidad de detalles.

Descripción ambigua del tema

a tratar, algunos detalles que

no clarifican el tema.

Descripción inexacta del tema a

tratar, sin detalles significativos o

escasos.

Aclaración sobre

el tema


claramente presentado así

como de fácil seguimiento.

Tema con información bien

focalizada pero no

suficientemente organizado.

Tema impreciso y poco claro, sin

coherencia entre las partes que lo

componen.

Alta calidad del

diseño

Ensayo escrito con tipografía

sencilla y que cumple con los

criterios de diseño

planteados, sin errores de

ortografía.


organizado con al menos tres

errores de ortografía y

tipografía difícil de leer.

Ensayo mal planteado que no

cumple con los criterios de diseño

planteados y con más de tres

errores de ortografía.

Elementos

propios del

Ensayo



(Resumen, palabras clave,

cuerpo del ensayo y

referencias bibliográficas)


cuatro criterios de diseño pero

no con la extensión solicitada

(mínimo 3 páginas) o bien,

estos puntos no han sido

correctamente realizados.


criterios de diseño planteados o

bien no están claramente

ordenados o definidos ni cumple

con la extensión mínima.

Presentación del

Ensayo


fue hecha en tiempo y forma,

además se entregó de forma

limpia en el formato pre

establecido (papel o digital).

La presentación/exposición fue

hecha en tiempo y forma,

aunque la entrega fue en el

formato preestablecido.

La presentación/exposición no fue

hecha en tiempo y forma, además

la entrega no se dio de la forma pre

establecida por el docente.

TIPO DE ACTIVIDAD

LUGAR ALCANCE FORMA

327

□Intraclase

□Extraclase

□Individual

□Grupal

□Taller


□Caso de estudio

□Investigativa





ejercicios







Introducción

C# es un lenguaje de Programación muy extenso, por lo cual se ha querido desarrollar con este

tipo de investigación un manual para reconocer todos sus componentes.

Marco Teórico

Según (James Kovacs 7 septiembre 2007) El nombre C Sharp fue inspirado por la notación

musical, donde '#' (sostenido, en inglés sharp) indica que la nota (C es la nota do en inglés) es un

semitono más alta, sugiriendo que C# es superior a C/C++. Además, el signo '#' se compone de

cuatro signos '+' pegados.9

Durante el desarrollo de la plataforma .NET, las bibliotecas de clases fueron escritas originalmente

usando un sistema de código gestionado llamado Simple Managed C (SMC). En enero de 1999,

Anders Hejlsberg formó un equipo con la misión de desarrollar un nuevo lenguaje de

9 James Kovacs (7 de septiembre de 2007). «C#/.NET History Lesson» (en ingles).



http://es.wikipedia.org/wiki/Sostenido

http://es.wikipedia.org/wiki/Semitono

http://es.wikipedia.org/wiki/Clase_%28inform%C3%A1tica%29

http://es.wikipedia.org/wiki/C%C3%B3digo_gestionado

http://es.wikipedia.org/wiki/Anders_Hejlsberg

http://jameskovacs.com/2007/09/07/cnet-history-lesson/

328

programación llamado Cool (C orientado a objetos). Este nombre tuvo que ser cambiado debido a

problemas de marca, pasando a llamarse C#.10


Elaborar un informe técnico (tipo manual / ensayo) acerca del IDE de Visual C#, que indique

cuáles son los componentes del IDE, creación de nuevos proyectos y elementos de una solución,

cómo utilizar los asistentes, diseñadores y editores.

IDE del Visual C#

Componentes



11 Estudiante de la Universidad Técnica de Machala, Escuela de Informática Quinto Quimestre “A”

Resumen

El presente ensayo, hace un análisis acerca del Lenguaje de Programación C# y sobre…

¿Cuáles son sus componentes del IDE?, ¿Cómo se maneja la plataforma?, ¿Es fácil la

utilización de esta herramienta?, ya que ahora en el Modulo de Programación haremos

énfasis en este lenguaje de programación y se necesita conocer sus componentes, sus

elementos, entre otros.


329

Palabras Claves: IDE, Lenguajes de Programación, Software, C#, Editores, Plataforma.Net,

Programación

Sumario:

Resumen

V. Introducción

VI. Acceso a Visual C#

VII. Conceptos Básicos

VIII. Elementos de una Solución

IX. Propiedades

X. Editores

Introducción

C# es un lenguaje de programación orientado a objetos desarrollado y estandarizado por Microsoft

como parte de su plataforma .NET.12

C# es un lenguaje orientado a objetos, seguro, moderno, de alto rendimiento es también la

principal herramienta para programar en la plataforma.NET

Acceso a Visual C#

Para hacer uso de C# es necesario tener instalado la versión más reciente de Visual 2010

Software necesario:

Visual

Edición 2010







330

Lo que se debe saber:

¿Qué programación es?

¿Qué lenguaje programación es?

Conceptos Básicos

Inicie Visual Basic Express

Página Principal de Microsoft 2010

Para la creación de un nuevo Proyecto:

Para empezar, abra el IDE y crear un nuevo proyecto (File >> New >> Proyecto o Ctrl + Shift + N)

seleccionar la

Visual C # Aplicación de consola o Aplicación Formulario

plantilla en la ventana que aparece

y haga clic en Aceptar.

Más información Los archivos del

proyecto

estarán aquí

Proyectos

La caja de Herramientas

331

Una vez que ha creado su proyecto, verá lo siguiente:

Elementos de una Solución

332

En los elementos de la solución son todos los formularios que se ordenan jerárquicamente para

poder hacer uso de cada uno de ellos.

Propiedades

Cambie el nombre del archivo de la

forma de helloForm.vb

Cambio de la propiedad de texto de

un formulario

333

Editores

Bibliografía

Rodríguez, T. (12 de Mayo de 2012). Xatak Android. Recuperado el 14 de Mayo de 2013,

de http://www.xatakandroid.com/programacion-android/xobotos-android-hecho-usando-c-y-

la-plataforma-mono-prescindiendo-de-java

Seco, J. A. (03 de Octubre de 2006). devjoker. Recuperado el 14 de Mayo de 2013, de

http://www.devjoker.com/contenidos/Tutorial-C/125/Introduccion-a-C.aspx

WAVE Corporation. (2013). WAVE Corporation. Recuperado el 14 de Mayo de 2013, de

http://waveengine.net/Engine/Documentation

334

UNIDAD II: BASE DE DATOS SQL Y

ADO .NET

335

UNIDAD III: CONCEPTO DE

INTERFAZ GRÁFICA DE USUARIO

Y PROGRAMACIÓN EN C#

336

Actividad N° 6


ENVIO: 27/05/2013

FECHA

ENTREGA: 29/05/2013

TEMA: Formularios Windows Forms: Controles CheckBox y CheckedListBox

UNIDAD N°3.1 y 3.2: 3.1. Principales controles

3.2. Propiedades

OBJETIVO: Manipular controles que se pueden utilizar para que la interfaz gráfica

sea amigable.

PROBLEMA: Desconocimiento de los controles en los Formularios Windows Forms.

INDICADOR DE EVALUACION: CALIFICACIÓN

Resuelve problemas de Ingeniería de Sistemas.

Comunicación efectiva.

Matrices de Evaluación

Criterios de Evaluación PARA EXPOSICIÓN

La exposición desarrollada:

Siempre

(1)

A

veces

(0.5)

Nunca

(0.1)

CONOCIMIENTO SOBRE EL TEMA. Responde claramente a las preguntas que se le realizan.

Demuestra seguridad en el tratamiento de los temas.

EXPRESIÓN.

Toma en cuenta los elementos vocales (mantiene: tono, énfasis, claridad durante la

presentación).Mantiene el mismo tono de voz durante la exposición. Habla con claridad y en forma coherente durante la exposición.

Toma en cuenta los elementos verbales, (explica en forma clara manteniendo coherencia en las ideas que expone).Hace énfasis tanto verbal como gestual, y resalta aspectos importantes del tema

Toman en cuenta los elementos visuales, (postura, viste de acuerdo a la ocasión, accesorios, gestos, ademanes).Sostiene una postura adecuada durante la exposición. Utiliza un vestuario adecuado para hacer la presentación

MATERIAL:

Entrega documentación impresa y digital. (Siguiendo las normas y convenciones para la

escritura y sin falta de ortografía). La redacción del documento debe ser clara. Debe incluir todas las fuentes de donde tomo la información.

Los recursos para presentar la exposición. (Diapositivas, trípticos o cualquier otro elemento

que permita dar a conocer el tema) Lo realiza a tiempo.

EJEMPLOS.

Incluye ejemplos claros que permiten un mejor entendimiento del tema.

CONTENIDO.

Los temas y el contenido presentado son fáciles de entender.

TIPO DE ACTIVIDAD

LUGAR ALCANCE FORMA

337

□Intraclase

□Extraclase

□Individual

□Grupal

□Taller


□Caso de estudio

□Investigativa





ejercicios





Norma Armijos

Jennifer Honores

Investigador - Analista Desarrollador de la actividad

DESARROLLO DE LA ACTIVIDAD, SOLUCIÓN O PROCEDIMIENTO

Introducción

Esta investigación tiene como propósito, dar a conocer las propiedades que posee CheckBox y

CheckedListBox, dos de los controles más usados en WebForms.

El ToolBox es la caja de herramientas en donde se encuentran los controles que se van a usar

para diseñar la interface de los diferentes tipos de aplicaciones.

Marco Teórico

Según (FERGUSON, y otros, 2003) C# es un lenguaje de programación orientado a objetos que

utiliza clases y estructuras para implementar tipos como formularios Windows Forms, controles de

interfaz de usuario y estructuras de datos.

Aquí definiremos dos controles que se encuentran en el ToolBox:

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:

338

Propiedades

Propiedad Descripción

Appearance Controla la apariencia del control, puede ser: Normal (como casilla) o

Button (como botón de comando).

AutoCheck Cambia de estado cada vez que se da clic al botón.

AllowDrop Indica si el control puede aceptar datos que el usuario arrastre.

Anchor Define a que bordes del contenedor está enlazado.

AutoEllipsis Habilitar el tratamiento automático del texto que se extiende mas ala del

ancho del botón.

Autosize Especifica si un control cambiara automáticamente de tamaño para

ajustarse a su contenido.

BlackColor El color de fondo del componente

CheckAlign Controla la alineación del checkbox. Hay 9 posiciones.

Checked Indica si el checkbox ha sido seleccionado o no.

CheckState Devuelve el estado del checkbox, que puede ser: Unchecked (sin

marcar), Checked (marcado) o Indeterminate (gris).

CausesValidation Indica si este componente genera eventos de validación.

Dock Define los bordes de control enlazados al contenedor

Enabled Indica si el control esta habilitado.

FlatApperance

Para los botones cuyo FlatStyle es FlatStyle.Flat, determina la apariencia

del borde y los colores utilizados para indicar el estado da activación el

estado del mouse.

GenerateMember Indica si se generara una variable miembro para este componente.

Image Imagen que se mostrara en el control.

ImageList Es utilizado para establecer u obtener la lista de imágenes que contiene

la imagen que aparece en una casilla de verificación.

Locked La propiedad si se puede mover cambiar el tamaño del control.

Margin Especifica el espacio entre este control y el margen de otro control.

Name Generalmente usaremos el prefijo chk.

Size Tamaño del control, en pixeles.

339

ThreeState Habilita o deshabilita el estado indeterminado del checkbox cada vez que

se da el tercer clic.

Métodos

Método Descripción

Focus Pone el foco sobre el checkbox.

Hide Oculta el checkbox, sin descargarlo de la memoria.

OnClick Provoca el evento click.

Show Pone visible el checkbox.

Eventos

Evento Descripción

CheckedChanged Ocurre al cambiar el valor de la propiedad Checked del control.

CheckStateChanged Ocurre al cambiar el valor de la propiedad CheckState del control.

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.

En tiempo de diseño, se pueden agregar elementos a los cuadros de lista con marcas de

verificación mediante el Editor de colección de cadenas, o bien se les pueden agregar elementos

dinámicamente desde una colección, utilizando la propiedad Items.

Propiedades

Propiedad Descripción

CheckOnClick Establece si el control podrá ser fijado la primera vez al dar click.

ColumnWidth Indica el ancho que debe tener las columnas de un control ListBox de

varias columnas.

FormatString Caracteres de especificador de formato que indica como se muestra

un valor.

FormattingEnabled Si esta propiedad es true, el valor de FormatString se utiliza para

convertir el valor de DisplayMember en un valor que se pueda mostrar.

GenerarMember Indica si se genera una variable miembro para este componente.

ImeMode Determina el estado IME(editor de métodos de entrada) del objeto

http://msdn.microsoft.com/es-es/library/system.windows.forms.checkedlistbox.aspx

http://msdn.microsoft.com/es-es/library/system.windows.forms.checkedlistbox.items.aspx

340

cuando se selecciona.

IntegralHeight Indica si la lista puede contener solo elementos completos.

Name Generalmente usaremos el prefijo ckl.

ScrollAlwaysVisible Indica si el cuadro de lista debe tener siempre una barra de

desplazamiento, independientemente de los elementos que tenga.

Sorted Controla si la lista esta ordenada.

TabIndex Determina el indice del orden de tabulación que ocupara este control.

ThreeDCheckBox Indica si la apariencia de los items se mostrará en 3D o plano.

ToolTip en tooltip1 Determina la información sobre herramientas que se muestra cuando

se desplaza el puntero sobre el control.

TabStop Indica si el usuario puede utilizar la tecla TABULADOR para poner el

foco en el control.

Métodos

Método Descripción

Focus Establece el foco de entrada en el control.

OnClick Provoca el evento click.

Show Muestra el control al usuario

Eventos

Evento Descripción

ItemCheck Ocurre al seleccionar un elemento y poner el check en true.

SelectedIndexChanged Ocurre al seleccionar otro elemento.

SOLUCIÓN O RESULTADOS

342

CONCLUSIONES

En conclusión, se pudo comprobar que los componentes CheckBox y CheckedListBox son

básicos para algún desarrollo de software, por ejemplo si queremos hacer la alternativa de

intereses, el usuario podrá escoger muchas de estas.

REFERENCIA BIBLIOGRÁFICA

BESTEIRO, Marco y RODRIGUEZ, Miguel. www.ehu.es. C#. [En línea] [Citado el: 09 de 05 de 2013.]

http://www.ehu.es/mrodriguez/archivos/csharppdf/Lenguaje/Introduccion.pdf.

FERGUSON, Jeff, y otros. 2003. La Biblia C#. Madrid : Anaya Multimedia, 2003. 84-415-1484-4.

343

Actividad N° 7 ACTIVIDAD N°: 7 FECHA

ENVIO:

10/06/2013 FECHA

ENTREGA:

13/06/2013

TEMA: 3. Realizar informe sobre la creación de Clases y Métodos en C#.

UNIDAD N° III: CONCEPTOS DE INTERFACE GRÀFICA DE USUARIO Y

PROGRAMACIÓN EN C#


programación.

PROBLEMA: El estudiante debe identificar los objetivos del lenguaje de programación

C#.


CALIFICACIÓN





Profundizaci

ón

del tema


sustancial del tema y

buena cantidad de

detalles.

Descripción ambigua del

tema a tratar, algunos

detalles que no clarifican

el tema.

Descripción inexacta del

tema a tratar, sin detalles

significativos o escasos.

Aclaración

sobre el

tema


claramente presentado

así como de fácil

seguimiento.

Tema con información

bien focalizada pero no

suficientemente

organizado.

Tema impreciso y poco

claro, sin coherencia entre

las partes que lo componen.

Alta calidad

del diseño

Ensayo escrito con

tipografía sencilla y que

cumple con los criterios

de diseño planteados,

sin errores de

ortografía.


organizado con al menos

tres errores de ortografía

y tipografía difícil de leer.

Ensayo mal planteado que

no cumple con los criterios

de diseño planteados y con

más de tres errores de

ortografía.

Elementos

propios del

Ensayo

El ensayo cumple con

los cuatro criterios de

diseño (Resumen,

palabras clave, cuerpo

del ensayo y

referencias



pero no con la extensión

solicitada (mínimo 3

páginas) o bien, estos

puntos no han sido


criterios de diseño

planteados o bien no están

claramente ordenados o

definidos ni cumple con la

extensión mínima.

344

bibliográficas) correctamente

realizados.

Presentación

del Ensayo

La



forma, además se

entregó de forma limpia

en el formato pre

establecido (papel o

digital).

La



forma, aunque la entrega

fue en el formato

preestablecido.


no fue hecha en tiempo y

forma, además la entrega no

se dio de la forma pre

establecida por el docente.

TIPO DE ACTIVIDAD

LUGAR ALCANCE FORMA

□Intraclase

□Extraclase

□Individual

□Grupal

□Taller


□Caso de estudio

□Investigativa

□Vinculación con a

colectividad




ejercicios







Introducción

Este trabajo nos ayuda a entender cómo crear clases, métodos para saber cómo se comunican

entre sí.

Marco Teórico

Métodos:

345

Todo método debe ser parte de una clase, no existen métodos globales (funciones).

Por defecto, los parámetros se pasan por valor. (Nótese que las listas y otras colecciones son

variables por referencia (referencias al espacio reservado para esa lista en la pila) y que se pasa

por valor al método la referencia, pero el espacio reservado para la lista es común, por lo que si

elimina un elemento lo hace también de la original).13

Clases:

Una variable de objeto de cierta clase no almacena los valores del objeto sino su referencia (al

igual que Java).

El operador de asignación no copia los valores de un objeto, sino la referencia al mismo (al igual

que Java).


Realizar informe sobre la creación de Clases y Métodos en C#.

C#

Creación de Clases y Métodos


13 C# | WebProgramación Artículos, ejemplos, fragmentos de código, etc.

14 Estudiante de la Universidad Técnica de Machala, Escuela de Informática Quinto Semestre “A”

Resumen

El presente ensayo nos presenta una explicación de: ¿Cómo se crean Clases en C#?,

¿Cómo se crean métodos en C#?, ¿Para qué sirven las clases y los métodos?, ¿Cómo

llamar a una clase desde un método en C#?.

http://www.webprogramacion.com/csharp.aspx

346

Palabras Claves: C#, Clases , Métodos, Programación, Visual Estudio.

Sumario:

Resumen

XI. Clases

a. ¿Qué son las clases?

b. Definir Clases

c. Clases Estáticas

d. Herencia de Clases

XII. Métodos

a. ¿Qué son las Métodos?

b. Parámetros de los Métodos

XIII. Ejercicios de Clases y Métodos

Introducción

C# (pronunciado si sharp en inglés) es un lenguaje de programación orientado a objetos

desarrollado y estandarizado por Microsoft como parte de su plataforma .NET.

C# es uno de los lenguajes de programación diseñados para la infraestructura de lenguaje común.

CLASES

¿Qué son las Clases?





http://es.wikipedia.org/wiki/Infraestructura_de_lenguaje_com%C3%BAn

347

Una clase es una construcción que permite crear tipos personalizados propios mediante la agrupación de variables de otros tipos, métodos y eventos. Una clase es como un plano. Define los datos y el comportamiento de un tipo. Si la clase no se declara como estática, el código de cliente puede utilizarla mediante la creación de objetos o instancias que se asignan a una variable.

Declarar Clases

Las clases se definen mediante la palabra clave CLASS, como se muestra en el siguiente ejemplo:

Public class Customer

{

// Campos, propiedades, métodos y eventos van aquí...

}

Clases Estáticas

Las clases estáticas y sus miembros se utilizan para crear datos y funciones a las que se puede tener acceso sin crear una instancia de la clase.

Herencia de Clases

La herencia se realiza a través de una derivación, lo que significa que una clase se declara utilizando una clase base de la cual hereda los datos y el comportamiento. Una clase base se especifica anexando dos puntos y el nombre de la clase base a continuación del nombre de la clase derivada, del modo siguiente:

Public class Manager : Employee

{

/ / Campos de empleados, propiedades, métodos y eventos son heredados

/ / Campos de nuevo gerente, propiedades, métodos y eventos van aquí...

}

MÉTODOS

¿Qué son las Métodos?

http://msdn.microsoft.com/es-es/library/0b0thckt%28v=vs.80%29.aspx

348

Los métodos son un bloque de código que contiene una serie de instrucciones. En C#, cada instrucción se ejecuta en el contexto de un método. Los métodos se declaran en una clase o estructura especificando el nivel de acceso, el valor devuelto, el nombre del método y los parámetros de método. Los parámetros de método se incluyen entre paréntesis y separados por comas. Los paréntesis vacíos indican que el método no requiere ningún parámetro. Esta clase contiene tres métodos Ejemplo:

class Motocicleta

{

Public void IniciarArranque() { }

Public void AgregarGas(int galones) { }

Public int Conducir(int miles, int aceleración) {

return 0;

}

}

Llamar a un método en un objeto es similar a tener acceso a un campo. Después del nombre de objeto, se agrega un punto, el nombre del método y paréntesis. Los argumentos se enumeran entre paréntesis y separados por comas. Por tanto, se puede llamar a los métodos de la clase Motocicleta del modo siguiente:

Motocicleta Moto = new Motocicleta ();

Moto. IniciarArranque ();

Moto. AgregarGas (15);

Moto. Conducir (5, 20);

Parámetros de los métodos

En el método al que se llama, los argumentos de entrada se denominan parámetros. Los parámetros que un método recibe también se proporcionan entre paréntesis, pero se debe especificar el tipo y nombre de cada parámetro. El nombre no tiene por qué ser igual que el argumento. Por ejemplo:

public static void PasaEntero()

http://msdn.microsoft.com/es-es/library/0b0thckt%28v=vs.80%29.aspx

http://msdn.microsoft.com/es-es/library/ah19swz4%28v=vs.80%29.aspx

349

{

int num_44 = 44;

entero (fortyFour);

}

static void entero(int i)

{

i = 33;

}

Ejemplo de Creación de Clases Métodos

Realizar un Windows Form que contenga datos personales de una persona, al dar clic en guardar

llamar a otra clase de Windows Form y me muestre los datos ingresados enviándolos a un método

que reciba dichos parámetros.

1. Abrimos Visual Estudio

350

2. Damos Clic en Archivo-->Nuevo Proyecto --> Y escogemos una aplicación de C#

3. Nos aparecerá la siguiente Pantalla

351

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

352

8. Arrastramos los componentes Nuevamente:

353

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


{

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

{


}

}

12. Cambiamos los nombres a los Labels

354

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);


}

15. A si nos debe quedar

355

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

http://ar.groups.yahoo.com/group/DesarrolloCSharp/

http://geeks.ms/

356

Actividad N° 8


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

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


INDICADOR DE

EVALUACION:

q) Comunicación efectiva

r) Asuntos contemporáneos


TIPO DE ACTIVIDAD

LUGAR ALCANCE FORMA

□Intraclase

□Extraclase

□Individual

□Grupal

□Taller


□Caso de estudio

□Investigativa





ejercicios



CALIFICACIÓN

357

Actividad N° 9


TEMA:

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).


PROGRAMACIÓN EN C#


PROBLEMA: Desconocimiento para manipular objetos.

INDICADOR DE

EVALUACION: s) Comunicación efectiva

358

t) Asuntos contemporáneos


TIPO DE ACTIVIDAD

LUGAR ALCANCE FORMA

□Intraclase

□Extraclase

□Individual

□Grupal

□Taller


□Caso de estudio

□Investigativa





ejercicios



CALIFICACIÓ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)

359

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;

360

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;

361

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); } }

362

}

363

Actividad N° 10


TEMA:

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.

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.


PROGRAMACIÓN EN C#


PROBLEMA: Desconocimiento para manipular objetos.

INDICADOR DE

EVALUACION:

u) Comunicación efectiva

v) Asuntos contemporáneos


TIPO DE ACTIVIDAD

LUGAR ALCANCE FORMA

364

□Intraclase

□Extraclase

□Individual

□Grupal

□Taller


□Caso de estudio

□Investigativa





ejercicios



CALIFICACIÓN

365

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:


2. Creamos una clase tipo FORM:

3. Nos tiene que quedar la ventana:

4. Programamos todos los botones

CODIGO

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 Deber2 { public partial class Form1 : Form

366

{ 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);

367

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 <= 9) { agregarTexto("7"); } } private void btn8_Click(object sender, EventArgs e) { if (txtIngreso.TextLength <= 9) { agregarTexto("8"); } } private void btn9_Click(object sender, EventArgs e) { if (txtIngreso.TextLength <= 9) { agregarTexto("9"); } } private void btn4_Click(object sender, EventArgs e) { if (txtIngreso.TextLength <= 9) { agregarTexto("4"); } } private void btn5_Click(object sender, EventArgs e) { if (txtIngreso.TextLength <= 9) { agregarTexto("5"); } } private void btn6_Click(object sender, EventArgs e) { if (txtIngreso.TextLength <= 9) { agregarTexto("6"); } } private void btn1_Click(object sender, EventArgs e) { if (txtIngreso.TextLength <= 9) { agregarTexto("1"); } } private void btn2_Click(object sender, EventArgs e) { agregarTexto("2");

368

} private void btn3_Click(object sender, EventArgs e) { if (txtIngreso.TextLength <= 9) { agregarTexto("3"); } } private void btn0_Click(object sender, EventArgs e) { if (txtIngreso.TextLength <= 9) { agregarTexto("0"); } } private void btnComa_Click(object sender, EventArgs e) { char texto; char punto=','; String cadenaTexto=txtIngreso.Text; for (int i=0; i < txtIngreso.TextLength; i++) { texto=txtIngreso.Text[i]; if (texto.Equals(punto)) { //NO SE AGREGARA MAS PUNTOS SI HAY EN LA CAJA DE TEXTO contadorDecimal = 0; i = txtIngreso.TextLength; } else { //ENTRO NO HAY PUNTOS contadorDecimal = 1; } } if (contadorDecimal == 1) { if (txtIngreso.Text.Equals("0")) { agregarTexto("0,"); } else { agregarTexto(","); } } } public void agregarTexto(String dato) { if (txtIngreso.Text.Equals("0")) { txtIngreso.Text = dato; } else { String texto = txtIngreso.Text; String numero = dato; String completo = texto + numero;

369

txtIngreso.Text = completo; } } private void btnIgual_Click(object sender, EventArgs e) { switch (operacionesCasos) { case 1: //Suma OperacionSuma();break; case 2: //Resta OperacionResta(); break; case 3: //Multiplicacion OperacionMultiplicacion();break; case 4: //Division OperacionDivision(); break; case 5: //Potencia OperacionPotencia(); break; } } //SUMA private void btnMas_Click(object sender, EventArgs e) { operacionesCasos = 1; double auxiliarSuma1 = double.Parse(txtIngreso.Text); vectorOperaciones[0] = vectorOperaciones[0] + auxiliarSuma1; txtIngreso.Text = ""; } public void OperacionSuma() { double auxiliarSuma2 = double.Parse(txtIngreso.Text); vectorOperaciones[0] = vectorOperaciones[0] + auxiliarSuma2; txtIngreso.Text = vectorOperaciones[0]+""; vectorOperaciones[0]=0; } //RESTA private void btnMenos_Click(object sender, EventArgs e) { operacionesCasos = 2; if ((contadorMultiplicacion++) < 2) { double auxiliarResta = double.Parse(txtIngreso.Text); vectorOperaciones[0] = auxiliarResta; txtIngreso.Text = ""; } else { double auxiliarResta = double.Parse(txtIngreso.Text); vectorOperaciones[0] = vectorOperaciones[0] - auxiliarResta; txtIngreso.Text = ""; }

370

} public void OperacionResta() { double auxiliarResta2 = double.Parse(txtIngreso.Text); vectorOperaciones[0] = vectorOperaciones[0] - auxiliarResta2; txtIngreso.Text = vectorOperaciones[0] + ""; vectorOperaciones[0] = 0; } //MULTIPLIACION private void btnMultipliador_Click(object sender, EventArgs e) { operacionesCasos = 3; if ((contadorMultiplicacion++) < 2) { vectorMultiplicacion[0] = 1; double auxiliarMultiplicacion = double.Parse(txtIngreso.Text); vectorMultiplicacion[0] = vectorMultiplicacion[0] * auxiliarMultiplicacion; txtIngreso.Text = ""; } else { double auxiliarMultiplicacion = double.Parse(txtIngreso.Text); vectorMultiplicacion[0] = vectorMultiplicacion[0] * auxiliarMultiplicacion; txtIngreso.Text = ""; } } public void OperacionMultiplicacion() { double auxiliarMultiplicacion = double.Parse(txtIngreso.Text); vectorMultiplicacion[0] = vectorMultiplicacion[0] * auxiliarMultiplicacion; txtIngreso.Text = vectorMultiplicacion[0] + ""; vectorMultiplicacion[0] = 1; } //DIVISION private void btnDivisor_Click(object sender, EventArgs e) { operacionesCasos = 4; if ((contadorDivision++) < 2) { vectorOperaciones[0] = 1; double auxiliarDivision = double.Parse(txtIngreso.Text); vectorOperaciones[0] = auxiliarDivision; txtIngreso.Text = ""; } else { double auxiliarDivision = double.Parse(txtIngreso.Text); vectorOperaciones[0] = vectorOperaciones[0] / auxiliarDivision; txtIngreso.Text = ""; } } public void OperacionDivision() { double auxiliarDivision = double.Parse(txtIngreso.Text); vectorOperaciones[0] = vectorOperaciones[0] / auxiliarDivision; txtIngreso.Text = vectorOperaciones[0] + ""; }

371

//POTENCIA private void btnExponente_Click(object sender, EventArgs e) { operacionesCasos = 5; if ((contadorPotencia++) < 2) { double auxiliarPotencia = double.Parse(txtIngreso.Text); vectorOperaciones[0] = auxiliarPotencia; txtIngreso.Text = ""; } } public void OperacionPotencia() { double auxiliarResultado; double auxiliarPot = double.Parse(txtIngreso.Text); auxiliarResultado = Math.Pow(vectorOperaciones[0], auxiliarPot); txtIngreso.Text = auxiliarResultado + ""; vectorOperaciones[0] = 0; } } }

Ejercicio 2:

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.

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.

Realizacion:


2. Creamos una clase tipo FORM:

3. Nos tiene que quedar la ventana:

372

4. Programamos todos los botones

CODIGO

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 Deber2 { public partial class Ahorcado : Form { public String nombreCategoria; public String palabraBd; public String palabraBdPista; public char []vectorAux; public int auxiliarDibujo=0; public String nombreTabla = ""; public DataSet ds; public DataRow dr; public int filas = 0; public Ahorcado() { InitializeComponent(); gbContenedor.Enabled = false; }

373

private void Ahorcado_Load(object sender, EventArgs e) { } private void btnJugar_Click(object sender, EventArgs e) { if (rbCategoria1.Checked) { nombreTabla = "Categoria1"; categoria("Categoria1"); } if (rbCategoria2.Checked) { nombreTabla = "Categoria2"; categoria("Categoria2"); } if (rbCategoria3.Checked) { nombreTabla = "Categoria3"; categoria("Categoria3"); } if (rbCategoria4.Checked) { nombreTabla = "Categoria4"; categoria("Categoria4"); } } public void categoria(String categoria) { gbContenedor.Enabled = true; activarTeclas(false, true); gbJuego.Text = "Juego Categoria: "+nombreTabla; escogerCategoria(); } private void btnNuevo_Click(object sender, EventArgs e) { activarTeclas(false, true); btnJugar.Enabled = true; gbContenedor.Enabled = false; esconderAhorcado(); auxiliarDibujo = 0; } public void esconderAhorcado() { ahoPalo1.Visible = false; ahoPalo2.Visible = false; ahoPalo3.Visible = false; ahoPalo4.Visible = false; ahoMuñeco1.Visible = false; ahoMuñeco2.Visible = false; ahoMuñeco3.Visible = false; ahoMuñeco4.Visible = false; ahoMuñeco5.Visible = false; ahoMuñeco6.Visible = false; ahoMuñecoFin.Visible = false; }

374

public void activarTeclas(Boolean tcla,Boolean teclado) { btnJugar.Enabled=tcla; txtPalabra.Text = ""; txtPista.Text = ""; btnA.Enabled = teclado; btnB.Enabled = teclado; btnC.Enabled = teclado; btnD.Enabled = teclado; btnE.Enabled = teclado; btnF.Enabled = teclado; btnG.Enabled = teclado; btnH.Enabled = teclado; btnI.Enabled = teclado; btnJ.Enabled = teclado; btnK.Enabled = teclado; btnL.Enabled = teclado; btnM.Enabled = teclado; btnN.Enabled = teclado; btnÑ.Enabled = teclado; btnO.Enabled = teclado; btnP.Enabled = teclado; btnQ.Enabled = teclado; btnR.Enabled = teclado; btnS.Enabled = teclado; btnT.Enabled = teclado; btnU.Enabled = teclado; btnV.Enabled = teclado; btnW.Enabled = teclado; btnX.Enabled = teclado; btnY.Enabled = teclado; btnZ.Enabled = teclado; } public void escogerCategoria() { conexionBd();; palabraBd=palabraBd.ToUpper(); txtPista.Text = palabraBdPista; //Llenar de guiones la caja de texto String cadenaTextoForm = txtPalabra.Text; vectorAux = new char[palabraBd.Length]; for(int i=0; i<palabraBd.Length;i++){ cadenaTextoForm = cadenaTextoForm + "- "; } txtPalabra.Text = cadenaTextoForm; for (int i = 0; i < palabraBd.Length; i++) { vectorAux[i] = '-'; } } public void conexionBd() { //buscar en tablas //Hacer la consulta a la tabla consulta //Hacer un numero aletorio y hacer una busquedad en ese registro //Cojer las variables de texto, pista, numero de caracteres de la palabra OleDbConnection conex = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=C:\Users\Computron\Documents\Ahorcado.accdb");

375

OleDbDataAdapter bd = new OleDbDataAdapter("select * from "+nombreTabla, conex); ds = new DataSet(); bd.Fill(ds, nombreTabla); filas = ds.Tables[nombreTabla].Rows.Count; Random ran= new Random(); filas=ran.Next(filas); dr = ds.Tables[nombreTabla].Rows[filas]; //asigna los valores de los campos en los objetos del formulario palabraBd = dr["palabra"].ToString(); palabraBdPista = dr["Pista"].ToString(); } public void operaciones(char letraComparar) { int contador=0; char [] vectorChar = new char [palabraBd.Length]; char[] vectorAuxiliarText = new char[palabraBd.Length]; String cadenaAux=""; for (int i = 0; i < palabraBd.Length; i++) { if (palabraBd[i].Equals(letraComparar)) { vectorAux[i] = letraComparar; cadenaAux = cadenaAux +vectorAux[i] ; } else { cadenaAux = cadenaAux + vectorAux[i]; contador++; } } txtPalabra.Text = ""; for (int i = 0; i < palabraBd.Length; i++) { txtPalabra.Text = txtPalabra.Text+vectorAux[i]; } if (contador == palabraBd.Length) { auxiliarDibujo = auxiliarDibujo+1; dibujarAhorcado(auxiliarDibujo); } if (txtPalabra.Text.Equals(palabraBd)) { MessageBox.Show("HA GANADO EL JUEGO"); gbContenedor.Enabled = false; } } public void dibujarAhorcado(int num) { switch (num) { case 1: //Dibujar Palos 1 y 2 ahoPalo1.Visible = true; ahoPalo2.Visible = true; break; case 2: //Dibujar Palos 3 y 4 ahoPalo3.Visible = true; ahoPalo4.Visible = true;

376

break; //DIBUJAR MUÑECO case 3: //Dibujar Cabeza ahoMuñeco1.Visible = true; break; case 4: //Dibujar Cuerpo ahoMuñeco2.Visible = true; break; case 5: //Dibujar Brazo 1 ahoMuñeco3.Visible = true; break; case 7: //Dibujar Brazo 2 ahoMuñeco4.Visible = true; break; case 8: //Dibujar Pierna 1 ahoMuñeco5.Visible = true; break; case 9: //Dibujar Pierna 2 ahoMuñeco6.Visible = true; break; case 10: //Dibujar Ahorcado; FIN DE JUEGO ahoMuñecoFin.Visible = true; MessageBox.Show("Perdio: Palabra Correcta: "+palabraBd); activarTeclas(false, false); break; } } /* * * TECLAS SE DESACTIVAN AL PRESIONARLAS * */ private void btnA_Click(object sender, EventArgs e) { btnA.Enabled = false; operaciones('A'); } private void btnB_Click(object sender, EventArgs e) { btnB.Enabled = false; operaciones('B'); } private void btnC_Click(object sender, EventArgs e) { btnC.Enabled = false; operaciones('C'); } private void btnD_Click(object sender, EventArgs e) { btnD.Enabled = false; operaciones('D'); } private void btnE_Click(object sender, EventArgs e)

377

{ btnE.Enabled = false; operaciones('E'); } private void btnF_Click(object sender, EventArgs e) { btnF.Enabled = false; operaciones('F'); } private void btnG_Click(object sender, EventArgs e) { btnG.Enabled = false; operaciones('G'); } private void btnH_Click(object sender, EventArgs e) { btnH.Enabled = false; operaciones('H'); } private void btnI_Click(object sender, EventArgs e) { btnI.Enabled = false; operaciones('I'); } private void btnJ_Click(object sender, EventArgs e) { btnJ.Enabled = false; operaciones('J'); } private void btnK_Click(object sender, EventArgs e) { btnK.Enabled = false; operaciones('K'); } private void btnL_Click(object sender, EventArgs e) { btnL.Enabled = false; operaciones('L'); } private void btnM_Click(object sender, EventArgs e) { btnM.Enabled = false; operaciones('M'); } private void btnN_Click(object sender, EventArgs e) { btnN.Enabled = false; operaciones('N'); } private void btnÑ_Click(object sender, EventArgs e) { btnÑ.Enabled = false; operaciones('Ñ'); } private void btnO_Click(object sender, EventArgs e) { btnO.Enabled = false; operaciones('O'); } private void btnP_Click(object sender, EventArgs e) {

378

btnP.Enabled = false; operaciones('P'); } private void btnQ_Click(object sender, EventArgs e) { btnQ.Enabled = false; operaciones('Q'); } private void btnR_Click(object sender, EventArgs e) { btnR.Enabled = false; operaciones('R'); } private void btnS_Click(object sender, EventArgs e) { btnS.Enabled = false; operaciones('S'); } private void btnT_Click(object sender, EventArgs e) { btnT.Enabled = false; operaciones('T'); } private void btnU_Click(object sender, EventArgs e) { btnU.Enabled = false; operaciones('U'); } private void btnV_Click(object sender, EventArgs e) { btnV.Enabled = false; operaciones('V'); } private void btnW_Click(object sender, EventArgs e) { btnW.Enabled = false; operaciones('W'); } private void btnX_Click(object sender, EventArgs e) { btnX.Enabled = false; operaciones('X'); } private void btnY_Click(object sender, EventArgs e) { btnY.Enabled = false; operaciones('Y'); } private void btnZ_Click(object sender, EventArgs e) { btnZ.Enabled = false; operaciones('Z'); } } }

379

UNIDAD IV: PRESENTACIÓN DE

RESULTADOS

380

EVALUACIONES

PARCIALES

381

Codigo

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 Leccion2 { public partial class Form1 : Form { String[] valorOriginal; Char [] valorCapicua; public Form1() { InitializeComponent(); } private void textBox1_KeyPress(object sender, KeyPressEventArgs e) { errorProvider1.Clear(); if (!Char.IsNumber(e.KeyChar)) { e.Handled = true; errorProvider1.SetError(textBox1, "Solo Numeros"); return; } } private void button1_Click(object sender, EventArgs e) { int tama= textBox1.TextLength; valorOriginal = new String[tama+1]; valorCapicua = new Char [tama+1]; int contador = tama-1; for (int i = 0; i < tama; i++) { valorCapicua[i] = textBox1.Text[contador];

382

contador--; } int aux=1; for (int i = 0; i < tama; i++) { if (textBox1.Text[i].Equals(valorCapicua[i])) { } else { aux = 0; } } if (aux == 1) { MessageBox.Show("Si es Capicua"); } else { MessageBox.Show("No es Capicua"); } } private void textBox2_KeyPress(object sender, KeyPressEventArgs e) { if (!Char.IsLetter(e.KeyChar)) { e.Handled = true; return; } } private void button2_Click(object sender, EventArgs e) { listBox1.Items.Add(textBox2.Text); textBox2.Text = ""; } private void listBox1_DoubleClick(object sender, EventArgs e) { String valorSeleccion = listBox1.SelectedItem.ToString(); listBox1.Items.Remove(valorSeleccion); listBox2.Items.Add(valorSeleccion); } private void listBox2_DoubleClick(object sender, EventArgs e) { String valorSeleccion = listBox2.SelectedItem.ToString(); listBox2.Items.Remove(valorSeleccion); listBox1.Items.Add(valorSeleccion); } } }

383

EXAMEN FINAL

384

PROYECTO FINAL

385

CONTROL DE PROYECTO N°:

1 FECHA ENVIO:

12/06/2013

TEMA:

Elaborar la propuesta de investigación para el proyecto final del

módulo. El anteproyecto debe incluir:

1. Nombre de la Empresa

2. Datos de la empresa (dirección, teléfonos, actividad, etc.)

3. Antecedentes (fecha de creación, historia)

4. Descripción de la Empresa (organigramas, funciones, procesos)

5. Selección y Descripción del área que se va a implementar la

automatización.

OBJETIVO: Explicar la factibilidad del proyecto.

PROBLEMA: Desconocimiento de los requerimientos de información para desarrollar

un software.

INDICADOR DE EVALUACION: CALIFICACIÓN

Comunicarse efectivamente

Diseñar , conducir experimentos, analizar e interpretar datos.

Valoración 1 punto 0,5 puntos 0,1 puntos

Introducción

La introducción incluye el propósito, exposición general del tema, objetivos claros y subdivisiones principales.

No se presenta la exposición general del tema o las subdivisiones principales. El propósito, el tema y los objetivos requieren clarificación o no se presentan de forma objetiva.

La introducción está incompleta, es inefectiva, confusa o está ausente. No incluye exposición general del tema, sus subdivisiones principales o no son relevantes. El propósito, el tema y los objetivos no están claros.

Organización (párrafos y transiciones)

Las ideas se presentan en orden lógico. Tiene coherencia y presenta fluidez en la transición de las ideas. El orden de los párrafos refuerza el contenido. Cada párrafo presenta una idea distinta. El espacio en blanco o las gráficas contribuyen a la organización.

Las ideas presentan orden lógico. Tiene coherencia pero la transición de las ideas entre los párrafos no se presenta con fluidez. El orden y las ideas de los párrafos refuerzan limitadamente el contenido. Necesita añadir más espacios en blanco para contribuir a la organización.

Las ideas no se presentan en orden lógico. No tiene coherencia, las transiciones entre párrafos es pobre o ninguna y el orden de los párrafos no refuerza el contenido. Los espacios en blanco no son suficientes para contribuir a la organización.

Cohesión La estructura o el orden de las palabras (sintaxis) en las oraciones es

Tiene errores en la estructura de las oraciones, en la

Tiene demasiados errores de puntuación y en la utilización de los

386

lógico. Tiene muy pocos errores de puntuación o en la utilización de pronombres. Selecciona cuidadosamente las palabras.

puntuación y en la utilización de los pronombres. Las palabras seleccionadas son poco apropiadas. Son frecuentes fragmentos y oraciones incompletas.

pronombres. Las palabras seleccionadas son inapropiadas.

Corrección (gramática)

No tiene errores ortográficos, de acentuación o de conjugación de verbos. Voz activa, apropiada para el tema y la audiencia.

Tiene errores ortográficos, de acentuación o conjugación de verbos. La voz no es activa y es poco apropiada para el tema y la audiencia. Los errores distraen al lector. Muestra falta de cuidado.

Tiene muchos errores que distraen considerablemente o totalmente al lector.

Contenido

Todas las ideas que se presentan tienen relación directa con el tema. Las ideas se presentan con claridad y objetividad. Éstas no se repiten ni se presentan lagunas. No utilizó el copiar y pegar.

Una buena cantidad de las ideas que se presentan tienen relación con el tema. Éstas deben presentarse con mayor claridad u objetividad. Algunas ideas se repiten. El documento presenta muy poca originalidad.

Las ideas que se presentan tienen poca o ninguna relación con el tema, están pobremente definidas, no son claras ni se presentan con objetividad. Muchas ideas se repiten. El texto es prácticamente un copiado y pegado.

TIPO DE ACTIVIDAD

LUGAR ALCANCE FORMA

□Intraclase □Extraclase

□Individual □Grupal

□Taller □Síntesis, esquemas □Caso de estudio □Investigativa □Vinculación con la colectividad

□Práctica en laboratorio □Práctica en clase □Resolución de problemas, ejercicios □Ensayo, artículo □Informe de exposición


NOMBRES ROL DESCRIPCIÓN

Norma Armijos

Jennifer Honores

Giovanni Ochoa

Investigador - Analista Desarrolladores del Proyecto

387

Tema:

SISTEMA INFORMÁTICO CAI

Nombre de la empresa

Centro de Atención de Adolescentes Infractores N° 4 El Oro

Datos de la empresa

Coordinador: Lcdo. Ramiro Bolívar Román Valdivieso

Dirección: Parroquia El Cambio km. ⁄ Vía a Pasaje

Provincia El Oro - Cantón Machala

Teléfono: 072992732

Antecedentes

En el Ecuador, al 2010, funcionan once centros de internamiento paras las y los adolescentes que

han infringido la ley Penal. De estos, dos son para mujeres, dos son mixtos y siete solo para

hombres.

El número de adolescentes que ingresan a los centros para ser custodiados (quienes tienen

medidas cautelar), o bajo la responsabilidad del centro (quienes tienen medidas socio educativas)

varía por mes, según la estadística de la DANCAI.

Descripción de la empresa

El Centro de Atención de Adolescentes Infractores N°. 4 El Oro en conflicto con la Ley Machala es

una entidad pública sin fines de lucro que recibe a personas de 12 a 18 años de edad, de sexo

masculino que hayan infringido la ley para promover su desarrollo personal, habilidades, destrezas

interpersonales y ocupacionales, logrando así reinsertarlo a la sociedad como un elemento

productivo de bien.

388

De cada adolescente se tendrá un expediente el cual contendrá la historia de la vida del

adolescente y su familia o personas de su vínculo afectivo, y el trabajo realizado con ellos por

cada uno de los funcionarios del Centro desde el momento que ingresa el adolescente hasta que

sale en libertad.

Organigrama

Funciones

El Coordinador de CAI - Centro de Adolescentes Infractores N°. 4 El Oro en conjunto con los

departamentos de Talento Humano - Bodeguero, Trabajadora Social, Traslado - Chofer y

Psicólogo, hacen el respectivo análisis, desarrollo y control de todas las actividades diarias de la

institución.

Procesos

Los procesos que realiza la institución en cada departamento, son los siguientes:

Coordinador

Es el encargado de realizar las respectivas revisiones y peticiones de las autoridades

competentes del centro para la realización de sus actividades a la mejora de la institución.

Talento Humano - Archivador

Es el encargado de recibir todas las actas, fichas de los menores, fichas de personas internas y

profesional que trabajan dentro del mismo.

Psicólogo

Es el encargado de realizar un análisis general, correspondiente a cada adolescente para la

valoración de un informe al centro de infractores, así como un análisis profundo de la historia de la

familia del adolescente.

Coordinador del CAI

Unidad de Desarrollo

Unidad de Operación

Unidad de Salud

Unidad de Logística

Dirección CAI

389

Trabajadora social

Es la encargada de la movilización respectiva a los adolescentes en estado de enfermedad a un

centro de salud, también llenando una ficha de cada interno por la visita o diálogo sobre su

comportamiento dentro del centro.

Chofer

Es el encargado de realizar el recorrido, traslado a diferentes lugares que se deseen, realiza las

respectivas encomiendas por cada uno de los profesionales que laboran en el Centro de

Adolescentes Infractores.

390

Selección y Descripción del área que se va a implementar la automatización.

Selección de Áreas:

Norma Armijos: Área del Psicólogo

Jennifer Honores: Área de Trabajadora Social

Giovanni Ochoa: Área del Archivador

Descripción:

Área de Archivador --> GIOVANNI OCHOA

Sería de ingresar de forma automática los datos de los adolescentes y del tutor, mediante una

ficha digital para guardarla en una base de datos y también de registrar los productos que se

ingresan al centro de infractores de El Oro.

Iniciar Sesión

Adolescente

Registrar inventario

Operaciones con oficios

Módulos Descripción

Inicio Sesión Inicia Sesión con su respectivo usuario para que solo

pueda hacer sus procesos

Adolescente Ingresa, Actualiza, Elimina, Imprime cada registro de

adolescente.

Inventario Ingresa, Actualiza, Elimina, Imprime la información de los

Inventario.

Oficios Ingresa, Actualiza, Elimina, Imprime la información de los

Oficios.

391

Área de Psicólogo --> NORMA ARMIJOS

En este departamento del Centro de Infractores se atienden a los adolescentes para llevar un

control de la salud de cada uno de ellos.

Tenemos operaciones como:

Iniciar Sesión

Ingresar Ficha Médica: Se registra todo el historial clínico del adolescente internado que ha

sido tratado por el psicólogo.

Buscar Ficha Médica: Permitirá buscar la ficha del adolescente que previamente ha sido

atendido

Actualizar Ficha Médica: Permitirá que actualice alguna información del adolescente.

Generar Reportes Médicos: Se podrá imprimir las fichas médicas de cada adolescente.

Generar Oficios: Cada vez que necesite redactar un oficio, obtendrá el número de oficio

automáticamente para de esta manera tener una secuencia con todos los departamentos.




Ficha médica Ingresa, Actualiza, Elimina, Imprime cada registro de Ficha

Médica con su respectivo Historial.

Reportes médicos Generará reportes por Fecha para entregar en informes.


Oficios.

Trabajadora Social --> JENNIFER HONORES

Iniciar Sesión: Inicia Sesión en el departamento que le corresponda.

Ficha Social: Registra la Trabajadora Social cada adolescente del centro mediante informes.

Asignar taller: Se escogerá un taller para el adolecente.

Oficios

Reportes: Generar Reportes de Fichas sociales, talleres y baja de adolescente.

Salida de Adolescente: Dar de baja a un adolescente cuando se retira del centro.

392




Ficha Social Ingresa, Actualiza, Elimina, Imprime cada registro de Ficha

Social.

Taller Ingresa, Actualiza, Elimina, Imprime cada registro de

asignaciones de talleres para los adolescentes.


Oficios.

Reportes

Generar reportes por fecha de las Información sobre las

fichas Sociales, de talleres realizados y de salida de

adolescente.

Salida de

Adolescente

Ingresa, Actualiza, Imprime la información de los Baja de

Adolescente.

Porta Folio

Documents

Transcript of Porta Folio