Porta Folio
-
Upload
mariuxipaolazea -
Category
Documents
-
view
455 -
download
117
Transcript of 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
Semana N° 1 Día 2: Clase 2 ................................................................................................................... 27
Semana N° 1 Día 3: Clase 3 ................................................................................................................... 29
Semana N° 2 Día 1: Clase 4 ................................................................................................................... 33
UNIDAD II: BASE DE DATOS SQL Y ADO .NET ................................................................................... 42
Semana N° 3 Día 1: Clase 5 ................................................................................................................... 43
Semana N° 4 Día 1: Clase 6 ................................................................................................................... 51
UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C# .. 60
Semana N° 4 Día 2: Clase 7 ................................................................................................................... 61
Semana N° 4 Día 3: Clase 8 ................................................................................................................... 85
Semana N° 5 Día 1: Clase 9 ................................................................................................................... 93
Semana N° 5 Día 2: Clase 10 ............................................................................................................... 128
Semana N° 6 Día 1: Clase 11 ............................................................................................................... 152
Semana N° 6 Día 2: Clase 12 ............................................................................................................... 159
Semana N° 7 Día 1: Clase 13 ............................................................................................................... 166
Semana N° 7 Día 2: Clase 14 ............................................................................................................... 167
Semana N° 8 Día 1: Clase 15 ............................................................................................................... 168
Semana N° 8 Día 2: Clase 16 ............................................................................................................... 169
Semana N° 9 Día 1: Clase 17 ............................................................................................................... 176
Semana N° 9 Día 2: Clase 18 ............................................................................................................... 204
Semana N° 10 Día 1: Clase 19 ............................................................................................................ 239
Semana N° 10 Día 2: Clase 20 ............................................................................................................ 261
Semana N° 11 Día 1: Clase 21 ............................................................................................................ 276
Semana N° 11 Día 2: Clase 22 ............................................................................................................ 289
UNIDAD IV: PRESENTACIÓN DE RESULTADOS .............................................................................. 291
Semana N° 11 Día 3: Clase 23 ............................................................................................................ 292
ACTIVIDADES DE APRENDIZAJE INTRA Y EXTRA CLASE ............................................................ 303
UNIDAD I: INTRODUCCIÓN A .NET ...................................................................................................... 304
Actividad N° 1 .......................................................................................................................................... 305
Actividad N° 2 .......................................................................................................................................... 307
Actividad N° 3 .......................................................................................................................................... 313
Actividad N° 4 .......................................................................................................................................... 316
Actividad N° 5 .......................................................................................................................................... 326
UNIDAD II: BASE DE DATOS SQL Y ADO .NET ................................................................................. 334
UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y PROGRAMACIÓN EN C# 335
Actividad N° 6 .......................................................................................................................................... 336
Actividad N° 7 .......................................................................................................................................... 343
Actividad N° 8 .......................................................................................................................................... 356
Actividad N° 9 .......................................................................................................................................... 357
Actividad N° 10 ........................................................................................................................................ 363
UNIDAD IV: PRESENTACIÓN DE RESULTADOS .............................................................................. 379
EVALUACIONES PARCIALES................................................................................................................. 380
EXAMEN FINAL .......................................................................................................................................... 383
PROYECTO FINAL .................................................................................................................................... 384
SYLLABUS DE LA
ASIGNATURA
UNIVERSIDAD TÉCNICA DE MACHALA
FACULTAD DE INGENIERÌA CIVIL
CARRERA DE INGENIERÌA DE SISTEMAS
SYLLABUS ESTANDARIZADO
1.- DATOS GENERALES
Asignatura:
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
Investigaciones para profundizar
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
Investigaciones para profundizar los
temas.
Práctica de laboratorio.
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
Investigaciones para profundizar los
temas.
Práctica de laboratorio.
Elaboración de listas de verificación
acerca de las características de un
buen diseño de interface para el
usuario.
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
Investigaciones para profundizar los
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
Investigaciones para profundizar los
temas.
Práctica de Laboratorio.
5
Taller - Caso de Estudio
8.-
24/06/13
–
29/06/13
Operaciones
CRUD
3.5. Eliminar,
Modificar
Investigaciones para profundizar los
temas.
Práctica de Laboratorio.
Taller - Caso de Estudio
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
Investigaciones para profundizar los
temas.
Práctica de Laboratorio.
Taller - Caso de Estudio
5
10.-
15/07/13
–
20/07/13
Integridad 3.8. Validación
Integridad
llave principal
3.9.
Validaciones
llave ajena
Investigaciones para profundizar los
temas.
Práctica de Laboratorio.
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
Investigaciones para profundizar los
temas.
Práctica de Laboratorio.
Investigaciones para profundizar los
temas.
Práctica de Laboratorio.
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
Investigaciones para profundizar los
temas.
Práctica de Laboratorio.
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
Investigaciones para profundizar
los temas.
Práctica de Laboratorio.
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://www.youtube.com/watch?v=DHcyUM5Md94
10. DATOS DEL DOCENTE:
Mariuxi Paola Zea Ordoñez
Master en Educación Superior, Ingeniero en Computación y Ciencias de la Informática
Dirección: Calle San Martín # 4-14 entre Colón e Independencia, Pasaje
Teléfonos: 07-2915426, 07-2912042, 099-8228455, 0939036346.
Correo electrónico: [email protected], [email protected]
11. FIRMA DEL O LOS DOCENTES RESPONSABLES DE LA ELABORACIÓN DEL SYLLABUS
_______________________
Mariuxi Paola Zea Ordoñez
12. FECHA DE PRESENTACION:
Machala, Mayo del 2013
UNIVERSIDAD TÉCNICA DE MACHALA FACULTAD DE INGENIERÍA CIVIL
ESCUELA DE INFORMÁTICA Carrera de Ingeniería de Sistemas
AUTORRETRATO
Mi nombre es Jennifer Lisseth Honores Cun soy estudiante de la asignatura de
Programación I, actualmente curso el Quinto Semestre en la carrera de Ing. de Sistemas de
la Escuela de Informática de la Facultad de Ingeniería Civil de la Universidad Técnica de
Machala. Soy una persona responsable, puntual
Mis metas son llegar a convertirme un gran profesional de Ingeniería de Sistemas para así poder
ejercer mi profesión. Aprender más para así desarrollarme como persona, cumplir mis metas y
propuesta porque nada es imposible en esta vida ya que todo es posible solo hay que ponerle
fuerza de voluntad y teniendo como principal fuente de apoyo incondicional del docente Ing.
Mariuxi Zea.
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
UNIVERSIDAD TÉCNICA DE MACHALA
MISIÓN
La Universidad Técnica de Machala es una Institución reconocida en su área de influencia
formadora de profesionales, con capacidades científico- técnicas, éticos, solidarios, con
identidad nacional, que aporta, creativamente, a través de la docencia, investigación,
vinculación y gestión, a la solución de los problemas del desarrollo sostenible y
sustentable.
VISIÓN
La Universidad Técnica de Machala para el año 2013 es una institución acreditada, lidera
el desarrollo territorial, forma y perfecciona profesionales competentes, emprendedores,
innovadores, críticos y humanistas.
ESCUELA DE INFORMÁTICA
La Escuela de Informática fue creada mediante resolución No. 087/1995 (25 de
Octubre/1995)
La Carrera de Ingeniería de Sistemas fue creada mediante resolución No.
077/2001 (7 de mayo de 2001)
La Misión y Visión fueron aprobadas mediante resolución No. 452 del H. C. D. (Honorable
Consejo Directivo) del 13 de Diciembre del 2011.
MISIÓN
Formar profesionales en Ingeniería de Sistemas con capacidades científicas, técnicas,
tecnológicas y humanísticas, competitivos y comprometidos con el desarrollo sostenible y
sustentable del buen vivir.
VISIÓN
La carrera de Ingeniería de Sistemas para el año 2013 es la unidad acreditada y
líder en el desarrollo y transferencia de soluciones informáticas, acorde a los avances
científicos y tecnológicos.
PERFIL PROFESIONAL
El Ingeniero de Sistemas de la Universidad Técnica de Machala es un profesional con
espíritu empresarial, ético con características de creatividad, innovación, capacidad
investigativa, deseo permanente de trabajar, de aprender y perfeccionarse con amor
propio, con amplia sensibilidad social y con capacidad promotora de desarrollo de la
comunidad donde se desempeñe y que estará capacitado para:
Generar empresas 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
Semana N° 1 Día 2: Clase 2
CLASE N°: 2 PERÍODO 06/05/2013 al 10/05/2012
TIEMPO: 2 Horas
FECHA: 08/05/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD I: INTRODUCCIÓN A .NET
Contenidos
Historia del C#.
Ventajas de C#.
Objetivos de Desempeño
Aprender acerca de C#.
Conocer su Historia.
Competencia General
Historia del C#: Quien lo Creo, por que lo crearon.
Ventajas de C#: Es conveniente usarlo.
Datos Interesados Discutidos
Actividades Durante la Clase
- Se hizo una breve descripción de C# como quien lo creo y porque lo crearon y
sacar ventajas sobre este Lenguaje de Programación.
- Se hizo una actividad Intraclase sobre un caso de estudio.(Anexo Actividad)
Descriptores Analizados
Historia de C#
Ventajas de C#
Conceptos de los Descriptores Analizados
- Historia de C#
Hejlsberg lideró el proyecto de desarrollo de C#. Anteriormente, ya
participó en el desarrollo de otros lenguajes como Turbo Pascal, J++ y
Embarcadero Delphi.
- Ventajas de C#
Declaraciones en el espacio de nombres: al empezar a programar
algo, se puede definir una o más clases dentro de un mismo espacio
de nombres.
Tipos de datos: en C# existe un rango más amplio y definido de tipos de datos que los que
se encuentran en C, C++ o Java.
Reflexionar
¿Qué cosa fueron difíciles?
No se nos hizo difícil nada.
¿Qué cosas fueron fáciles?
Realizar la actividad Intraclase.
¿Por qué?
Gracias al Internet se nos hizo mucho más fácil encontrar sobre C#.
La actividad Intraclase fue muy interesante ya que lo hicimos en grupo y después
discutimos las respuestas con nuestros compañeros.
¿Qué Aprendí Hoy?
- Quien fue el creador de C# y cuáles son las ventajas de usar C#.
APUNTES DE CLASE
Semana N° 1 Día 3: Clase 3
CLASE N°: 3 PERÍODO 06/05/2013 al 10/05/2012
TIEMPO: 1 Horas
FECHA: 10/05/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD I: INTRODUCCIÓN A .NET
Contenidos
Evolución de los lenguajes de Programación.
Sistemas Automatizados
Objetivos de Desempeño
Conocer más los lenguajes de Programación.
Aprender sobre los sistemas automatizados que existen en la actualidad
Competencia General
Identifica los objetivos del lenguaje de programación C#
Datos Interesados Discutidos
Actividades Durante la Clase
- Se hizo una actividad Intraclase sobre la evolución de los lenguajes de
programación.(Anexo Actividad)
- La actividad intraclase se trato de hacer una espina de pescado de la
evolución.
- Se compartió con los compañeros las características que se habían descritos
en la espina de pescado.
- Se compartió respuestas sobre preguntas acerca de C#.
Descriptores Analizados
Creación del Lenguaje
Ensamblador
1 Jan 1950
Conceptos de los Descriptores Analizados
C# 1 Enero 1980
Reflexionar
¿Qué cosa fueron difíciles?
Al realizar la espina de pescado acerca de las fechas de creación del los lenguajes de programación.
En una de las preguntas: ¿En qué generación ubica a C#.
¿Qué cosas fueron fáciles?
Encontrar las características de los lenguajes de programación.
¿Por qué?
Al momento de buscar en el internet sobre las fechas de creación varían con relación a
fuentes bibliográficas.
La pregunta de qué en que generación poníamos a C# fue tal vez la más confusa ya
que si bien es cierto C# es un combinación de Java y C por lo cual estos lenguajes
estaban en tercera generación, pero al momento de ver sus características
automatizadas se analizo y debido a esto se la clasifico como cuarta generación.
Las características de los lenguajes de programación se encontraba de manera más
amplia en el internet.
¿Qué Aprendí Hoy?
- Se aprendió a analizar, describir en una espina de pescado la evolución de los
lenguajes de programación.
- Entendimos en el lenguaje de Programación C# es te cuarta generación.
APUNTES DE CLASE
En esta clase no hubo apuntes debido a que se trabajó una actividad Intraclase.
Semana N° 2 Día 1: Clase 4
CLASE N°: 4 PERÍODO 13/05/2013 al 17/05/2012
TIEMPO: 2 Horas
FECHA: 13/05/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD I: INTRODUCCIÓN A .NET
Contenidos
Introducción a Visual Estudio 2010
Creación de Proyectos en Visual Estudio 2010 con C#
Objetivos de Desempeño
Conocer la Interfaz de C#
Trabajar con Visual Estudio 2010 C#
Competencia General
Conoce la interfaz de C#
Aprende a trabajar en Proyectos de C#
Datos Interesados Discutidos
Actividades Durante la Clase
- Se aprendió a usar la herramienta de Visual Estudio C#.
- Se creó proyectos de C#: Console y Aplicación de Formulario.
- Se conoce propiedades, explorador de soluciones
- La Ing. Mariuxi Zea mediante el proyecto nos enseñaba todo lo antes
mencionado.
Descriptores Analizados
- Visual Estudio 2010
- C#
Conceptos de los Descriptores Analizados
Microsoft Visual Studio es un entorno de desarrollo integrado (IDE, por sus
siglas en inglés) para sistemas operativos Windows. Soporta varios lenguajes
de programación tales como Visual C++, Visual C#, Visual J#, y Visual Basic
.NET, al igual que entornos de desarrollo web como ASP.NET.
Versiones
Visual Basic Express Edition
Visual C# Express Edition
Visual C++ Express Edition
Visual J# Express Edition (Desapareció en Visual Studio 2008)
Visual Web Developer Express Edition (para programar en ASP.NET)
Visual F# (Apareció en Visual Studio 2010, es parecido al J#)*
Reflexionar
¿Qué cosa fueron difíciles?
No hubieron temas difíciles con relación a Visual Estudio 2010 C#
¿Qué cosas fueron fáciles?
Todo quedo entendido.
¿Por qué?
Debido a la Docente explicaba con proyector el alumno iba practicando en cada una de
sus computadores y todo era más sencillo.
¿Qué Aprendí Hoy?
- A crear Proyectos C# mediante: Console y aplicación de formulario.
APUNTES DE CLASE
1. Ingresar a Visual Estudio 2010
2. Nos aparecerá la pantalla principal de Visual Estudio 2010
3. La ventana de Explorador de soluciones es donde se van a almacenar todos los
formularios o clases de nuestro proyecto
4. En la ventana de cuadro de herramientas nos aparecerá todos los componentes que
podemos arrastrar pero solo si es aplicación de formulario
5. Haremos clic en crear nuevo proyecto
6. Nos 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
Semana N° 3 Día 1: Clase 5
CLASE N°: 5 PERÍODO 20/05/2013 al 24/05/2012
TIEMPO: 2 Horas
FECHA: 20/05/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD II: BASE DE DATOS SQL Y ADO .NET
Contenidos
Visual Estudio 2010 C#
Creación de Base de datos en Microsoft Acces
Base de datos en Visual Estudio 2010 C#
Objetivos de Desempeño
Aprender a hacer conexiones con una base de datos y Visual Estudio 2010
Trabajar con Visual Estudio 2010 C#
Competencia General
Aprende a trabajar en Proyectos de C#
Aprende a hacer Conexiones BD y C#
Datos Interesados Discutidos
Actividades Durante la Clase
- La Ing. Mariuxi Zea mediante el proyecto nos enseñaba a crear las conexiones
1. Creamos BD en Microsoft Acces
2. Creamos 5 registros
3. Revisamos las conexiones mediante código para Visual Estudio 2010
C#
4. Hicimos la conexión entre la herramienta de aprendizaje con la BD
Descriptores Analizados
- Visual Estudio 2010
- Base de datos en Visual Studio 2010
Conceptos de los Descriptores Analizados
Visual Studio proporciona herramientas para conectar la aplicación a datos de muchos orígenes diferentes, como bases de datos, servicios y objetos. Las conexiones a datos se
crean mediante programación (en código), como resultado de colocar los objetos de datos en un formulario o diseñador de componentes o a través de la finalización de uno de los asistentes de datos.
Reflexionar
¿Qué cosa fueron difíciles?
Al momento de crear conexiones de base de datos como programador uno debe saberse el código de conexión.
¿Qué cosas fueron fáciles?
Conexionar la BD de manera automática.
¿Por qué?
Debido a que uno no solo va a crear conexiones automáticas por que no todos los
lenguajes de programación no tienen esa facilidad uno aunque sea debe tener idea del
código para estas conexiones.
¿Qué Aprendí Hoy?
- Crear conexiones con el lenguaje de Programación C# y las Bases de datos.
APUNTES DE CLASE
1. Crearemos Conexiones
2. Primero Crearemos la base de datos en Access
2.1. Abrimos Microsoft Access
2.2. 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
Semana N° 4 Día 1: Clase 6
CLASE N°: 6 PERÍODO 27/05/2013 al 31/05/2012
TIEMPO: 2 Horas
FECHA: 27/05/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD II: BASE DE DATOS SQL Y ADO .NET
Contenidos
Visual Estudio 2010 C#
Creación de Base de datos en Microsoft Acces
Conexiones de Base de datos mediante Código
Objetivos de Desempeño
Aprender a hacer conexiones con una base de datos y Visual Estudio 2010
Trabajar con Visual Estudio 2010 C#
Competencia General
Aprende a trabajar en Proyectos de C#
Aprende a hacer Conexiones BD y C#
Datos Interesados Discutidos
Actividades Durante la Clase
- La Ing. Mariuxi Zea mediante el proyector nos enseñaba a crear las
conexiones
1. Creamos BD en Microsoft Acces
2. Creamos 5 registros
3. Revisamos las conexiones mediante código para Visual Estudio 2010
C#
4. Hicimos la conexión entre la herramienta de aprendizaje con la BD
Descriptores Analizados
- Visual Estudio 2010
- Base de datos en Visual Studio 2010
Conceptos de los Descriptores Analizados
Visual Studio proporciona herramientas para conectar la aplicación a datos de muchos orígenes diferentes, como bases de datos, servicios y objetos. Las conexiones a datos se crean mediante programación (en código), como resultado de colocar los objetos de datos en un formulario o diseñador de componentes o a través de la finalización de uno de los asistentes de datos.
Reflexionar
¿Qué cosa fueron difíciles?
Al momento de crear conexiones de base de datos como programador uno debe saberse el código de conexión.
¿Qué cosas fueron fáciles?
Trabajar en modo diseño y hacer las pruebas con las bases de datos.
¿Por qué?
Debido a que uno no solo va a crear conexiones automáticas porque no todos los
lenguajes de programación no tienen esa facilidad uno aunque sea debe tener idea del
código para estas conexiones.
¿Qué Aprendí Hoy?
- Crear conexiones con el lenguaje de Programación C# y las Bases de datos.
APUNTES DE CLASE
1. Crearemos Conexiones
2. Primero Crearemos la base de datos en Access
a. Abrimos Microsoft Access
b. Creamos una base de datos
c. 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#
Semana N° 4 Día 2: Clase 7
CLASE N°: 7 PERÍODO 27/05//2013 al 31/05/2012
TIEMPO: 2 Horas
FECHA: 29/05/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Windows Forms
Principales controles
Propiedades
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para
facilitar la posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta
cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la
información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y
mantenimiento de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto
CheckBox
CheckBoxList
ComboBox
DateTimePicker.
MonthCalendary.
Listbox
ListView
Descriptores Analizados
- CheckBox
- Check BoxList
- ComboBox
- DateTimePicker.
- MonthCalendary.
- ListBox
- ListView
Conceptos de los Descriptores Analizados
CHECKBOX
El control CheckBox de Windows Forms indica si una condición
establecida está activada o desactivada. Permite al usuario
seleccionar uno o más elementos marcando la casilla / casillas de
verificación correspondientes. Puede utilizar grupos de casillas para mostrar múltiples
opciones entre las cuales el usuario puede elegir una o más.
El control CheckBox puede mostrar una imagen, texto o ambas. Tiene dos propiedades
importantes:
CHECKEDLISTBOX
El control CheckedListBox de los formularios Windows
Forms hace casi todo lo que puede hacer un cuadro
de lista y puede mostrar una marca de verificación
junto a los elementos de la lista.
COMBOBOX
Representa un control de cuadro combinado de Windows.
Control DateTimePicker
Este control permite ingresar una fecha en una aplicación. El ingreso se realiza mediante un
calendario, que muestra el control o también digitando manualmente.
El usuario puede elegir la fecha dando Click en una caja que muestra un calendario de
donde se puede seleccionar un día determinado.
Una vez elegido el día y/o la hora, estos son mostrados en el área de texto.
Propiedades: - Format: Esta propiedad permite seleccionar el formato en el cual se debe
visualizar la fecha o la hora en el control. Si se selecciona Custom la fecha se mostrara con
el formato establecido en la propiedad CustomFormat.
Un ejemplo de formato que se puede establecer en el propiedad CustomFormat es (las letras
M están en mayúsculas):
CustomFormat dd-MM-yy hh:mm:ss.
Si se selecciona el formato Custom en la propiedad Format, el resultado será el siguiente:
06-May-10 - Value: Esta propiedad almacena la fecha y/o hora seleccionada en el control.
- MaxDate: Esta propiedad permite establecer la fecha máxima que se puede seleccionar en
el calendario. En forma predeterminada la fecha máxima es 31/12/9998.
- MinDate: Esta propiedad permite establecer la fecha mínima que se puede seleccionar en
el calendario. En forma predeterminada la fecha mínima es 01/01/1753.
-ValueChange: Tiene lugar cuando el valor del control cambia.
-VisibleChange: tiene lugar cuando cambia la visibilidad del control.
-Maximumsize: Especifica el tamaño máximo del control.
-Minumunsize: Tamaño mínimo del control.
-Modifiers: Indica el nivel de visibilidad del objeto.
-Rightoleft: Indica si el componente debe dibujar del componente.
-Rightoleftlayout: Indica si el diseño del control es de derecha a izquierda, cuando la
propiedad rightleft está establecida en yes.
-Showcheckbox: Determina si se muestra una casilla en el control.
-Showupdown: Indica si se muestra un cuadro de números en un lugar de una calendario
desplegable para modificar el valor del control.[/size].
CONTROL MONTHCALEDARY
El control MonthCalendar de Windows Forms muestra una intuitiva interfaz gráfica de usuario
para que los usuarios vean y establezcan información relativa a fechas. El control muestra un
calendario: una cuadrícula que contiene el número de días del mes, ordenado en columnas
debajo de los días de la semana con el intervalo de fechas seleccionado resaltado Para
seleccionar un mes diferente, puede hacer clic en los botones de fecha a los lados de la
leyenda del mes. A diferencia del control DateTimePicker similar, puede seleccionar más de
una fecha con este control. Para obtener más información sobre el controlDateTimePicker,
vea DateTimePicker (Control, formularios Windows Forms).
LISTBOX
ListBox es un control o componente de Visual Studio 2010, específicamente de tipo
Aplicación
de Windows Forms, de la cual forma parte de los controles comunes para crear
aplicaciones, se encuentra en el cuadro de herramientas y se utiliza para poder
insertar elementos, elegir elementos en forma de una lista del cual se van agregando o
se encuentran agregadas a este dicho componente.
Principales métodos para utilizar este control:
listBox.Items.Add() este método realiza el ingreso o el agregar de un elemento
a la cuadro del cual mientras cómo se van agregando se van insertado de manera
ordenada en el cuadro de texto.
listBox.Items.Clear() este método realiza el borrado o eliminación de todo los
elementos de la lista.
listBox.BackColor = Color.White esta parte de código se efectúa que el fondo
del cuadro donde se insertan los elementos de la lista tome un color que el
programador le asigne.
listBox.SelectedItem.Equals() este método realiza la comparación de
un elemento seleccionado dela lista realice o efectué cualquier tipo de instrucción
que se codifique, hasta el SelectedItem toma el elemento de la lista seleccionado.
LISTVIEW
El componente ListView, forma parte del cuadro de herramientas de Visual Studio, el
mismo que nos muestra una lista de elementos en diferentes tipos de vistas.
Se encuentran a disposición un total de 5 vistas diferentes para este comando, entre
las cuales tenemos: Details, List, LargeIcon, SmallIcon y Tile.
La utilidad de este componente radica en la visualización de información, ya que
permite mostrar una lista de elementos con texto, y además de forma opcional, con
un icono que identifique el tipo de elemento al que pertenecen.
La propiedad clave del Listview es items, ya que es la que contiene los elementos
que muestra el control.
Reflexionar
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los
talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
PASOS PARA REALIZAR UNA PRÁCTICA EN VISUAL STUDIO 2010, DONDE SE
MOSTRARA COMO UTILIZAR CONTROLES:
CHECHKBOX y CHECKEDLISTBOX
Se crea un Windows Forms
Arrastramos los controles desde
ToolBox hasta el formulario:
3 CheckBox
6 Button
1 CheckedListBox , quedando así:
Luego procedemos a asignarle propiedades a cada control del formulario:
Para cambiarle el nombre a los CheckBox seleccionamos:
checkBox1 y en Propiedades buscamos:
y escribimos
y escribimos
checkBox2 y en Propiedades buscamos:
y escribimos
y escribimos
checkBox3 y en Propiedades buscamos:
y escribimos
y escribimos
Para cambiarle el nombre a los Button seleccionamos:
button1 y en Propiedades buscamos:
y escribimos
y escogemos
y escribimos
button2 y en Propiedades buscamos:
y escribimos
y escribimos
button3 y en Propiedades buscamos:
y escribimos
y escribimos
button4 y en Propiedades buscamos:
y escribimos
y escribimos
button5 y en Propiedades buscamos:
y escribimos
y escribimos
button6 y en Propiedades buscamos:
y escribimos
y escribimos
Para asignarle los nombres al CheckedListBox, lo seleccionamos y en Propiedades buscamos:
y escribimos
damos clic en el icono que aparece a la derecha
Nos muestra este cuadro en la
cual escribimos los nombres
que tendrá cada CheckedListBox
y finalmente damos clic en
Aceptar.
Nos queda así el formulario, con los nombres asignado para cada uno de los controles
Ahora damos doble clic en:
Botón color y escribimos este código
Botón Apariencia y escribimos este código
Botón Contar y escribimos este código
Botón Desactivar Op2 y escribimos este código
Botón Revisar y escribimos este código
Botón seleccionar todos y escribimos este código
COMBOBOX
Se crea un Windows Forms
Arrastramos los controles desde ventana de Componentes quedando asi:
Textbox1= caja de texto
button 1 =fuente
button 1 = llenar
Combobox1 =
Button2 = botón deshabiitar
Button3 =boton cambiar color
Ejemplo 1:
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace ComboBoxEjemplo { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void button1_Click(object sender, EventArgs e) { //Agregar el texto que contiene el Texbox1 al ComboBox if (textBox1.Text != "") { if (comboBox1.Text == textBox1.Text) { MessageBox.Show("Escriba otra palabra"); } else { comboBox1.Items.Add(textBox1.Text); MessageBox.Show("Hay "+comboBox1.Items.Count+" elementos"); } } else
{ MessageBox.Show("El Campo está vacío"); } } private void comboBox1_SelectedIndexChanged(object sender, EventArgs e) { //Poner el texto seleccionado en el ComboBox en el TextBox2 textBox2.Text = ""+comboBox1.SelectedItem; } private void Form1_Load(object sender, EventArgs e) { } private void button4_Click(object sender, EventArgs e) { //Cambiar la fuente comboBox1.Font = new Font("Arial", 14); } private void button2_Click(object sender, EventArgs e) { if (button2.Text == "Deshabilitar") { //Deshabilitar la selección en el ComboBox comboBox1.Enabled = false; button2.Text = "Habilitar"; } else { //Habilitar la selección en el ComboBox comboBox1.Enabled = true; button2.Text = "Deshabilitar"; } } private void button3_Click(object sender, EventArgs e) { if (button3.Text == "Cambiar Color") { //Cambiar el color del ComboBox comboBox1.BackColor = Color.Blue; button3.Text = "Sin Color"; } else { //Cambiar el color del ComboBox comboBox1.BackColor = Color.White; button3.Text = "Cambiar Color"; } }
} } Ejemplo2 : using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace combobox { public partial class Form1 : Form { public Form1() { InitializeComponent(); } //Añadir instancias de la clase ComboItem //en nuestro comboBox. //luego modificar la propiedad DrawMode del ComboBox, y fijarla en OwnerDrawFixed. private void Form1_Load(object sender, EventArgs e) { comboBox1.Items.Add(new ComboItem("Ambato", 0)); comboBox1.Items.Add(new ComboItem("Cuenca", 1)); comboBox1.Items.Add(new ComboItem("Esmeraldas", 2)); } // en esta parte tengo el error que el nombre de la clase es ta mal o algo asi private void comboBox1_DrawItem(object sender, DrawItemEventArgs e) { ComboItem item = comboBox1.Items[e.Index] as ComboItem; e.DrawBackground(); if (item.ImageIndex >= 0 && item.ImageIndex < imageList1.Images.Count) e.Graphics.DrawImage(imageList1.Images[item.ImageIndex], new PointF(e.Bounds.Left, e.Bounds.Top)); e.Graphics.DrawString(item.Etiqueta, e.Font, new SolidBrush(e.ForeColor), new PointF(e.Bounds.Left + imageList1.ImageSize.Width + 1, e.Bounds.Top)); } } //Ahora necesitamos crear una clase muy simple que nos permita almacenar //la etiqueta de los elementos del Combo y el índice de la imagen en el ImageList. class ComboItem { private int _imageIndex;
private string _etiqueta; public string Etiqueta { get { return _etiqueta; } set { _etiqueta = value; } } public int ImageIndex { get { return _imageIndex; } set { _imageIndex = value; } } public ComboItem(string etiqueta, int imageIndex) { this.Etiqueta = etiqueta; this.ImageIndex = imageIndex; } public override string ToString() { return Etiqueta; } } }
MONTHCALENDARY
Mostrar más de un mes en el control MonthCalendar.
Una vez creada la Aplicación de Windows Foms, arrastramos hacia el formulario el control
MonthCaledary.
Hacemos doble clic sobre el control MonthCalendary, y nos aparece la ventana de código del
formulario con sus respectivos controles.
Nos posicionamos en el método monthCalendary1, escribimos la siguiente línea de código.
monthCalendar1.CalendarDimensions = new System.Drawing.Size(2, 2);
Resultados:
Al iniciar la depuración del programa se ejecuta así:
Debe hacer clic en la pestaña de cambiar el mes y se muestra de la siguiente manera:
Y podemos observar que el tamaño del calendario es de 2x2 como lo indica el código.
Mostrar en negrita una fecha(s) seleccionada(s).
Una vez que seleccionamos el control MonthCalendary, elegimos la propiedad
MonthlyBoldedDates.
Nos aparece la siguiente ventana en la cual debemos hacer clic en Agregar.
Seleccionamos la fecha que deseamos que se ponga en negrita y damos clic en Aceptar.
Como resultado podemos observar que la fecha seleccionada se encuentra en negrita:
Mostrar los números de semana a la izquierda de cada semana.
Haciendo doble clic sobre el control, posesionándonos sobre el método del control
monthCalendary escribimos la siguiente sentencia:
this.monthCalendar1.ShowWeekNumbers = true;
Como resultado podemos observar el número de la semana ubicado en la parte izquierda:
Ejemplos de cómo utilizar DateTimePicker:
Mostrar fechas: Usar los controles MonthCalendar y DateTimePicker.
Cómo: Mostrar la fecha y la hora en una aplicación
Para mostrar una fecha mediante un control MonthCalendar:
En el menú Archivo, haga clic en Nuevo proyecto.
Aparecerá el cuadro de diálogo Nuevo proyecto.
Haga clic en Aplicación de Windows Forms y, a continuación, en Aceptar.
Agregue un control Label al formulario, con el nombre predeterminado Label1.
Agregue un control MonthCalendar al formulario, con el nombre
predeterminado MonthCalendar1.
Haga doble clic en el formulario para agregar el controlador predeterminado del
evento Load en el Editor de código y agregue el siguiente código. Este código asigna la fecha
seleccionada (la fecha de hoy) a la propiedad Text de la etiqueta en el formato de fecha corto.
this.label1.Text =
this.monthCalendar1.SelectionRange.Start.ToShortDateString();
Cree un controlador del evento DateChanged para el control MonthCalendar1. Para ello, sólo
tiene que hacer doble clic sobre el control en el diseñador.
Agregue el código siguiente al controlador del evento MonthCalendar_DateChanged. Este
código establece la etiqueta en la fecha seleccionada, pero esta vez en formato de fecha largo
this.label1.Text =
this.monthCalendar1.SelectionRange.Start.ToShortDateString();
Presione F5 para ejecutar el programa.
Cuando el formulario se abra, cambie la fecha haciendo clic en una fecha en el
control MonthCalendar.
Compruebe que la fecha se haya actualizado en la etiqueta.
Para mostrar la hora con el control DateTimePicker:
Agregue un control DateTimePicker al formulario, con el nombre
predeterminado DateTimePicker1.
Haga doble clic en el diseñador para cambiar al Editor de código.
Agregue el código siguiente al controlador del evento Form1_Load. Este código establece el
formato d-el control para mostrar una hora, en lugar de una fecha, y permite al usuario cambiar
la hora que se muestra.
Agregue un control Button al formulario y cambie las propiedades siguientes.
Propiedad Valor
Name horaActual
Text Hora actual
Agregue el código siguiente para establecer la hora en la hora actual.
this.dateTimePicker1.Value = DateTime.Now;
Presione F5 para ejecutar el programa.
Cuando el formulario se abra, cambia la hora seleccionando la hora, minuto o segundo y haga
clic en la flecha arriba o abajo.
Haga clic en Hora actual para restablecer el control a la hora actual.
LISTBOX
La aplicación se basa en insertar nombres de colores, de los cuales se
insertaran mediante un botón que realice esta acción, también se podrá realizar
que mientras se selecciona un color se ejecuta la instrucción de cambiar el
fondo de la listBox además de limpiar o eliminar los elementos de dicha lista.
Insertar elementos:
- Para insertar elementos en la caja de texto se escribe el nombre del color a
insertar.
LISTVIEW
Ejemplos:
Usamos para este ejemplo, un ListView con vista tipo detallada, para mostrar la
información guardada en él.
Semana N° 4 Día 3: Clase 8
CLASE N°: 8 PERÍODO 27/05/2013 al 31/05/2012
TIEMPO: 1 Horas
FECHA: 31/05/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Windows Forms
Principales controles
Propiedades
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para
facilitar la posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta
cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la
información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y
mantenimiento de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto
MaskedTextBox
NotifyIcon
1 Página Oficial: (http://librosweb.es/javascript/capitulo_8/tooltip.html)
Tooltip.
Descriptores Analizados
- MaskedTextBox
- NotifyIcon
- Tooltip.
Conceptos de los Descriptores Analizados
MASKEDTEXTBOX
Constructor
MaskedTextBox Sobrecargado. Inicializa una nueva instancia de la
clase MaskedTextBox.
NOTIFYICON
Según (MSDN, página oficial de Windows) dice: “El componente NotifyIcon de
formularios Windows Forms muestra iconos en el área de notificación de estado de la barra
de tareas para procesos que se ejecutan en segundo plano y que, de otro modo, no tendrían
interfaz de usuario‖.
Como su propio nombre lo indica el notifyicon, es un icono de notificación que tiene sus
métodos, eventos y propiedades las cuales pueden ser modificadas ya sea desde la ventana
de propiedades o por medio de la programación correspondiente.
Tooltip
Según un blog ubicado en la página de "librosweb" 1dice: ―Los tooltips son pequeños
recuadros de información que aparecen al posicionar el ratón sobre un elemento.
Normalmente se utilizan para ofrecer información adicional sobre el elemento seleccionado o
para mostrar al usuario pequeños mensajes de ayuda".
Cuando utilizamos un ToolTip en Visual Studio, solo puede ser utilizado directamente sobre
un control de Windows Forms, por ejemplo un TextBox, una Label, un Button, etc., ya que
solo acepta dos parámetros; el control y la cadena de Texto que mostrará.
Reflexionar
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los
talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
Practica con:
MASKEDTEXTBOX
1.-Para realizar este ejercicio empezamos creando un formulario WindowsForms
2.- Luego nos dirigimos al cuadro de herramientas seleccionamos el MaskedTextBox y lo
arrastramos al Formulario.
3.- También arrastramos el Control Label, para añadir etiqueta a los MaskedtextBox que
colocaremos a continuación
4.- Luego añadimos la máscara con la propiedad Mask o click en la flechita del MaskedTextBox
como veremos a continuación.
5.-Luego podemos dar click en ―Establecer máscara‖ o en Mask y aparecerá la siguiente
ventana. Y podremos elegir cualquier formato de máscara.
6.-Luego realizamos el mismo procedimiento para el resto de MaskedTextBox y tendremos el
siguiente formulario
7.- Agregamos un toolTip para en este caso mostrar un mensaje al momento de que no sea
válido el dato ingresado.
8.- Con esto terminamos la parte gráfica y ahora procedemos al código de los MaskedTexBox.
Al hacer doble click en cada MaskedTextBox nos muestra la línea del evento void maskedTextBox1_MaskInputRejected(object sender, MaskInputRejectedEventArgs e) { toolTip1.ToolTipTitle = "entrada incorrecta"; toolTip1.Show("solo registrar datos desde (0-9)", maskedTextBox1, maskedTextBox1.Location, 2000);
PRACTICA CON:
NOTIFYICON y TOOLTIP
Pasos:
1. Ingresamos a Visual Studio y se crea un nuevo proyecto.
2. En propiedades de formulario cambiamos de titulo en Text.
3. Para que el proyecto se lleva a cabo necesitamos 4 objetos: Un Boton, el NotifyIcon,
ContextMenuStrip y el ToolTip
4. Colocamos los componentes Boton, y ContextMeuStrip donde nosotros deseemos en la
ventana
5. Hacemos Clic en ContextMenuStrip y escribimos las opciones que aparecerán cuando este
la ventana minimizada
6. Escribimos las opciones salir, restaurar y ocultar
7. Ahora en el notifyIcon damos clic sobre una flechita superior que tiene y nos pedirá
escoger un icono el cual lo podemos elegir dependiendo de la ruta donde tengamos el
icono deseado.
8. En Propiedades de NotifyIcon modificamos de la siguiente manera:
9. Ahora vamos a empezar a darle código a nuestro Programa
10. Empezamos escribimiendo un método llamado Minimizar
11. Lo llamamos del Botón con el método
Minimizar()
12. Ingresamos el código siguiente en Restaurar.
this.Show()
this.WindowState = FormWindowState.Normal
13. En La Sección Ocultar ingresamos el siguiente codigo:
this.WindowState = FormWindowState.Minimized
this.Hide()
14. En Salir ingresamos el siguiente código:
NotifyIcon1.Visible = False
15. Creamos un método Tip() con el código que se muestra a continuación en el formulario.
ToolTip1.SetToolTip(Button1, "EL MOUSE ESTA SOBRE ESTE BOTON")
Semana N° 5 Día 1: Clase 9
CLASE N°: 9 PERÍODO 03/06/2013 al 07/06/2012
TIEMPO: 2 Horas
FECHA: 03/06/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Windows Forms
Principales controles
Propiedades
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la
posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta
cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento
de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto
PictureBox
ProgressBar
RadioButton
TreeView
NumericUpDown
GroupBox
TabControl
MenuStrip
ContextMenuStrip
Descriptores Analizados
- PictureBox
- ProgressBar
- RadioButton
- TreeView
- NumericUpDown
- GroupBox
- TabControl
- MenuStrip
- ContextMenuStrip
Conceptos de los Descriptores Analizados
PictureBox
PictureBox es un control de Visual Studio 2010, específicamente de tipo Aplicación de
Windows Forms, la cual forma parte de los controles comunes para crear aplicaciones, lo
podemos encontrar en el
cuadro de herramientas y la
utilizamos para mostrar
imágenes.
PROPIEDADES
Nombre Descripción 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
Nombre Descripción Nombre Descripción
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
Nombre Descripción Nombre Descripción
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:
Principales propiedades del GroupBox:
Backcolor: sirve para colocarle un color de fondo al control.
BackgroundImage: sirve para colocar una imagen de fondo al control.
BackgroundImageLayout: sirve para ajustar la imagen colocada en el control.
Cursor: sirve para elegir el tipo de cursor que se va a visualizar en el control.
Enabled: sirve para bloquear o desbloquear al control de acuerdo al valor booleano que se le
dé.
Font: sirve para asignarle un tipo y tamaño de letra al control.
Forecolor: sirve para cambiar el color de letra en el control.
Text: sirve para colocarle un título al control.
Tabcontrol
Ventanas TabControl es un control útil que permite mostrar varios cuadros de diálogo de
pestañas en una única forma de cambiar entre las pestañas. Una ficha actúa como otra forma
que puede albergar otros controles.
MenuStrip
Añade una barra de menú en su programa de Windows Forms. Con este control, se añade un
área de menú y, a continuación añadimos los menús predeterminados o crear menús
personalizados directamente en Visual Studio. Se demuestra la MenuStrip y ofrecemos algunos
consejos de uso.
Entre las principales características de este objeto tenemos las siguientes:
Crear fácilmente menús personalizados y comúnmente empleados compatibles con la interfaz
de usuario avanzada y con las características de diseño, como la alineación y orden de texto e
imágenes, operaciones de arrastrar y colocar, MDI, desbordamiento y modos alternativos de
acceso a comandos de menú.
Compatibilidad con el comportamiento y aspecto típico del sistema operativo.
Controlar de forma coherente los eventos para todos los contenedores y los elementos
contenidos, al igual que controla los eventos para otros controles.
Imagen
Un elemento de menú puede mostrar una imagen, además de un título textual. Debido a varios
casos de control diferentes a menudo utilizan la misma imagen, las imágenes no se almacenan
en la instancia del control en sí. Por el contrario, las imágenes se almacenan en un archivo de
recursos. Imágenes se añaden a un archivo de recursos utilizando el cuadro de diálogo
Seleccionar recurso se muestra en la siguiente figura.
Ilustración 1 Asignación de Iconos a ítems
ContextMenuStrip
Los menús contextuales aparecen en la posición del mouse (ratón) cuando el usuario hace clic
con el botón secundario. Los menús contextuales proporcionan opciones para el área de cliente
o el control en la ubicación del puntero del mouse.
Reflexionar
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los
talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
Practica:
PICTUREBOX 1. Creamos un nuevo proyecto
2. Luego agregamos los componentes que se va a utilizar del toolbox hacia el
formulario.
2 Button 1 PictureBox
3 Luego procedemos a asignarle propiedades a cada control del formulario:
Para cambiarle el nombre a los Button seleccionamos:
button1 y en Propiedades buscamos:
y escribimos
y escribimos
Button2 y en Propiedades buscamos:
y escribimos
y escribimos
Picturebox1 y en Propiedades buscamos:
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:
Para cambiarle el nombre a los Button seleccionamos:
button1 y en Propiedades buscamos:
y escribimos
y escribimos
button2 y en Propiedades buscamos:
y escribimos
y escribimos
button2 y en Propiedades buscamos:
y escribimos
textBox1 y en Propiedades buscamos:
y escribimos
3. Ahora procedemos a codificar los eventos:
Practica:
RADIOBUTTON
1. Repetimos los pasos 1 y 2 ya descritos anteriormente.
2. Luego procedemos a asignarle propiedades a cada control del formulario:
Para cambiarle el nombre a los RadioButton seleccionamos:
Radiobutton1 y en Propiedades buscamos:
y escribimos
y escribimos
Radiobutton2 y en Propiedades buscamos:
y escribimos
y escribimos
Button1 y en Propiedades buscamos:
y escribimos
y escribimos
Label1 y en Propiedades buscamos:
y escribimos
4. Ahora procedemos a codificar los eventos:
PRACTICA CON:
TREEVIEW
A continuación se desarrollara un ejemplo haciendo uso del TreeView:
1. Se crea un nuevo proyecto de tipo Aplicación de Windows Forms.
2. Se arrastra hacia la ventada del diseñador el control TreeView.
3. Se arrastra hacia la ventana del diseñador un ImageList para poder almacenar los iconos del
TreeView.
4. Agregamos imágenes al ImageList, desde la ventana de Tareas del ImageList seleccionamos
Elegir imágenes y rápidamente se nos presentara el Editor de la colección Imágenes en donde
agregaremos las imágenes que deseemos dando clic en el botón Agregar.
5. Desde la ventana de Tareas de TreeView le agregamos el ImageList
6. Desde la ventana de Tareas de TreeView elegimos la opción Editar nodos, en donde tendremos
el Editor de TreeNode, en donde tendremos la opción de agregar nuevos nodos de tipo raíz y
secundario según sea la aplicación y al mismo tiempo desde el menú de propiedades se podrá
colocar una imagen de ImageList al Nodo, una ves agregados los nodos deseado aceptamos para
guardar los cambios
7. Agregamos tres botones a nuestra ventana, los cuales cumplirán las funciones de Agregar
Nodo, Eliminar Nodo y Eliminar Node
8. Procedemos a codificar los eventos para cada uno de los botones.
9. Ejecutar la aplicación y comprobar resultados.
PRACTICA CON:
NUMERICUPDOWN
Ejemplo de aplicación del NumericUpDown y algunas de sus propiedades:
1. Se crea un nuevo proyecto de tipo Aplicación de Windows Forms.
2. Se arrastra hacia la ventada del diseñador el control NumericUpDown.
3. Desde la ventana de propiedades modificamos los valores del NumericUpDown del tal
manera que establecemos un máximo, un mínimo y un incremento.
4. Agregamos 3 botones que nos permitirán capturar las propiedades actuales del
NumericUpDown como máximo, mínimo e incremento, otro para poder limpiar los TextBoxs y
otro para poder agregar nuevos valores a las propiedades y 4 Textboxs.
5. Codificamos los eventos de los botones.
6. Ejecutar la aplicación y verificar resultados.
PRACTICA CON:
CONTEXTMENUSTRIP
Pasos para usar un ContextMenuStrip:
Abrimos el visual estudio 2010
Creamos un nuevo proyecto
De la barra de herramientas arrastramos textbox,
label y botones hasta que nos quede el formulario
de esta forma
A continuación vamos al cuadro de herramientas y en ―Menús y barras de Herramientas‖
seleccionamos la opción ContextMenuStrip
Una ves seleccionada la opcion lo insertamos en el formulario, y nos aparecera la
herrameinta seleccionada. Le ponemos el nombre en el recuadro que dice ―Escribe aqui‖
según lo que deseamos hacer en este menu.
En mi caso mi programa es sobre la suma, resta, multiplicacion y division de dos numeros.
Para poder activar el menú median otro objeto, lo que tenemos que hacer es seleccionar el
objeto en nuestro caso es el botón ―Elija lo que desea calcular‖, y en las propiedades
buscamos la propiedad siguiente:
Al hacer esto
estamos diciendo que al darle clic derecho al botón se
nos presente el ContextMenuStrip con las opciones que
pusimos en los pasos anteriores.
Lo siguiente que haremos es programar cada una de las opciones, esto lo hacemos de la
misma forma que programar en un botón.
Le damos doble clic en la opción para que nos aparezca la ventana de código.
CÓDIGO DEL EJERCICIO SOBRE ContextMenuSTrip
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace WindowsFormsApplication1 { public partial class Form1 : Form { public Form1() { InitializeComponent();
} private void cerrarToolStripMenuItem_Click(object sender, EventArgs e) { if (textBox1.Text == "" || textBox2.Text == "") { MessageBox.Show("Tiene que llenar todos los campos"); } else { int numerouno = Convert.ToInt32(textBox1.Text); int numerodos = Convert.ToInt32(textBox2.Text); int resp = (numerouno + numerodos); textBox4.Text = Convert.ToString(resp); } } private void rESTAToolStripMenuItem_Click(object sender, EventArgs e) { if (textBox1.Text == "" || textBox2.Text == "") { MessageBox.Show("Tiene que llenar todos los campos"); } else { int numerouno = Convert.ToInt32(textBox1.Text); int numerodos = Convert.ToInt32(textBox2.Text); int resp = (numerouno - numerodos); textBox3.Text = Convert.ToString(resp); } } private void mULTIPLICACIONToolStripMenuItem_Click(object sender, EventArgs e) { if (textBox1.Text == "" || textBox2.Text == "") { MessageBox.Show("Tiene que llenar todos los campos"); } else { int numerouno = Convert.ToInt32(textBox1.Text); int numerodos = Convert.ToInt32(textBox2.Text); int resp = (numerouno * numerodos); textBox5.Text = Convert.ToString(resp); } } private void dIVICIONToolStripMenuItem_Click(object sender, EventArgs e)
{ if (textBox1.Text == "" || textBox2.Text == "") { MessageBox.Show("Tiene que llenar todos los campos"); } else { int numerouno = Convert.ToInt32(textBox1.Text); int numerodos = Convert.ToInt32(textBox2.Text); int resp = (numerouno / numerodos); textBox6.Text = Convert.ToString(resp); } } private void lIMPIARDATOSToolStripMenuItem_Click(object sender, EventArgs e) { textBox1.Clear(); textBox2.Clear(); textBox3.Clear(); textBox4.Clear(); textBox5.Clear(); textBox6.Clear(); textBox1.Focus(); } private void sALIRToolStripMenuItem_Click(object sender, EventArgs e) { this.Close(); } private void button2_Click(object sender, EventArgs e) { } } }
PRACTICA CON:
GROUPBOX
El presente formulario ha sido desarrollado para indicar las propiedades más
importantes o más relevantes de este contenedor llamado GroupBox:
Lo primero que debemos hacer es crear un nuevo Proyecto: Windows Forms, arrastrar el
control o contendor GroupBox y colocarlo en el formulario.
Modificamos la fuente, el tamaño y el color del texto en las propiedades: Font y forecolor.
En la propiedad Font nos aparecerá un ventanita como esta para la modificación antes
dicha.
Mientras que en la propiedad forecolor nos aparcera los diferentes colores que le
podemos colocar al contenedor.
Ahora para poderle cambiar el color de fondo al contendor nos vamos a la propiedad
BackColor y nos aparecerá un cuadro similar al anterior y seleccionamos el color que
deseemos.
Lo siguiente que debemos hacer es agregar los componentes al contendor GroupBox,
añadiendo cajas de texto, etiquetas y un botón, de tal manera que nos queda de esta
forma:
En la parte inferior de la ventana, agregamos 6 etiquetas y 2 botones. A las etiquetas le
borramos el texto de tal manera que esa propiedad Text quede vacía, mientras que a los
botones les colocamos en la propiedad Text: Desbloquear y Cancelar, respectivamente.
Una vez que nos haya quedado el formulario de esa forma, procedemos a darles
funciones a los botones que existen en dicho formulario:
Botón enviar
El botón enviar nos va a servir para enviar la información o el texto que se encuentra
dentro del GroupBox a la parte inferior de la ventana donde se encuentran las etiquetas
que no contienen ningún texto.
Además cabe recalcar que si no se llenan todas las cajas de texto la información no se
llenara en la parte inferior y además mostrara un mensaje de error.
Para colocarle el código al botón y me realice las funciones antes mencionadas,
procedemos a darle doble clic al botón y escribimos dentro del método lo siguiente.
Botón Desbloquear
El botón desbloquear va a permanecer bloqueado y una vez que se encuentre
desbloqueado va a cumplir la función de desbloquear el GroupBox y sus componentes
que están adentro una vez que el botón cancelar lo haya bloqueado. Además de limpiar
las cajas de texto del GroupBox. Así mismo le damos doble clic a dicho botón y le
colocamos el siguiente código:
Botón Cancelar
El botón cancelar va a servir para bloquear el contenedor GroupBox y sus componentes
que se encuentran adentro. Y también dejar en blanco las etiquetas que se encuentran en
la parte inferior de la ventana, además de desbloquear el botón desbloquear.
Para que el botón cumpla dichas funciones le damos doble clic y escribimos el siguiente
código en el método:
PRACTICA CON:
TABCONTROL
¿Cómo Crear un TabControl en mi Ventana?
Una vez creado nuestro proyecto, nos ubicamos en el cuadro de herramientas y buscamos la
opción TabControl.
Una vez ubicados en la opción TabControl la arrastramos hacia la ventana donde deseamos usar
el TabControl una vez arrastrado nos quedara algo más o menos así:
Por Default nos aparecerá dos pestañas con el nombre TabPage1 y TabPage1, y es ahí cuando
surgen las interrogantes, ¿Podre poner o quitar pestañas a mi TabControl?, ¿Podre cambiar el
nombre de mis pestañas de mi TabControl?, Pues la respuesta es que sí. Procederé a explicar
cómo agregar o quitar pestañas de mi TabControl asi como a cambiar el nombre de las pestañas
de mi tabControl de la misma manera revisaremos las demás propiedades.
Agregar y Quitar pestañas de mi TabControl
Lo explicare gráficamente como con código, así que gráficamente para agregar pestañas o
quitarlas le damos clic a la flecha que se encuentra en la parte superior del TabControl y se nos
despliegan las opciones agregar y quitar ficha dándole clic se procederá agregar o quitar según
como nosotros lo manejemos.
Ahora procederé a eliminar las pestañas del TabControl y agregare dos botones donde el uno
tenga como texto agregar pestaña y el otro eliminar pestaña, nos quedara algo más o menos así:
Entonces comenzamos a programar los eventos de los botones respectivamente cuando yo
presione agregar pestaña se me agregué una pestaña a mi tabControl y así respectivamente con
el eliminar pestaña.
Nos ubicaremos en el modo programador, como lo hacemos damos doble clic sobre la ventana y
nos aparecerá el código y entonces debemos escribir la librería:
using System.Collections; //Es la que nos permite manejar las pestañas en modo de arrayList
Declaramos un arrayList yo utilizare el nombre pestana el objeto pestana se encarga de
almacenar cada pestaña, con esto tendremos control sobre la pestaña a tenerla almacenada y el
código para declarar un arrayList quedaría así: ArrayList pestana = newArrayList();
Lo siguiente que realizare será declarar una variable int con el nombre contarPestana, la variable
contarPestana, lleva un control sobre la cantidad de pestaña que llevamos almacenado en el
objeto pestana, de esta manera podemos eliminar pestaña por medio de índice de esta variable y
la sintaxis quedaría así:
int contarPestana = 0;
Ahora voy a crear el método crearPestana() como su nombre indica es para crear pestaña en
tiempo de ejecución, en este método procederé añadir lo siguiente:
Private void crearPestana()
{
// Creo una nueva Pestaña
TabPage nuevaPestana = new TabPage("Nueva Pestaña " + contarPestana); // Creamos una
nueva pestaña
pestana.Add(nuevaPestana); // cada pestaña creada los añadimos en un arraylist
tabControl1.TabPages.Add(nuevaPestana); //cargamos la pestaña en el control
contarPestana++; //variable que lleva el control de la cantidad de pestaña creada
tabControl1.SelectedTab = nuevaPestana; //seleccionamos la pestaña
}
Lo que realizo en el código es primero crear un TabPage que no es más que una pestaña por
medio de constructor de objeto le pasamos en título que queremos que tenga la pestaña. Una vez
que eh creado una pestaña guardo esa pestaña con su título en el ArrayList pestana luego cargo
esa pestaña en el control TabControl1 (es el nombre de mi tabControl). Incremento la variable
contarPestana, luego marco la pestaña recién creada como seleccionada mediante las
propiedades de TabControl.SelectedTab le paso la pestaña recién creada.
Luego nos vamos al modo diseñador y damos doble clic sobre el botón crear pestaña y dentro del
evento coloco el nombre del método, ósea llamo al método crearPestana, y tendremos algo más o
menos así:
Ejecutando podremos observar que nuestro trabajo puede hacer esto:
Ventana de inicio (ventana como se ejecuta inicialmente)
Una vez presionando agregar pestana (procedí a agregar 2 pestañas)
Procederé a trabajar con el eliminar pestaña, tendremos un código así:
private void EliminarPestana()
{
TabPage vacio = tabControl1.SelectedTab;
pestana.Remove(vacio);
tabControl1.TabPages.Remove(vacio);
contarPestana--;
}
Como se ve el código del método es bastante corto, primero creamos un TabPage vació, y le paso
la pestaña que tengo seleccionada para eliminar. Luego elimino las pestaña de las lista, y también
de TabControl1 y por últimos restamos un -1 a la variable contarPestana.
El código mejorado poniéndole al eliminar pestaña un controlador de que cuando no se agregado
pestañas y se quiera eliminar mostrar un mensaje, entonces el código completo quedaría así:
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; using System.Collections; //Es la que nos permite manejar las pestañas en modo de arrayList namespace WindowsFormsApplication1 { public partial class Form1 : Form { ArrayList pestana = new ArrayList(); int contarPestana = 0; public Form1() { InitializeComponent(); } private void crearPestana() { // Creo una nueva Pestaña TabPage nuevaPestana = new TabPage("Nueva Pestaña " + contarPestana); // Creamos una nueva pestaña pestana.Add(nuevaPestana); // cada pestaña creada los añadimos en un arraylist tabControl1.TabPages.Add(nuevaPestana); //cargamos la pestaña en el control contarPestana++; //variable que lleva el control de la cantidad de pestaña creada tabControl1.SelectedTab = nuevaPestana; //seleccionamos la pestaña } private void EliminarPestana() { if (contarPestana <= 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:
Semana N° 5 Día 2: Clase 10
CLASE N°: 10 PERÍODO 03/06/2013 al 07/06/2012
TIEMPO: 2 Horas
FECHA: 05/06/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Windows Forms
Principales controles
Propiedades
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para
facilitar la posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta
cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la
información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y
mantenimiento de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto
Tool strip
Status strip
Timer
ErrorProvider
ColorDialog
FolderBrowserDialog
OpenFileDialog
SaveFileDialog
Descriptores Analizados
- Tool strip
- Status strip
- Timer
- ErrorProvider
- ColorDialog
- FolderBrowserDialog
- OpenFileDialog
- SaveFileDialog
Conceptos de los Descriptores Analizados
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
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 #.
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
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los
talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
Práctica con la herramienta:
TOOL STRIP
Se crea un Windows Forms
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
Práctica con la herramienta:
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)
{
toolStripProgressBar1.Value = 0;
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)
{
toolStripProgressBar1.Value = 0;
timer1.Enabled = true;
timer1.Interval = 50;
toolStripStatusLabel1.Text = "Cargando nuevamente...";
}
private void limpiarBarraToolStripMenuItem_Click(object sender, EventArgs e)
{
toolStripProgressBar1.Value = 0;
toolStripStatusLabel1.Text = "Barra de progreso";
}
}
}
Práctica con la herramienta:
TIMER
Practica: Crear un semáforo en C# utilizando el componente Timer:
Para Iniciar el semáforo
Hay que darle clic en el botón que dice encender el cual va a habilitar los dos botones siguientes de
―Detener‖ y ―Apagar‖ y bloqueara al botón ―Encender‖ ya que no se puede encender el semáforo si ya
esta encendido además de poner en el label un mensaje indicando que el semáforo se encuentra activo.
Para pausar el semáforo
Se da clic en el botón ―Detener‖ el cual una vez presionado pausara el timer que se encuentra activado
y el botón cambiara el nombre a ―Reanudar‖, cuando se de clic en ―Reanudar‖ activara de nuevo el
temporizador del timer.
Para Apagar el semáforo
Dar clic en el último botón que se llama ―Apagar‖ la función principal de este botón es finalizar el timer
con un método que se llama Stop(), desactivando los demás botones y dejando activado solo el botón
de ―Encender‖ activado.
¿Cómo funciona el timer en este programa?
El uso del timer en este programa es que en cada intervalo diferente de tiempo, hacer el el picturebox
cargue una imagen diferente del semáforo, por medio de un case de una forma infinita hasta que el
usuario de clic en el botón ―Apagar‖ para que finalice el timer con el método Stop(); todo el proceso se
lo debe realizar en el único método que tiene el timer que se llama Tick
Práctica con la herramienta:
ERROR PROVIDER
Practica: Validar un formulario para que el usuario no pueda dejar casilleros vacíos
Cuando se da clic en comprobar lo que hace el programa es comprobar si cualquiera de los tres textBox
estén vacios y si en caso de estarlos nos saldrá una notificación indicando en que componente se
encentra el error:
La forma para controlar esto es muy sencilla: hay que validar cada textBox utilizando un ―if‖ y en caso
que se cumpla la condición dada se utiliza el componente error proveer utilizando su método que se
llama setError en el que se envían dos parámetros, el primero es el componente donde se encuentra el
error y el segundo es una mensaje que queramos que se muestre cuando pasemos el mouse sobre el la
notificación de error.
Práctica con la herramienta:
COLORDIALOG
En el siguiente ejemplo, se aplicaran las funciones que nos brinda el Colordialog:
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:
private void button1_Click(object sender, EventArgs e)
{
if (colorDialog1.ShowDialog() == DialogResult.OK)
//si el dialogo es abierto se consulta si el boton aceptar fue presionado
{
textBox1.ForeColor = colorDialog1.Color;
//cambia de color el texto del textbox
}
}
private void button2_Click(object sender, EventArgs e)
{
if (colorDialog1.ShowDialog() == DialogResult.OK)
{
textBox1.BackColor = colorDialog1.Color;
//cambia de color de fondo de la caja de texto
}
}
Práctica con la herramienta:
FOLDERBROWSERDIALOG
Para elegir carpetas con el componente FolderBrowserDialog
En un procedimiento, compruebe la propiedad DialogResultdel componente
FolderBrowserDialog para ver cómo se cerró el cuadro de diálogo y obtener el valor de la
propiedad SelectedPath del componente FolderBrowserDialog.
Si necesita definir la carpeta de nivel más alto que aparecerá en la vista de árbol del cuadro de
diálogo, establezca la propiedad RootFolder, que toma el miembro de la enumeración
SpecialFolder.
Asimismo, puede definir la propiedad Description, que especifica la cadena de texto que
aparece en la parte superior de la vista de árbol del explorador de carpetas.
En el siguiente ejemplo, se aplicaran las funciones que nos brinda el FolderBrowserDialog:
1 2
Dirección de una carpeta: nos permite obtener la dirección completa de una carpeta a buscar
Botón nueva carpeta: permite establecer el botón ―crear nueva carpeta‖ en el cuadro de
diálogo FolderBrowserDialog
El mismo que nos permite crear carpetas donde nosotros queramos
El código de esta sección es el siguiente:
private void button4_Click(object sender, EventArgs e)
{
//indica que el boton crear nueva carpeta no esta visible
folderBrowserDialog1.ShowNewFolderButton = false;
// descripcion del dialogo
folderBrowserDialog1.Description = "Seleccione una carpeta para copiar su direccion";
if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
{
//selecciona el texto de la direccion y lo coloca en un label
label1.Text = folderBrowserDialog1.SelectedPath;
}
}
private void button5_Click(object sender, EventArgs e)
{
//indica que el boton crear nueva carpeta esta visible
folderBrowserDialog1.ShowNewFolderButton = true;
folderBrowserDialog1.Description = "Puede crear una nueva carpeta, haciendo clic en el boton \"Crear Nueva
Carpeta\"";
folderBrowserDialog1.ShowDialog();
}
Práctica con la herramienta:
OPENFILEDIALOG y SAVEFILEDIALOG
Creamos un nuevo Formulario
Agregamos diferentes herramientas al formulario
1 Boton: Abrir
1 Boton: Guardar
2 TextBox: textBox1, y textBox2
Quedando de la siguiente manera
Ingresamos el siguiente Código en cada botón haciendo doble clic en cada uno de ellos
Botón: Abrir
openFileDialog1.FileName = "";
openFileDialog1.Title = "Lector de archivos";
if (openFileDialog1.ShowDialog() == DialogResult.OK) {
this.textBox1.Text = openFileDialog1.FileName;
StreamReader sr = new StreamReader(textBox1.Text,
System.Text.Encoding.Default);
textBox2.Text = sr.ReadToEnd();
sr.Close();
Botón: Guardar
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
StreamWriter fichero = new StreamWriter(saveFileDialog1.FileName);
fichero.Write(textBox2.Text);
fichero.Close();
MessageBox.Show("Se guardo el archivo: " +
saveFileDialog1.FileName);
}
Previamente debemos haber importado lo siguiente
using System.IO;
Al momento de Ejecutar:
Clic en Abrir:
Clic en Guardar
Escogemos el nombre del archivo a guardar
Semana N° 6 Día 1: Clase 11
CLASE N°: 11 PERÍODO 10/06/2013 al 14/06/2012
TIEMPO: 2 Horas
FECHA: 10/06/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Windows Forms
Principales controles
Propiedades
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para
facilitar la posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta
cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la
información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y
mantenimiento de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto
FontDialog
PrintDialog
LineShape
OvalShape
RectangleShape
Descriptores Analizados
- FontDialog
- PrintDialog
- LineShape
- OvalShape
- RectangleShape
Conceptos de los Descriptores Analizados
FontDialog
Pide al usuario que elija una fuente de entre todas las instaladas en el equipo local.
Sintaxis
PrintDialog
Invoca un cuadro de diálogo de impresión estándar de Microsoft Windows que configure PrintTicket y PrintQueue según los datos proporcionados por el usuario y después imprimir un documento.
Sintaxis
Reflexionar
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los
talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
Práctica con la herramienta:
FONTDIALOG
En el siguiente ejemplo de código se utiliza ShowDialog para mostrar FontDialog. En este
código se requiere que ya se haya creado un objeto Form que incluya un objeto TextBox y un
botón. También requiere que se haya creado fontDialog1. Font contiene la información de
tamaño pero no la información de color.
Pasos:
1. Creamos un nuevo proyecto
2. En el modo diseñador, colocamos un text y un button; cambiamos nombres como nos
convenga.
3. Arrastramos el fontDialog
4. Damos doble click en el botón y nos lanzara al editor de código, donde colocaremos el
siguiente código.
5. Una vez terminado regresamos al editor de diseño y ejecutamos el programa; damos
click en el botón fuente y se nos abre la pantalla de la fuente de las letras, hay elegimos
la fuente que queremos dar al texto que se mostrara en el texto.
Práctica con la herramienta:
PRINTDIALOG
1. Digitamos un texto en el textbox que se encuentra en el centro.
2. Luego pulsamos en el botón ―Vista Previa‖ para obtener una vista previa del documento
a imprimir.
3. Luego pulsamos el botón ―Imprimir‖ donde se abrirá el printDialog para escoger los
detalles de impresión.
Semana N° 6 Día 2: Clase 12
CLASE N°: 12 PERÍODO 10/06/2013 al 14/06/2012
TIEMPO: 2 Horas
FECHA: 12/06/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Windows Forms
Manejo de Excepciones en Visual Estudio C#
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la
posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento
de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto
Manejo de Excepciones
Descriptores Analizados
- Excepciones en C#
Conceptos de los Descriptores Analizados
Manejo de excepciones estructuradas
Las excepciones en C# las podemos controlar usando las instrucciones try / catch / finally. Estas
instrucciones realmente son bloques de instrucciones, y por tanto estarán delimitadas con un par
de llaves.
Cuando queramos controlar una parte del código que puede producir un error lo incluimos dentro
del bloque try, si se produce un error, éste lo podemos detectar en el bloque catch.
Cuando creamos una estructura de control de excepciones no estamos obligados a usar los tres
bloques, aunque el primero: try si es necesario, ya que es el que le indica al compilador que
tenemos intención de controlar los errores que se produzcan.
Veamos ahora con más detalle cada uno de estos bloques y que es lo que podemos hacer en
cada uno de ellos.
Bloque try
En este bloque incluiremos el código en el que queremos comprobar los errores.
El código a usar será un código normal, es decir, no tenemos que hacer nada en especial, ya
que en el momento que se produzca el error se usará (si hay) el código del bloque catch.
Bloque catch
Si se produce una excepción, ésta la capturamos en un bloque catch.
En el bloque catch podemos indicar que tipo de excepción queremos capturar, para ello
usaremos una variable de tipo Exception, la cual puede ser del tipo de error específico que
queremos controlar o de un tipo genérico.
Por ejemplo, si sabemos que nuestro código puede producir un error al trabajar con ficheros,
podemos usar un código como éste:
try
{
// código para trabajar con ficheros, etc.
}
catch(System.IO.IOException ex)
{
// el código a ejecutar cuando se produzca ese error
}
Si nuestra intención es capturar todos los errores que se produzcan, es decir, no queremos hacer
un filtro con errores específicos, podemos usar la clase Exception como tipo de excepción a
capturar. La clase Exception es la más genérica de todas las clases para manejo de
excepciones, por tanto capturará todas las excepciones que se produzcan.
try
{
// código que queremos controlar
}
catch(System.Exception ex)
{
// el código a ejecutar cuando se produzca cualquier error
}
Aunque si no vamos usar la variable indicada en el bloque Catch, pero queremos que no se
detenga la aplicación cuando se produzca un error, podemos hacerlo de esta forma:
try
{
// código que queremos controlar
}
catch
{
// el código a ejecutar cuando se produzca cualquier error
}
La variable indicada en el bloque catch la podemos usar para mostrar un mensaje al usuario o
para obtener información extra sobre el error, pero no siempre vamos a hacer uso de esa
variable, en ese caso podemos utilizar el código anterior, en el que no se usa una variable y
tampoco se indica el tipo de error que queremos interceptar. Pero es posible que nuestra
intención sea capturar errores de un tipo concreto sin necesidad de utilizar una variable, en ese
caso podemos crear un bloque catch como el siguiente, en el que solo se indica el tipo de
excepción:
try
{
// código que queremos controlar
}
catch(FormatException)
{
// interceptar los errores del tipo FormatException
}
Varias capturas de errores en un mismo bloque try/catch
En un mismo try/catch podemos capturar diferentes tipos de errores, para ello podemos incluir
varios bloques catch, cada uno de ellos con un tipo de excepción diferente.
Es importante tener en cuenta que cuando se produce un error y usamos varios bloques catch, el
CLR de .NET buscará la captura que mejor se adapte al error que se ha producido, pero siempre
lo hará examinando los diferentes bloques catch que hayamos indicado empezando por el
indicado después del bloque try, por tanto deberíamos poner las más genéricas al final, de forma
que siempre nos aseguremos de que las capturas de errores más específicas se intercepten
antes que las genéricas.
Aunque el propio compilador de C# detectará si hay capturas de errores genéricas antes que las
más específicas, avisándonos de ese hecho.
En el siguiente código capturamos un error específico y también uno genérico, con idea de que
tengamos siempre controlado cualquier error que se produzca:
try
{
// código que queremos controlar
}
catch(FormatException)
{
// captura de error de formato
}
catch(Exception ex)
{
// captura del resto de errores
}
Captura de errores no controlados
Como es lógico, si no controlamos las excepciones que se puedan producir en nuestras
aplicaciones, éstas serán inicialmente controladas por el propio runtime de .NET, en estos casos
la aplicación se detiene y se muestra el error al usuario. Pero esto es algo que no deberíamos
consentir, por tanto siempre deberíamos detectar todos los errores que se produzcan en nuestras
aplicaciones, pero a pesar de que lo intentemos, es muy probable que no siempre podamos
conseguirlo.
Una forma de hacerlo es iniciando nuestra aplicación dentro de un bloque try/catch, de esta
forma, cuando se produzca el error, se capturará en ese bloque catch, porque cuando el runtime
de .NET se encuentra con una excepción, lo que hace es revisar "la pila" de llamadas y buscar
algún try/catch, si lo encuentra, lo utiliza, y si no lo encuentra, se encarga de lanzar la excepción
deteniendo el programa.
Esto es importante saberlo, no ya por detectar esos errores que no hemos tenido la previsión de
controlar, sino porque es posible que si un error se produce dentro de un método en el que no
hay captura de errores, pero antes de llamar a ese método hemos usado un try/catch, el error
será interceptado por ese catch, aunque posiblemente ni siquiera lo pusimos pensando que
podía capturar errores producidos en otros niveles más profundos de nuestra aplicación.
Reflexionar
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los
talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
Práctica con la Manejo de Execiones mediante:
TRY { CATCH (…){}
Desarrollo de la aplicación.
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace WindowsFormsApplication6 { public partial class Form1 : Form { public Form1() { InitializeComponent(); } private void textBox2_TextChanged(object sender, EventArgs e) { } private void txtcantidad_Leave(object sender, EventArgs e) { try { byte numero = (byte.Parse(txtcantidad.Text)); } catch (Exception a) {
MessageBox.Show("Por favor ingrese un numero valido"); txtcantidad.Text=""; txtcantidad.Focus(); } } private void txtprecio_Leave(object sender, EventArgs e) { try { byte numero = (byte.Parse(txtprecio.Text)); } catch (Exception b) { MessageBox.Show(b.GetBaseException().ToString()); txtprecio.Text = ""; txtprecio.Focus(); } } private void button1_Click(object sender, EventArgs e) { txttotal.Text = (int.Parse(txtcantidad.Text)*int.Parse(txtprecio.Text)).ToString(); } } }
Semana N° 7 Día 1: Clase 13
CLASE N°: 13 PERÍODO 01/07/2013 al 05/07/2013
TIEMPO: 2 Horas
FECHA: 01/07/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Revision de temas para expsiciones
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la
posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento
de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
A cada grupo les dio tema para exposición
Semana N° 7 Día 2: Clase 14
CLASE N°: 14 PERÍODO 01/07/2013 al 05/07/2013
TIEMPO: 2 Horas
FECHA: 03/07/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Examen Objetivo de Hemisemestre
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la
posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento
de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
La Ing. Realizo a los estudiantes un examen objetivo de fin de
Hemisemestre.
Semana N° 8 Día 1: Clase 15
CLASE N°: 15 PERÍODO 15/07/2013 al 19/07/2013
TIEMPO: 2 Horas
FECHA: 15/07/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Revision de Examen Objetivo de Hemisemestre
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la
posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento
de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
La Ing. Realizo la correcion del examen hecha a los estudiantes un
examen objetivo de fin de Hemisemestre.
APUNTES DE CLASE
- Correcion de la Pureba
1. Private Button btnImprimir = new Button();
Respuesta: Crea un control button, Instancia un control button
2. Una variable del instancia ------
Respuesta: Es un objeto de una clase, Representa un atributo de un objeto
Semana N° 8 Día 2: Clase 16
CLASE N°: 16 PERÍODO 15/07/2013 al 19/07/2013
TIEMPO: 2 Horas
FECHA: 17/07/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
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
Manejo de Excepciones en Visual Estudio C#
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la
posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento
de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto
Valores automáticas y validación de datos
Descriptores Analizados
- Valores automáticos y validación de datos
VALORES AUTOMÁTICOS EN C#
Es posible establecer una columna de un DataTable para que sea una clave principal de
incremento automático con el fin de garantizar que haya un valor único para cada fila de la tabla.
Sin embargo, es posible tener varios clientes de la aplicación y cada uno de esos clientes puede
trabajar con una instancia diferente de la tabla DataTable. En este caso, podría haber valores
duplicados en las distintas instancias de la DataTable. Como todos los clientes trabajan con un
único origen de datos, es posible resolver este conflicto si se permite que el origen de datos
defina el valor de incremento automático. Para ello se utilizan columnas de identidad en Microsoft
SQL Server o campos Autonumérico en Microsoft Access.
El uso del origen de datos con el fin de llenar una columna Identidad o Auto numérica para una
nueva fila agregada a un DataSet crea una situación única, ya que el DataSet no tiene conexión
directa con el origen de datos. Por tanto, el DataSet no conoce los valores generados
automáticamente por el origen de datos. Sin embargo, con un origen de datos que pueda crear
procedimientos almacenados con parámetros de salida, como Microsoft SQL Server, se pueden
especificar los valores generados automáticamente, como un nuevo valor de identidad, como
parámetro de salida, y utilizar DataAdapter para volver a asignar el valor a la columna del
DataSet.
Puede que el origen de datos pertinente no admita procedimientos almacenados con parámetros
de salida. En este caso es posible utilizar el evento RowUpdated para recuperar un valor
generado automáticamente y ponerlo en la fila insertada o actualizada del DataSet. Esta sección
incluye un ejemplo que muestra cómo se puede utilizar Microsoft Access 2000 o posterior y el
proveedor de datos OLE DB de Jet 4.0 con el fin de agregar código al evento RowUpdated para
determinar si se ha producido una inserción y recuperar el valor de incremento automático y
almacenarlo en la fila actualizada en estos momentos.
Recuperar valores de columnas de identidad de SQL Server
El procedimiento almacenado y el ejemplo de código siguientes muestran cómo asignar el valor
de identidad de incremento automático desde una tabla de Microsoft SQL Server a su columna
correspondiente en una fila agregada a una tabla de un DataSet. El procedimiento almacenado
se utiliza para insertar una nueva fila en la tabla Categories de la base de datos Northwind y para
devolver el valor de identidad devuelto por la función Transact-SQL SCOPE_IDENTITY() como
parámetro de salida.
VALIDACION DE DATOS
Puede aplicar reglas de validación a una entidad o tabla para asegurarse de que se escriben
datos con formato correcto en el origen de datos. Una regla de validación es una condición o una
restricción que deben cumplir los datos de la aplicación. Puede agregar una o más reglas de
validación a una entidad o tabla en LightSwitch. Si un usuario agrega o cambia datos y esos
datos no cumplen las reglas de validación, LightSwitch muestra un error. Antes de que un usuario
pueda confirmar los datos, debe solucionarse el error de validación.
Reflexionar
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los
talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
PRACTICA VALIDACION DE DATOS
INTERFAZ
MÉTODOS
VALIDATING
CODIGO PARA VALIDAR CAMPOS NULOS
private void textBox2_Validating(object sender, CancelEventArgs e)
{
if (txtCantidades.Text.Trim() == "")
{
MessageBox.Show("INGRESE NUMERO");
e.Cancel = true;
}
}
CODIGO PARA VALIDAR CAMPOS NULOS
private void txtNombres_Validating(object sender, CancelEventArgs e)
{
if (txtNombres.Text.Length == 0)
{
MessageBox.Show("Necesita escribir Nombres");
e.Cancel = true;
}
}
CODIGO PARA VALIDAR INGRESO DE CIFRAS
private void txtPrecios_Validating(object sender, CancelEventArgs e)
{
try
{
double numero = Double.Parse(txtPrecios.Text);
}catch(System.FormatException){
MessageBox.Show("No es una cifra");
e.Cancel = true;
}
}
CODIGO PARA VALIDAR EL INGRESO DE CORREOS ELECTRONICOS
private void txtCorreo_Validating(object sender, CancelEventArgs e)
{
if (txtCorreo.Text.IndexOf('@') == -1 || txtCorreo.Text.IndexOf('.') == -1) {
MessageBox.Show("Correo Invalido!");
e.Cancel = true;
}
}
VALIDATED
CODIGO PARA VALIDAR INGRESO DE CAMPOS NULOS
private void txtNombres_Validated(object sender, EventArgs e)
{
if (txtNombres.Text.Length==0)
{
MessageBox.Show("Necesita escribir Nombres");
}
}
EVENTOS
KEYPRESS
CODIGO PARA VALIDAR INGRESO DE LETRAS Y ESPACIOS
private void txtNombres_KeyPress(object sender, KeyPressEventArgs e)
{
if
(!Char.IsLetter(e.KeyChar)&&e.KeyChar!=(char)Keys.Back&&e.KeyChar!=(char)Keys.Space)
e.Handled = true;
}
CODIGO PARA VALIDAR INGRESO DE NUMEROS
private void txtPrecios_KeyPress(object sender, KeyPressEventArgs e)
{
if (Char.IsLetter(e.KeyChar)) e.Handled = true;
}
CODIGO PARA VALIDAR INGRESO DE CANTIDADES
private void txtCantidades_KeyPress(object sender, KeyPressEventArgs e)
{
if (!Char.IsDigit(e.KeyChar) && e.KeyChar != (char)Keys.Back) e.Handled = true;
}
MOUSEMOVE
CODIGO PARA ENVIAR VALORES AL CALENDARIO
private void calendario_MouseMove(object sender, MouseEventArgs e){
calendario.MaxDate = DateTime.Today;
}
VALUECHANGED
CODIGO PARA VALIDAR FECHA DE NACIMIENTO
private void calendario_ValueChanged(object sender, EventArgs e)
{
if (calendario.Value > DateTime.Today)
MessageBox.Show("La fecha no puede ser mayor a Hoy");
}
Semana N° 9 Día 1: Clase 17
CLASE N°: 17 PERÍODO 22/07/2013 al 26/07/2013
TIEMPO: 2 Horas
FECHA: 22/07/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Windows Forms
Manejo de Excepciones en Visual Estudio C#
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la
posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento
de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto
Validacion de llaves primarias y ajenas
Formularios MDI
Descriptores Analizados
- Validacion de llaves primarias y ajenas
- Formularios MDI
VALIDACION DE DATOS
¿De qué trata?
Proceso por el cual los datos son filtrados y aceptados o rechazados en base a procedimientos
definidos.
Es también el paso previo a su entrega.
Punto a considerar
Debe verificarse la exactitud de los datos críticos, independientemente de si fueron ingresados a
mano o transferidos electrónicamente.
Los chequeos deben ser parte de procedimientos rutinarios para identificar errores
Deben existir procedimientos estándar para definir datos sin procesar, seguridad para la entrada
de datos y revisión.
Los resultados finales deben ser traceables a quien ingresó los datos o al instrumento desde el
cual se incorporaron automáticamente
TIPOS DE DATOS
Cuando se introducen numerosos datos en una tabla, existe el riesgo de que cometamos errores,
estos errores pueden ser por tipeo o debido a que la información ingresada sea incorrecta. Se
puede disminuir el riesgo de cometer errores, con la creación de técnicas para VALIDACION DE
DATOS, la cual impide introducir datos erróneos a medida que llenamos una tabla.
Los tipos de datos que se pueden validar son:
Números: Se puede establecer que el número que se introduce a una celda sea decimal o
entero, que este entre un mínimo y un máximo, excluir un número o intervalo de números y
finalmente se puede utilizar una fórmula para hacer el cálculo de validación
Fechas y horas: En este caso se pueden excluir fechas u horas, establecer una fecha máxima,
mínima o un intervalo y también establecer una fórmula para determinar las fechas válidas.
Longitud: Pone límites al número de caracteres que se pueden introducir, tanto en máximo
como en mínimo.
BASE DE DATOS: LLAVES PRIMARIAS Y AJENAS
LLAVE PRIMARIA
En base de datos, una llave primaria es un conjunto de uno o más atributos de una tabla, que
tomados colectivamente nos permiten identificar un registro como único, es decir, en una tabla
podemos saber cuál es un registro en específico sólo con conocer la llave primaria. Ejemplo el
número de cedula de ciudadanía, o la clave de única el registro de población, permiten identificar
a una persona en particular en una entidad de personas.
LLAVE AJENA
En base de datos, llaves o también conocidas como claves ajenas consiste en garantizar la
integridad referencial entre tablas que puedan existir en una base de datos.
"La clave ajena hace referencia a un campo que se añade a una tabla para hacer de enlace con
otra. Dicho campo hará la función de clave primaria en la tabla referenciada".
VALIDACION DE LLAVES PRIMARIAS Y AJENAS
La validación de llaves primarias siempre se da, cuando se genera un ingreso de datos, es ahí
donde toma un papel importante el poder validar ese ingreso y no tener inconvenientes, para lo
cual se debe saber el tipo de dato que permite, y algunas características mismas del ingreso.
La validación de llaves ajenas, tiene lugar al momento de hacer consultas e ingresar datos a
tablas ya referenciadas, con llaves primarias. Por ejemplo: al registrar un factura, se está
registrando llaves ajenas correspondiente a cliente y producto, es ahí donde se valida dicho
ingreso.
Como parte de demostración de se tiene el siguiente ejemplo, desarrollado en lenguaje de
programación c#.
FORMULARIOS MDI (INTERFAZ DE MULTIPLES DOCUMENTOS)
¿Qué son?
Los programas de ordenador gráficos de interfaz de múltiples documentos (MDI) son aquellos
cuyas ventanas se encuentran dentro de una ventana padre (normalmente con la excepción de
las ventanas modales), de manera opuesta a una interfaz de documento único o SDI. Ha habido
muchos debates sobre qué tipo de interfaz se prefiere. Generalmente se considera que SDI es
más útil si los usuarios trabajan con varias aplicaciones. Las compañías han utilizado ambos
sistemas con reacciones diversas. Por ejemplo, Microsoftha cambiado la interfaz de sus
aplicaciones Office de SDI a MDI y luego otra vez a SDI, aunque el grado de implementación
varía entre componentes.
Formulario "Padre" o "Parent" que puede contener otros formularios llamados "Hijos" o "Child".
La principal desventaja de MDI es la escasez de información sobre las ventanas abiertas: Para
ver una lista de ventanas abiertas de una aplicación MDI, el usuario normalmente tiene que
seleccionar un menú específico ("lista de ventanas" o algo parecido), si esta opción está
disponible. Con una aplicación SDI, la barra de tareas del administrador de ventanas muestra las
ventanas abiertas actualmente. En los últimos años, las aplicaciones han añadido barras de
tareas o sistemas de pestañas a las aplicaciones MDI, lo que ha hecho obsoleta esta crítica.
Algunas personas usan un nombre distinto para este tipo de interfaz, "interfaz de pestañas"
(TDI). Cuando se usa pestañas para controlar las ventanas, estas normalmente no se pueden
cambiar de tamaño por separado.
Aplicaciones de interfaz de múltiples documentos (MDI)
Las aplicaciones MDI (interfaz de múltiples documentos) permiten mostrar varios documentos al
mismo tiempo, cada uno de ellos en su propia ventana. Las aplicaciones MDI suelen tener un
elemento de menú Ventana con submenús que permiten cambiar entre ventanas o documentos.
Reflexionar
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los
talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
PRACTICA PARA LA VALIDACION DE LLAVES PRIMARIAS Y AJENAS
Nuestro ejemplo ilustrativo estará compuesta por una base de datos, creada en Microsoft
Access 2010, y una aplicación dentro del Entorno Integrado Microsoft Visual Studio 2010 y
su lenguaje C#.
Como parte principal, es necesario crear nuestra base que contendrá todos los datos, en
donde se pueda consultar y agregar llaves tanto en el caso de llaves primarias como llaves
ajenas.
1. CREACION DE BASE DATOS
Dentro de Microsoft Access 2010, en la parte lateral derecho es necesario colocarle un
nombre a nuestra base de datos, con el propósito de poderla identificar, en nuestro caso la
nombraremos: ―DataBaseSistema.accdb‖, cabe recalcar MS Access 2010 coloca a que
toda base de datos, en su nombre la extensión de archivo ―.accdb‖.
Ya creada nuestra base de datos, procedemos a crear cada una las tablas con sus
correspondientes atributos o campos, especificando el tipo de datos que puede almacenar.
Para la creación de una tabla es necesario, estar en la pestaña CREAR y seleccionamos
la opción TABLA
Con el propósito de simular las operaciones que realiza una factura, se necesitara crear
cuatro tablas:
Tabla CLIENTE
[cedula, nombre, ciudad, teléfono, direccion].
Tabla PRODUCTO
[código, descripción, valorUnitario, stock].
Tabla FACTURA
[numero, cliente, valorTotal, fechaNacimiento].
Tabla DETALLE_FACTURA
[codigoPro, nombre, ciudad, teléfono, direccion].
Ya habiendo creado las tablas correspondientes, realizamos las relaciones a cada tabla,
sin dejar ninguna tabla suelta o sin relacionar, es necesario colocar las llaves primarias en
las tablas CLIENTES, PRODUCTO Y FACTURA, la tabla DETALLE_FACTURA, nos
servirá para almacenar nuestras llaves ajenas correspondientes a FACTUA, PRODUCTO,
no olvidar que existe una relación de Muchos a Muchos entre la tabla PRODUCTO Y
FACTURA, por tal motivo se vio la necesidad crear la tabla DETALLE_FACTURA, luego en
su modelo relacional tendremos, la siguiente ilustración:
En la tabla CLIENTE, nuestra llave primaria es: “CEDULA”; y esta misma será llave ajena
en la tabla FACTURA, como parte de hacer una consulta a los clientes en caso de que
dicho cliente ya este registro.
En la tabla PRODUCTO, llave primaria es: “CODIGO”, de igual forma esta será llave ajena
en la tabla FACTURA, ya que por medio de esta llave se podrá consultar el producto a
facturar.
En FACTURA, tenemos como primaria a “NUMERO‖ ya que una factura solo posee un
número y no se podrá repetir, entre las llaves foránea tenemos: “CLIENTE” que será
“CEDULA” en la tabla CLIENTE.
DETALLE FACTURA, tenemos como foránea a “COD_PRO” y “NUM_FAC”, no tiene
llaves primaria por ser una tabla que rompe las relacione de ―Muchos a Muchos.‖
Una vez, terminado la creación de nuestra base de datos, desarrollamos nuestro proyecto
en Microsoft Visual Studio 2010, en lenguaje C#:
2. CREACION DE APLICACIÓN
Creamos nuestro proyecto en lenguaje C#, en nuestro caso lo nombraremos ―Validación de
Llaves‖, nuestro proyecto estará compuesto por dos formulación, una clase y una conexión de
datos.
Creación del ORIGEN DE DATOS
1. Ingresamos al menú ―DATOS‖ y al desplegarse las opciones seleccionamos ―AGREGAR
NUEVO ORIGEN DE DATOS‖.
2. Escogemos el tipo de Origen de datos, en nuestro ejemplo, ocuparemos Base de Datos,
después click en botón ―Siguiente‖
3. Realizamos una NUEVA CONEXIÓN. Y al momento de aparecer la nueva venta es
necesario buscar nuestra base de datos creada, y colocarla, luego como un téster para
conocer si la conexión está bien es necesario presionar el botón ―PROBAR CONEXION‖
Es necesario, copiar la cadena de conexión, ya que este sirve como el Path o la
direccion para poder enlazar nuestra aplicación con la base de datos.
4. Luego se selecciona lo que se desea ocupar de la base de datos, por ejemplo las vistas y
tablas, y como parte final, presionamos el botón FINALIZAR.
Una vez realizado la creación del Origen de Datos, podremos ver que en nuestro proyecto
aumento una parte de base datos, y en panel de Origen de datos, podremos visualizar las
tablas con las que cuenta la base de datos ―DataBaseSistema.accdb‖
Creación de INTERFAZ GRAFICA DE USUARIO
Formulario1: INICIAL
CLIENTE: Nos llevara el formulario ―CLIENTE‖, el cual tendrá la función de ingresar los
nuevos registros y validar la llave primaria no se repita y poder controlar cierto errores que
se presentan al almacenar una llave primaria.
FACTURA: Nos presentara el formulario ―FACTURA‖: que tendrá la función hacer
consultar por medio de llaves primarias registros de las tablas CLIENTES Y PRODUCTOS,
además podrá registrar las llaves foráneas.
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á:
private void Form2_Load(object sender, EventArgs e)
{
textBox1.Text = "Probando";
}
public void Borar()
{
textBox1.Text=""; textBox2.Text="";
textBox3.Text = "";
}
7. Luego a Form1 le añadimos un control MenuStrip, jalándolo desde la caja de herramientas:
8. Luego se le hace click a la etiqueta "limpiar" y se añade el código:
private void limpiarToolStripMenuItem_Click(object sender, EventArgs e)
{
frm2.Borar();
}
9. Se pueden hacer más cosas, por ejemplo, añadí esto al menuStrip:
10. Junto con este código:
11. Esto permite minimizar y maximizar Form2 clickeando la opción correspondiente en el menú.
Resultados:
Al ejecutar el proyecto se muestra el Texto que escribimos en el primer textBox:
Si deseamos limpiar la caja de texto debemos presionar el Menú Limpiar:
Si deseamos maximizar, minimizar la ventana hacemos clic en los menús Maximizar
y Minimizar:
Vista Maximizada:
Vista
Minimizada:
Por ultimo si deseamos poner la ventana en estado Normal presionamos el Menú Normal:
PRACTICA 2:
1.- Creamos un formulario, del cual será primario o padre en donde se mostraran las demás ventanas
de los otros formularios llamados secundarios o hijos.
2.- Luego para que nuestro formulario sea Padre o Primario, se debe colocar en la propiedad
IsMdiContainer a True, al momento de que se ponga True el color de fondo del formulario cambiara
indicando de que será contenedor de formularios hijos o secundarios.
3.- Ahora colocamos un MenuStrip, en el cual contendra opcviones para abrir y mostrar los
formularios hijos que se encuentran en el formulario.
4.- Seleccionamos el MenuStrip, en propiedades MdiWindowsListItem selecciones
ventanaTollStripMenuItem, esto sirvira para indicvar que ventana secundario o hija esta activa que
se muestra en el formulario padre.
5.- Procedemos a crear formularios para los MenuStrip
6.- En los MenuStrip se realiza la siguiente codificacion private void bananoToolStripMenuItem_Click(object sender, EventArgs e) { //se crea una instancia de un formulario hijo Form9 banana = new Form9();
//el nombre de la instancia se le asigna el formulario padre a este, mediante la propiedad MdiParent
banana.MdiParent = this; //.show se utiliza para mostrar la instancia del formulario previo
banana.Show(); } private void perroToolStripMenuItem_Click(object sender, EventArgs e) { Form2 perro = new Form2(); perro.MdiParent = this; perro.Show(); }
7.- Luego damos clic en Animales Perro y nos mostrara el formulario Perro (Secundario) dentro
del formulario Padre (Form1).
8.- Luego damos clic en otro formulario en este caso Pera y se nos abrira otro formulario hijo dentro
del formulario Padre. Ademas en ventana podemos visualizar el o los formularios que se encuentren
abiertos, el formulario que esta primero se seleccionara con un visto.
Semana N° 9 Día 2: Clase 18
CLASE N°: 18 PERÍODO 22/07/2013 al 26/07/2013
TIEMPO: 2 Horas
FECHA: 24/07/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Windows Forms
Manejo de Excepciones en Visual Estudio C#
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto
Busquedad de Registros
Formulario Maestro Detalle
Descriptores Analizados
- Busqueda de registros
- Formulario Maestro Detalle
BUSQUEDA DE REGISTROS
Primeramente para poder conceptualizar que es una búsqueda de registro debemos tener bien
en claro algunos conceptos principales es por eso que nos eso visto en la necesidad de definirlos
a continuación.
QUE ES UN REGISTRO?
Un registro es un conjunto de campos que contienen los datos que pertenecen a una misma
repetición de entidad. Se le asigna automáticamente un número consecutivo (número de registro)
que en ocasiones es usado como índice aunque lo normal y práctico es asignarle a cada registro
un campo clave para su búsqueda.
QUE ES UNA BUSQUEDA?
La palabra búsqueda refiere, por un lado, la acción de buscar que despliega alguien o una cosa,
por ejemplo una máquina o una función especializada para tal efecto; y también se llama
búsqueda, a la investigación o estudio de documentación, la búsqueda bibliográfica, la búsqueda
de una persona, entre otras.
Uno de los sistemas más complejos cuando de recuperar información se trata, básicamente
porque busca información en una cantidad inmensa de documentos, los buscadores web
emplean este tipo de metodología. Consiste en extraer de los documentos un mínimo fragmento
de texto el cual responde a una pregunta que se hace en el lenguaje corriente natural. El mismo,
por la complejidad que mencionamos, se encuentra ubicado por delante de la tecnología que
tiene un buscador tradicional.
Pues bien un concepto el cual nos interesa es la búsqueda con respecto a la informática resulta
ser aquel sistema informático que busca archivos que se encuentran guardados en diversos
servidores o en algunas bases de datos.
BÚSQUEDA DE REGISTRO
Una vez definidos estos conceptos tenemos una idea clara de lo que es una búsqueda de
registro.
Se refiere a la acción de búsqueda de un archivo o documento en un conjunto de campos
perteneciente a una base de datos.
PROGRAMA DE BÚSQUEDA DE REGISTRO
INTERFAZ INICIO
FORMULARIOS MAESTRO, DETALLE, CÁLCULOS
Una factura bien hecha debería contener los siguientes elementos en el orden establecido:
Datos identificativos del profesional que presta los servicios: nombre completo, domicilio y Razón
social.
Número de factura: todas las facturas han de ir numeradas de forma correlativa, es decir, no se
puede saltar del número 93 a la 98, por ejemplo.
Fecha de la factura: también hay que tener en cuenta que las fechas de las facturas han de ir de
acuerdo a su numeración, es decir, la factura 98 no puede tener una fecha anterior a la 97.
Concepto de la factura: breve descripción de los productos o servicios prestados.
Importe del IVA: cantidad resultante de aplicar al importe 12%.
Cantidad total a percibir: la suma del importe inicial, más el importe del IVA.
Forma de pago.
Reflexionar
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los
talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
BÚSQUEDA DE REGISTROS
PASOS PARA REALIZAR LA PRÁCTICA
CREAR LA BASE DE DATOS
1. Para llevar a cabo la práctica, iniciamos con la creación de la base de dato, la cual
contendrá los registros que se van a acceder, para esto, hacemos lo siguiente:
1.1. Abrimos Microsoft Access y damos clic en la opción Nuevo y le colocamos un
nombre
1.2. Luego procedemos a crear una tabla de nombre ―Personal‖
1.3. Luego damos clic en la opción Ver, y seleccionamos ―Diseño‖
1.4. Para continuar, debemos crear los campos en la tabla, para ello haremos 7 campos,
de la siguiente manera:
1.5. Una vez que fijemos los tipos de datos, procedemos a llenar la tabla con los
registros que nosotros queramos y guardamos los cambios efectuados.
CREAR EL FORMULARIO
2. Primero debemos crear un nuevo Proyecto y ponerle el nombre que nosotros queramos. Y
luego arrastramos los componentes de manera que se parezca a la que se muestra a
continuación:
3. Los nombres de las variables de cada componente se detallan a continuación:
COMPONENTES (nombre de variables)
Label Button ComboBox TextBox
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;
private void Form1_Load(object sender, EventArgs e)
{
llenarTabla();
comboBox1.SelectedIndex = 0;
comboBox2.SelectedIndex = 0;
csueldo.SelectedIndex = 0;
cfecha.SelectedIndex = 0;
cordenacion.SelectedIndex = 0;
this.Size = new Size(391, 477);
}
6. El método llenarTabla(), lo que hará es llenar el dataGridView1 con los registros de la base
de datos. Primero se instancia la variable OleDbConnection y se ubica la ruta en donde se
encuentra nuestra base de datos.
Después creamos un objeto de tipo DataAdapter y en los parámetros recibirá la conexión y la
sentencia SQL, la cual será seleccionar todos los registros de la tabla; porque inicializa la variable
total Registros con el número de filas que tenga el dataGridView1 y se coloca el número de
registros en lregistros.
Código:
public void llenarTabla()
{
con = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data
Source=D:\BDEjemplo.accdb");
OleDbDataAdapter da = new OleDbDataAdapter("SELECT * FROM Personal", con);
DataSet ds = new DataSet();
da.Fill(ds, "Personal");
dataGridView1.DataSource = ds.Tables["Personal"];
totalRegistros = dataGridView1.Rows.Count - 1;
lregistros.Text = (dataGridView1.Rows.Count-1) + " de " + totalRegistros;
}
EVENTOS
7. Evento comboBox1
Este evento habilitará el comboBox2 al momento de seleccionar el elemento en la posición
5.
Código:
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
if (comboBox1.SelectedIndex == 5)
{
comboBox2.Enabled = true;
}
else
{
comboBox2.Enabled = false;
tbuscar.Text = "";
}
}
8. Evento tbuscar
Este evento hará que se llene el dataGridView1 con el resultado de la consulta a la base
de datos dependiendo del campo que se haya seleccionado en comboBox1. Tendrá un
bucle el cual vaciará la tabla y dependiendo del elemento que se seleccione en
comboBox1, llamará al método filtarTabla() siempre y cuando no se elija el elemento en la
posición 5 (sueldo). Si se eligió el elemento 5, entonces llamará a otro método
busquedaSueldo().
En caso que el tbuscar esté vacío, se llamará al método llenarTabla().
Código:
private void tbuscar_TextChanged(object sender, EventArgs e)
{
for (int i = 0; dataGridView1.Rows.Count - 1 > 0; i++)
{
dataGridView1.Rows.RemoveAt(0);
}
if (comboBox1.SelectedIndex != 5)
{
lerror.Text = "";
if (tbuscar.Text != "")
filtrarTabla(comboBox1.SelectedItem.ToString());
else
llenarTabla();
}
else
{
lerror.Text = "";
if (tbuscar.Text != "")
busquedaSueldo(comboBox2.SelectedItem.ToString());
else
llenarTabla();
}
}
9. El método filtarTabla(), recibirá el campo que se eligió en comboBox1 y se armará la
sentencia SQL, la cual mandará a buscar en la tabla Personal aquellos campos que
contengan parte de texto que se escribió en tbuscar. Si se encontró registros se llenará el
dataGridView1 y se actualizarán el número de registros en legistros.
En caso de no hallar registros, se mostrará un mensaje en lerror, del mismo modo nos
mostrará error cuando genere una excepción.
Código:
public void filtrarTabla(string campo)
{
//senetencia sql
string sql = "SELECT * FROM Personal WHERE " + campo + " LIKE '%" + tbuscar.Text + "%'";
try
{
lerror.Text = "";
con = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data
Source=D:\BDEjemplo.accdb");
OleDbDataAdapter da = new OleDbDataAdapter(sql, con);
DataSet ds = new DataSet();
da.Fill(ds, "Personal");
dataGridView1.DataSource = ds.Tables["Personal"];
lregistros.Text = (dataGridView1.Rows.Count - 1) + " de " + totalRegistros;
if ((dataGridView1.Rows.Count - 1) == 0)
{
lerror.Text = "¡No hay registros!";
}
}
catch (Exception ex)
{
lerror.Text = "¡No hay registros!";
}
}
10. El método busquedaSueldo(), recibirá el operador que se eligió en comboBox2 (<, >, =, <=,
>=) y se armará la sentencia SQL, la cual mandará a buscar en la tabla Personal aquellos
registros que tengan el Sueldo especificado por el operador.
Si se encontró registros se llenará el dataGridView1 y se actualizarán el número de
registros en legistros. En caso de no hallar registros, se mostrará un mensaje en lerror,
del mismo modo nos mostrará error cuando genere una excepción.
Código:
public void busquedaSueldo(string o)
{
string sql = "SELECT * FROM Personal WHERE Sueldo " + o + tbuscar.Text;
try
{
lerror.Text = "";
con = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data
Source=D:\BDEjemplo.accdb");
OleDbDataAdapter da = new OleDbDataAdapter(sql, con);
DataSet ds = new DataSet();
da.Fill(ds, "Personal");
dataGridView1.DataSource = ds.Tables["Personal"];
lregistros.Text = (dataGridView1.Rows.Count - 1) + " de " + totalRegistros;
if ((dataGridView1.Rows.Count - 1) == 0)
{
lerror.Text = "¡No hay registros!";
}
}
catch (Exception ex)
{
lerror.Text = "¡No hay registros!";
}
}
11. Evento dataGridView1
Este evento mostrará en las cajas de texto el registro que se haya encontrado mediante
la consulta SQL donde la cédula sea igual al valor de la fila que se haya seleccionado
mediante un clic.
En caso de no hallar registros, se mostrará un mensaje en lerror, del mismo modo nos
mostrará error cuando genere una excepción.
Código:
private void dataGridView1_CellClick(object sender, DataGridViewCellEventArgs e)
{
string sql = "SELECT * FROM Personal WHERE Cedula = '" + dataGridView1[0,
dataGridView1.CurrentRow.Index].Value.ToString()+ "'";
try
{
lerror.Text = "";
OleDbDataAdapter da = new OleDbDataAdapter(sql, con);
DataSet ds = new DataSet();
da.Fill(ds, "Personal");
dr = ds.Tables["Personal"].Rows[0];
tcedula.Text = dr["Cedula"].ToString();
tnombre.Text = dr["Nombre"].ToString();
tapellido.Text = dr["Apellido"].ToString();
tfecha.Text = dr["Fecha_nac"].ToString();
tciudad.Text = dr["Ciudad"].ToString();
ttelefono.Text = dr["Telefono"].ToString();
tsueldo.Text = dr["Sueldo"].ToString();
tbuscar.Text = "";
comboBox2.Enabled = false;
}
catch (Exception ex)
{
lerror.Text = "¡No hay registros!";
}
}
12. Evento button2
Este botón únicamente ajustará el tamaño del formulario y deshabilitará tbuscar.
Código:
private void button2_Click(object sender, EventArgs e)
{
this.Size = new Size(781,477);
tbuscar.Enabled = false;
}
13. Evento cfecha
Este evento hará visible el fdate2, siempre y cuando el elemento que se haya
seleccionado esté en la posición 4, caso contrario, no se podrá visualizar éste
dataTimePicker.
Código:
private void cfecha_SelectedIndexChanged(object sender, EventArgs e)
{
if (cfecha.SelectedIndex == 4)
fdate2.Visible = true;
else
fdate2.Visible = false;
}
14. Evento button4
Llamará al método busquedaAvanzada()
Código:
private void button4_Click(object sender, EventArgs e)
{
busquedaAvanzada();
}
El método busquedaAvanzada()
Capturará en las variables string todos los valores que contenga cada TextBox, en
base a esto, la sentencia SQL se irá concatenando siempre y cuando los campos
tengan un valor y no sean nulos.
Del mismo modo la ordenación se verá afectado al seleccionar los valores en
cordenacion y en asc/desc
En caso de no hallar registros, se mostrará un mensaje en lerror, del mismo modo nos
mostrará error cuando genere una excepción.
Código:
public void busquedaAvanzada()
{
string ced, nom, ape, ciu, sue, cs, cf, sql, fec1, fec2;
int cont = 0;
ced = fced.Text;
nom = fnom.Text;
ape = fape.Text;
ciu = fciu.Text;
sue = fsue.Text;
cs = csueldo.SelectedItem.ToString();
fec1 = formatoFecha(fdate1.Value.Date);
fec2 = formatoFecha(fdate2.Value.Date);
cf = cfecha.SelectedItem.ToString();
if (cf == "entre")
cf = "BETWEEN";
sql = "SELECT * FROM Personal ";
if (ced != "")
{
cont++;
sql += " WHERE Cedula LIKE '%" + ced + "%' ";
}
if (nom != "")
{
cont++;
if (cont == 1)
sql += " WHERE Nombre LIKE '%" + nom + "%' ";
else
sql += " AND Nombre LIKE '%" + nom + "%' ";
}
if (ape != "")
{
cont++;
if (cont == 1)
sql += " WHERE Apellido LIKE '%" + ape + "%' ";
else
sql += " AND Apellido LIKE '%" + ape + "%' ";
}
if (ciu != "")
{
cont++;
if (cont == 1)
sql += " WHERE Ciudad LIKE '%" + ciu + "%' ";
else
sql += " AND Ciudad LIKE '%" + ciu + "%' ";
}
if (sue != "")
{
cont++;
if (cont == 1)
sql += " WHERE Sueldo " + cs + sue;
else
sql += " AND Sueldo " + cs + sue;
}
if (fdate1.Value.Date != DateTime.Today)
{
cont++;
if (cont == 1)
{
if (cf == "BETWEEN")
sql += " WHERE Fecha_nac " + cf + "#" + fec1 + "# AND #" + fec2 + "# ";
else
sql += " WHERE Fecha_nac " + cf + "#" + fec1+ "# ";
}
else
{
if (cf == "BETWEEN")
sql += " AND Fecha_nac " + cf + "#" + fec1 + "# AND #" + fec2+ "# ";
else
sql += " AND Fecha_nac " + cf + "#" + fec1 + "# ";
}
}
String campo = cordenacion.SelectedItem.ToString();
if (campo != "(Sin ordenación)")
{
if (asc.Checked)
sql += " ORDER BY " + campo + " ASC";
else
sql += " ORDER BY " + campo + " DESC";
}
try
{
lerror.Text = "";
con = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data
Source=D:\BDEjemplo.accdb");
OleDbDataAdapter da = new OleDbDataAdapter(sql, con);
DataSet ds = new DataSet();
da.Fill(ds, "Personal");
dataGridView1.DataSource = ds.Tables["Personal"];
lregistros.Text = (dataGridView1.Rows.Count - 1) + " de " + totalRegistros;
if ((dataGridView1.Rows.Count - 1) == 0)
{
lerror.Text = "¡No hay registros!";
}
}
catch (Exception ex)
{
lerror.Text = "¡No hay registros!";
}
}
El método formatoFecha(), convertirá a String la fecha que se ha colocado en el
dateTimePicker1
Código:
private string formatoFecha(DateTime dt)
{
return dt.Year + "/" + dt.Month + "/" + dt.Day;
}
15. Evento button1
Lo que hará este evento es llamar al método llenarTabla ()
Código:
private void button1_Click(object sender, EventArgs e)
{
llenarTabla();
}
16. Evento button3
Este evento ajustará el formulario para que su tamaño se reduzca y habilitará el
tbuscar
Código:
private void button3_Click(object sender, EventArgs e)
{
this.Size = new Size(391,477);
tbuscar.Enabled = true;
}
FUNCIONAMIENTO: EJEMPLOS
En este ejemplo buscaremos los registros cuyo campo apellido contenga la palabra “ez” y
seleccionaremos el primer registro que aparezca:
En este ejemplo buscaremos los registros cuyo campo ciudad sea igual a “Machala”, el
campo sueldo sea menor o igual a 900 y lo ordenamos por sueldo de forma ascendente;
seleccionamos el primer registro que aparezca:
En este ejemplo buscaremos los registros cuyo campo cédula contenga ―070”, el campo
nombre contenga la letra “a” y lo ordenamos por apellido de forma descendente;
seleccionamos el primer registro que aparezca:
PRACTICA EN VISUAL C#: FACTURA MAESTRO DETALLE
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)); } } } } } }
Semana N° 10 Día 1: Clase 19
CLASE N°: 19 PERÍODO 29/07/2013 al 02/08/2013
TIEMPO: 2 Horas
FECHA: 29/07/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Windows Forms
Manejo de Excepciones en Visual Estudio C#
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto Servicios Web Validacion de usuarios
Descriptores Analizados
- 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
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
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; } }
Semana N° 10 Día 2: Clase 20
CLASE N°: 20 PERÍODO 29/07/2013 al 02/08/2013
TIEMPO: 2 Horas
FECHA: 31/07/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Windows Forms
Manejo de Excepciones en Visual Estudio C#
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto Respaldar y restaurar archivos
Descriptores Analizados
- 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.
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
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
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#
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); } } } }
Semana N° 11 Día 1: Clase 21
CLASE N°: 21 PERÍODO 05/08/2013 al 09/08/2013
TIEMPO: 2 Horas
FECHA: 05/08/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Windows Forms
Manejo de Excepciones en Visual Estudio C#
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto Creacion y envio de email
Descriptores Analizados
- 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.
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
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
PRACTICA PARA LA CREACIÓN Y ENVÍO DE CORREOS ELECTRÓNICOS.
MailMessage m = new MailMessage (“[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.
Semana N° 11 Día 2: Clase 22
CLASE N°: 22 PERÍODO 05/08/2013 al 09/08/2013
TIEMPO: 2 Horas
FECHA: 07/08/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
TEMA DISCUTIDO: UNIDAD III: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
Contenidos
Windows Forms
Manejo de Excepciones en Visual Estudio C#
Objetivos de Desempeño
Crear interfaces gráficas amigables y flexibles.
Utilizar nombres estandarizados, comentarios, documentación y sangría para facilitar la posterior lectura del código.
Crear funciones utilizando datos por valor y referencia.
Programar métodos que muestren características de bajo acoplamiento y alta cohesión.
Construir módulos que valida el ingreso de datos para la integridad de la información
Competencia General
Identificar los métodos a programar en la construcción de un sistema
Manejar controles que se pueden utilizar para que la interfaz gráfica sea amigable.
Utilizar programación modular.
Aplicar y emplear el lenguaje C# para el desarrollo, implementación y mantenimiento de los sistemas.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto Creacion OCX Formas de Formularios
Descriptores Analizados
- 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
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
UNIDAD IV: PRESENTACIÓN DE
RESULTADOS
Semana N° 11 Día 3: Clase 23
CLASE N°: 22 PERÍODO 05/08/2013 al 09/08/2013
TIEMPO: 2 Horas
FECHA: 09/08/2013
DOCENTE GUÍA: Ing. Mariuxi Paola Zea Ordoñez
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
Objetivos de Desempeño
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.
Datos Interesados Discutidos
Actividades Durante la Clase
- Hubieron exposiciones de Compañeros
- Cada estudiante iba haciendo sus prácticas de cada tema expuesto Crystal Reports
Descriptores Analizados
- 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
¿Qué cosa fueron difíciles?
Todo estuvo bien explicado
¿Qué cosas fueron fáciles?
Realizar las practicas
¿Por qué?
Debido a que las Exposiciones estuvieron bien explicadas se pudieron desarrollar los talleres
¿Qué Aprendí Hoy?
- A usar los componentes que vienen en visual Estudio 2010.
APUNTES DE CLASE
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
lenguajes de programación.
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
lenguajes de programación.
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
OBJETIVO: Describir los conceptos y terminologías sobre el lenguaje de
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
□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
□ 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..
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 -----------------
Actividad N° 3
ACTIVIDAD N°: 3 FECHA: 10/05/2013
TEMA:
Elaborar una línea de tiempo sobre la evolución de los
lenguajes de programación.
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
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:
o) Comunicación efectiva
p) 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 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
ACTIVIDAD N°: 4 FECHA
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.
UNIDAD N°1: Introducción a.Net
OBJETIVO: Describir los conceptos y terminologías sobre el lenguaje de
programación.
PROBLEMA: El estudiante debe identificar 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
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)
El ensayo cumple con los
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.
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
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
□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
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.
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
Solución o Resultados
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.
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#
6 Visual C# Developer Center, Frequently Asked Questions About Visual C# .NET 2003 (en inglés)
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
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.
324
325
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.
UNIDAD N°1: Introducción a.Net
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#
INDICADOR DE EVALUACION:
CALIFICACIÓN
Comprometerse con el aprendizaje continuo.
Diseñar conducir experimentos analizar e interpretar datos
Comunicarse Efectivamente
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 errores de
ortografía.
Ensayo simple pero bien
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 bibliográficas)
El ensayo cumple con los
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.
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 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
□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
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
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).
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
Solución o Resultados
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
Jennifer Honores Cun11
10 Visual C# Developer Center, Frequently Asked Questions About Visual C# .NET 2003 (en inglés)
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
12 Visual C# Developer Center, Frequently Asked Questions About Visual C# .NET 2003 (en inglés)
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
ACTIVIDAD N°: 6 FECHA
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
□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
ROLES Y RESPONSABILIDADES DE LOS PARTICIPANTES EN LA TAREA:
NOMBRE ROL DESCRIPCIÓN
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
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
341
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#
OBJETIVO: Describir los conceptos y terminologías sobre el lenguaje de
programación.
PROBLEMA: El estudiante debe identificar 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
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 errores de
ortografía.
Ensayo simple pero bien
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
El ensayo cumple con los
cuatro criterios de diseño
pero no con la extensión
solicitada (mínimo 3
páginas) o bien, estos
puntos no han sido
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.
344
bibliográficas) correctamente
realizados.
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
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
□Intraclase
□Extraclase
□Individual
□Grupal
□Taller
□Síntesis, esquemas
□Caso de estudio
□Investigativa
□Vinculación con a
colectividad
□Práctica en laboratorio
□Práctica en clase
□Resolución de problemas,
ejercicios
□Ensayo, artículo
□Informe de exposició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
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).
Solución o Resultados
Realizar informe sobre la creación de Clases y Métodos en C#.
C#
Creación de Clases y Métodos
Jennifer Honores Cun14
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#?.
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?
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?
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()
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
private void button1_Click(object sender, EventArgs e)
{
//Inicializamos la Clase Presentar
//Y le enviamos lo que tenia los textos al constructor que recibe parametros
Presentar aas= new Presentar(txtNombre.Text, txtEdad.Text);
//Hacemos que se haga visible
aas.Visible = true;
}
11. En la clase Presentar debe tener el Constructor recibiendo Parámetros
public partial class Presentar : Form
{
public Presentar(String nombre, String edad)
{
InitializeComponent();
}
}
12. Cambiamos los nombres a los Labels
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);
InitializeComponent();
}
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
356
Actividad N° 8
ACTIVIDAD N°: 8 FECHA: 12/06/2013
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
Visual Estudio 2010 C#
INDICADOR DE
EVALUACION:
q) Comunicación efectiva
r) 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
357
Actividad N° 9
ACTIVIDAD N°: 9 FECHA: 14/06/2013
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).
UNIDAD N° 3: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
OBJETIVO: Crear y manipular Objetos
PROBLEMA: Desconocimiento para manipular objetos.
INDICADOR DE
EVALUACION: s) Comunicación efectiva
358
t) 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
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
ACTIVIDAD N°: 10 FECHA: 05/07/2013
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.
UNIDAD N° 3: CONCEPTO DE INTERFAZ GRÁFICA DE USUARIO Y
PROGRAMACIÓN EN C#
OBJETIVO: Crear y manipular Objetos
PROBLEMA: Desconocimiento para manipular objetos.
INDICADOR DE
EVALUACION:
u) Comunicación efectiva
v) Asuntos contemporáneos
VALORES: Respeto, Honestidad, Responsabilidad.
TIPO DE ACTIVIDAD
LUGAR ALCANCE FORMA
364
□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
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:
1. Creamos un nuevo proyecto
2. Creamos una clase tipo FORM:
3. Nos tiene que quedar la ventana:
4. Programamos todos los botones
CODIGO
using 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:
1. Creamos un nuevo proyecto
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
ROLES Y RESPONSABILIDADES DE LOS PARTICIPANTES EN LA TAREA:
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.
Módulos Descripción
Inicio Sesión Inicia Sesión con su respectivo usuario para que solo
pueda hacer sus procesos
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 Ingresa, Actualiza, Elimina, Imprime la información de los
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
Módulos Descripción
Inicio Sesión Inicia Sesión con su respectivo usuario para que solo
pueda hacer sus procesos
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 Ingresa, Actualiza, Elimina, Imprime la información de los
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.