programacion i guia- cap i

VISUAL STUDIO .NET

2012

Guía de Estudio

C# - ADO .Net - LINQ - SQL SERVER - WPF

EI | Ing. Joffre Cartuche C Programación Visual

Pro

gram

ació

n V

isu

al II

2

PROGRAMACIÓN

VISUAL

C# .Net

Guía de Estudio


Pro

gram

ació

n V

isu

al II

3

ÍNDICE


Pro

gram

ació

n V

isu

al II

4


Pro

gram

ació

n V

isu

al II

5

"Los programas deben ser escritos para que la gente los lea y sólo

incidentalmente, para que las máquinas los ejecuten"

Bill Gates

Empezar una nueva asignatura representa reafirmar el compromiso que al principio te propusiste, y

al igual que muchos, te encuentras entre aquellos que lograron las metas iníciales.

Estudiar una carrera como la Ingeniería en Sistemas no es fácil, tus propósitos deben mantenerse firmes,

debes levantarte al caer y gozar del triunfo que acompaña al trabajo terminado.

Vamos a iniciar el estudio de PROGRAMACIÓN VISUAL, asignatura que tiene como pre requisito a

Programación Estructurada, Programación Orientada a Objetos y Base de I. Esta asignatura va a permitir

el inicio del aprendizaje y el desarrollo de habilidades en el área de la programación visual en la

plataforma .NET y su proceso de implementación, basándonos en las necesidades del entorno

empresarial.

Ahora, con tu aprendizaje y habilidades adquiridas en este primer momento del mundo de la

programación, podrás desarrollar propuestas de desarrollo de software que permitan la implementación

de sistemas informáticos, alcanzando el nivel que en nuestra Institución y Escuela exigimos a los futuros

ingenieros de sistemas.

La asignatura de programación visual II esta orienta a que los estudiantes adquirirán conocimientos,

habilidades y valores en el diseño e implementación de aplicaciones visuales orientadas a objetos,

eventos y componentes visuales, sin dejar a un lado las habilidades y destrezas en crear nuevos

escenarios y entornos en el área de software.

Para un mejor entendimiento la presente guía está dividida en cuatro unidades que son los

siguientes:

UNIDAD DIDÁCTICA 1: INTRODUCCIÓN A VISUAL STUDIO .NET

INTRODUCCIÓN


Pro

gram

ació

n V

isu

al II

6

En esta unidad se caracterizara la plataforma de desarrollo Microsoft .NET, el lenguaje C#, se

desarrollara aplicaciones Windows usando los principales componentes visuales con manejo de

estructuras de control, selección repetición y manejo de excepciones.

UNIDAD DIDÁCTICA 2: CLASES Y OBJETOS

En esta unidad recordaremos los conceptos fundamentales de la programación orientada a objetos

usando el lenguaje C# en Visual Studio .NET 2012, utilizaremos el lenguaje UML para el modelado de las

clases y objetos, desarrollaremos aplicaciones usando esta técnica de programación también se

implementara listas de objetos con lenguaje integrado de consultas orientada a objetos ( LINQ OBJECT),

este tema es de suma importancia nos ayudara a la siguiente unidad a realizar una programación por

capas.

UNIDAD DIDÁCTICA 3: ACCESO A BASES DE DATOS

En esta unidad aprenderemos a trabajar con datos y fuentes de datos en escenarios en modo

desconectado con Visual Studio 2012 y los principales componentes de acceso a datos ADO.NET y los

lenguajes integrados de consultas LINQ to SQL. Estas dos tecnología principales para conectarse a una

base de datos , nos ofrece un alto nivel de abstracción, ocultando los detalles de bajo nivel de la

implementación de la base de un fabricante.

UNIDAD DIDÁCTICA 4: CREACION DE REPORTES

En esta unidad aprenderemos a realizar reportes básicos, estadísticos y personalizados con la

herramienta Crystal Reports y el componente ReportViewer.

En esta asignatura utilizaras la plataforma de desarrollo Visual Studio 2012 con un motor de bases de

datos SQL Server 2008, Mysql, Postgres y para modelado de datos Enterprice Architecter.

Bienvenido a la asignatura y espero satisfacer tus expectativas en el área de desarrollo de software de tal

forma que pueda aportar en tu formación como profesional.

Joffre Cartuche Calva


Pro

gram

ació

n V

isu

al II

7

ESTRATEGIAS METODOLÓGICAS

Estudiante, al iniciar el análisis de los contenidos de esta interesante asignatura, es necesario que tomes

en consideración los siguientes aspectos:

1. Lee con atención cada uno de los temas objeto de estudio, para ello es importante organizar tu tiempo

de tal manera que el estudio cotidiano forme un hábito y al final no se verá acumulado el trabajo y

podrás resolver todas las actividades pedidas en tu trabajo a distancia.

2. Es importante que tú no memo rices los conceptos sino que tengas una idea general del tema la más

clara posible para relacionarla con la realidad.

3. Trata de entender los conceptos y destaca lo más importante de los temas, a fin de poder relacionarlos

con los subsiguientes.

4. Cuando estudies concéntrate en lo que estás leyendo.

5. Tener una actitud positiva, voluntad, motivación e interés es importante.

6. Leer reflexivamente la bibliografía básica, en ella se encuentran todos los temas de las actividades

planteadas.

7. Para aprender cualquier asignatura se necesita tener una fuente de consulta a mano, por lo tanto se

recomienda leer, como mínimo, los textos básicos o guías expuestos en la bibliografía y reforzar con

algunos textos complementarios.

8. Cuando hayas hecho esta primera lectura comprensiva, procede a desarrollar las actividades, poniendo

en práctica tu actitud crítica y reflexiva, tu capacidad de síntesis y tu creatividad.

9. Para estudiar debes elegir siempre un lugar tranquilo, cómodo, con buena iluminación, y tener sobre la

mesa la bibliografía básica, diccionario, papel. esfero, etc.

10. Planifica el tiempo dedicado al sueño y a las comidas, casi todos necesitamos de 8 horas de sueño.

11. Considera las horas que son dedicadas a tu trabajo u ocupación personal. Lo importante es saber

determinar el tiempo que necesitas para tus estudios.

12. Es importante que en todo este proceso cultives el valor de la constancia porque no sirve de nada tener

una excelente planificación y un horario si no eres constante.


Pro

gram

ació

n V

isu

al II

8

SIMBOLOGÍA

RECUERDA:

EL TRABAJO ES PERSONAL, NO SE ACEPTARAN COPIAS PARCIALES

O TOTALES

Instrucciones para el aprendizaje

Sugerencia Le indicará apoyos de contenido por

parte del profesor

Tarea Actividades complementarias y de

refuerzo

Comunícate

Son temas dónde vas a necesitar la

ayuda del tutor

Observación Recomendaciones del Profesor

Ejercicios Podrá practicar lo que se ha enseñado

en el tema estudiado

Ejemplos Podrá reforzar el conocimiento

adquirido

Texto Importante Resumen de la idea Principal del tema


Pro

gram

ació

n V

isu

al II

9

UNIDAD DIDÁCTICA

1

INTRODUCCIÓN A

VISUAL STUDIO

.NET

Tiempo estimado de estudio:

32 Horas


Pro

gram

ació

n V

isu

al II

10

OBJETIVO GENERAL

Caracterizar la plataforma de desarrollo Microsoft .NET, mediante el análisis de sus principios

básicos de funcionamiento, su arquitectura de componentes y sus principales bibliotecas

reutilizables, que permita la utilización de .NET como plataforma de desarrollo.

AGENDA Introducción a la plataforma .NET

Lenguaje C # 3.0 y .NET

Elementos de Programación

Controles principales

Estructuras de control, selección, repetición.

Arrays y colecciones

Manejo de errores.

Creación de componentes.

Trabajando con aplicaciones Windows.

ESQUEMA DE CONTENIDOS

Introduccion a la plataforma .NET

Arquitectura framework

Componentes internos.

Caracteristicas del lenguaje C#

Tipo de datos Instrucciones

de control Estructuras

Manejo errores

Desarrollo de aplicaciones


Pro

gram

ació

n V

isu

al II

11

INTRODUCCIÓN

En esta Unidad podrás aprender a desarrollar aplicaciones Windows con Visual Studio terminaremos

desarrollando una aplicación real con los conceptos aprendidos. Al final de cada lección tendrás

disponible un ejercicio en el que podrás ver los conceptos explicados de forma práctica sobre el entorno

de Visual Studio 2012.

Este curso le enseñará entre otras cosas:

Las características fundamentales del lenguaje C#

Cómo crear aplicaciones Windows con Visual Studio 2010

Utilizar controles en sus aplicaciones

Trabajar con imágenes y gráficos en 2D y 3D

Desplegar las aplicaciones que desarrolle

Utilizar las clases que se incluyen en la librería de .NET

Acceder a datos provenientes de una base de datos

Conocer en qué consiste LINQ y cómo utilizarlo en C#

Cómo exponer funcionalidad a otras aplicaciones mediante servicios Web.


Pro

gram

ació

n V

isu

al II

12

UNIDAD I

INTRODUCCION A LA PLATAFORMA .NET

1.1 Visual Studio .NET

1.1.1 ¿Qué NO es .NET?

Antes de decir qué es .NET, es conveniente aclarar qué NO es .NET:

.NET no es un sistema operativo, como si lo es Microsoft Windows en sus distintas

versiones.

.NET no es un Lenguaje de Programación: si bien la plataforma Microsoft .NET

incluye lenguajes de programación de aplicaciones, su concepto es más amplio y va

más allá de éstos.

.NET no es un Entorno de Desarrollo: si bien la plataforma Microsoft .NET incluye

entornos de desarrollo integrados (IDEs), su concepto es más amplio y va más allá

de éstos.

.NET no es un servidor de aplicaciones (Application Server).

.NET no es un producto empaquetado que se pueda comprar como tal, sino que es

una plataforma que engloba distintas aplicaciones, servicios y conceptos y que en

conjunto permiten el desarrollo y la ejecución de aplicaciones.

1.1.2 ¿Qué es .NET?

Microsoft .NET es una plataforma de desarrollo y ejecución de aplicaciones. Esto quiere decir

que no sólo nos brinda todas las herramientas y servicios que se necesitan para desarrollar

modernas aplicaciones empresariales y de misión crítica, sino que también nos provee de

mecanismos robustos, seguros y eficientes para asegurar que la ejecución de las mismas sea

óptima. Los componentes principales de la plataforma .NET son:

Un entorno de ejecución de aplicaciones, también llamado “Runtime”, que es un

componente de software cuya función es la de ejecutar las aplicaciones .NET e

interactuar con el sistema operativo ofreciendo sus servicios y recursos.

Un conjunto de bibliotecas de funcionalidades y controles reutilizables, con una

enorme cantidad de componentes ya programados listos para ser consumidos por

otras aplicaciones.

Un conjunto de lenguajes de programación de alto nivel, junto con sus compiladores y

linkers, que permitirán el desarrollo de aplicaciones sobre la plataforma .NET.

Un conjunto de utilitarios y herramientas de desarrollo para simplificar las tareas más

comunes del proceso de desarrollo de aplicaciones


Pro

gram

ació

n V

isu

al II

13

Documentación y guías de arquitectura, que describen las mejores prácticas de diseño,

organización, desarrollo, prueba e instalación de aplicaciones .NET

A lo largo de esta capitulo se analizará cada uno de estos puntos con mayor detalle.

1.1.3 Arquitectura Framework .NET

En realidad .NET es mucho más que eso ya que ofrece un entorno gestionado de

ejecución de aplicaciones, nuevos lenguajes de programación y compiladores, y

permite el desarrollo de todo tipo de funcionalidades: desde programas de consola o

servicios Windows hasta aplicaciones para dispositivos móviles, pasando por

desarrollos de escritorio o para Internet. Son estos últimos de los que nos ocuparemos

en este curso. Pero antes conviene conocer los fundamentos en los que se basa

cualquier aplicación creada con .NET, incluyendo las que nos interesan.

Arquitectura Framework 2.0

En la imagen podemos ver las diferentes versiones del .Net Framework (empezando desde la

2.0) y las características que agregan a la programación. Como ya sabemos, con el Framework

2.0, con fecha de salida 07/11/2005.

1.1.4 El entorno de ejecución CLR

.NET ofrece un entorno de ejecución para sus aplicaciones conocido como Common Language Runtime o

CLR. La CLR, es la implementación de Microsoft de un estándar llamado Common Language


Pro

gram

ació

n V

isu

al II

14

Infrastructure o CLI. Éste fue creado y promovido por la propia Microsoft pero desde hace años es un

estándar reconocido mundialmente por el ECMA.

El CLR/CLI esencialmente define un entorno de ejecución virtual independiente en el que trabajan las

aplicaciones escritas con cualquier lenguaje .NET. Este entorno virtual se ocupa de multitud de cosas

importantes para una aplicación: desde la gestión de la memoria y la vida de los objetos hasta la

seguridad y la gestión de subprocesos.

Todos estos servicios unidos a su independencia respecto a arquitecturas computacionales convierten la

CLR en una herramienta extraordinariamente útil puesto que, en teoría, cualquier aplicación escrita para

funcionar según la CLI puede ejecutarse en cualquier tipo de arquitectura de hardware. Por ejemplo

Microsoft dispone de implementación de .NET para Windows de 32 bits, Windows de 64 bits e incluso

para Windows Mobile, cuyo hardware no tiene nada que ver con la arquitectura de un ordenador

común.

1.1.5 El lenguaje Intermedio y el CLS.

Al contrario que otros entornos, la plataforma .NET no está atada a un determinado lenguaje de

programación ni favorece a uno determinado frente a otros. En la actualidad existen implementaciones

para varias decenas de lenguajes que permiten escribir aplicaciones para la plataforma .NET. Los más

conocidos son Visual Basic .NET, C# o J#, pero existen implementaciones de todo tipo, incluso de

¡COBOL!.

Lo mejor de todo es que cualquier componente creado con uno de estos lenguajes puede ser utilizado de

forma transparente desde cualquier otro lenguaje .NET. Además, como ya se ha comentado, es posible

ejecutar el código .NET en diferentes plataformas y sistemas operativos.

¿Cómo se consigue esta potente capacidad?

Dentro de la CLI, existe un lenguaje llamado IL (Intermediate Language o Lenguaje Intermedio) que está

pensado de forma independiente al procesador en el que se vaya a ejecutar. Es algo parecido al código

ensamblador pero de más alto nivel y creado para un hipotético procesador virtual que no está atado a

una arquitectura determinada.

Cuando se compila una aplicación escrita en un lenguaje .NET cualquiera (da igual que sea VB, C# u otro

de los soportados), el compilador lo que genera en realidad es un nuevo código escrito en este lenguaje

intermedio. Así, todos los lenguajes .NET se usan como capa de más alto nivel para producir código IL.

Un elemento fundamental de la CLR es el compilador JIT (just-in-time). Su cometido es el de compilar

bajo demanda y de manera transparente el código escrito en lenguaje intermedio a lenguaje nativo del

procesador físico que va a ejecutar el código.

Al final, lo que se ejecuta es código nativo que ofrece un elevado rendimiento. Esto es cierto también

para las aplicaciones Web escritas con ASP.NET y contrasta con las aplicaciones basadas en ASP clásico

que eran interpretadas, no compiladas, y que jamás podrían llegar al nivel de desempeño que ofrece

ASP.NET.


Pro

gram

ació

n V

isu

al II

15

1.1.6 .NET Framework Class Library.

De muy poco serviría a los desarrolladores el contar con una plataforma de ejecución de aplicaciones tan

sofisticada y robusta como el CLR sin tener además un conjunto de funcionalidades y componentes

empaquetados listos para aprovechar y reutilizar en sus aplicaciones. Justamente ese es el propósito de

la .NET Framework Class Library (Biblioteca de Clases del .NET Framework), que provee cientos de tipos

básicos (clases e interfaces principalmente) orientados a objetos, extensibles mediante herencia,

independientes del lenguaje de programación de alto nivel que se desee utilizar.

La plataforma .NET nos ofrece infinidad de funcionalidades "de fábrica" que se utilizan como punto de

partida para crear las aplicaciones. Existen funcionalidades básicas (por ejemplo todo lo relacionado con

la E/S de datos o la seguridad) y funcionalidades avanzadas en las que se fundamentan categorías

enteras de aplicaciones (acceso a datos, creación de aplicaciones Web...).

Toda esta funcionalidad está implementada en forma de bibliotecas de funciones que físicamente se

encuentran en diversas DLL (bibliotecas de enlazado dinámico). A su conjunto se le denomina Base

Classes Library (Biblioteca de clases base o BCL) y forman parte integral de la plataforma .NET, es decir,

no se trata de añadidos que se deban obtener o adquirir aparte.

Componentes Internos Class Library

En la figura se aprecian los principales biblioteca de clases .NET:

System: raíz de todos los otros namespaces, y dentro del cual podemos encontrar la mayoria de

los namespaces correspondientes a la Base Class Library

System.Data y System.Xml: en conjunto, estos dos namespaces constituyen la tecnología

conocida como ADO.NET

System.Web: dentro de este namespace se encuentran todos los tipos necesarios para

programar aplicaciones y servicios web ASP.NET


Pro

gram

ació

n V

isu

al II

16

System.Windows.Forms: dentro de este namespace se encuentran todos los tipos necesarios

para programar aplicaciones de escritorio basadas en formularios y ventanas Windows.

1.1.7 Bibliotecas De Clases De ADO .NET

Componentes ADO .NET

El acceso a fuentes de datos es algo indispensable en cualquier lenguaje o plataforma de desarrollo. La

parte de la BCL que se especializa en el acceso a datos se denomina de forma genérica como ADO.NET.

Si usted ha programado con Visual Basic 6.0 o con ASP, ha empleado en su código con total seguridad la

interfaz de acceso a datos conocida como ADO (ActiveX Data Objects), puede que combinado con ODBC

(Open Database Connectivity). Si además es usted de los programadores con solera y lleva unos cuantos

años en esto es probable que haya usado RDO o incluso DAO, todos ellos métodos mucho más antiguos.

ADO.NET ofrece una funcionalidad completamente nueva, que tiene poco que ver con lo existente hasta

la fecha en el mercado. Sin embargo, con el ánimo de retirar barreras a su aprendizaje, Microsoft

denominó a su nuevo modelo de acceso a datos con un nombre similar y algunas de sus clases recuerdan

a objetos de propósito análogo en el vetusto ADO.

ADO.NET es un modelo de acceso mucho más orientado al trabajo desconectado de las fuentes de datos

de lo que nunca fue ADO. Si bien este último ofrecía la posibilidad de desconectar los Recordsets y

ofrecía una forma de serialización de estos a través de las diferentes capas de una aplicación, el

mecanismo no es ni de lejos tan potente como el que nos ofrece ADO.NET.

El objeto más importante a la hora de trabajar con el nuevo modelo de acceso a datos es el DataSet. Sin

exagerar demasiado podríamos calificarlo casi como un motor de datos relacionales en memoria.


Pro

gram

ació

n V

isu

al II

17

Aunque hay quien lo asimila a los clásicos Recordsets su funcionalidad va mucho más allá como se verá

en el correspondiente módulo.

1.1.8 LINQ

Arquitectura de LINQ

LINQ es quizás una de las características más novedosas introducidas en Microsoft .NET Framework en

los últimos años.

No solo se desarrollara aplicaciones usando LINQ siempre que pueda, no porque sea mejor que otras

formas de trabajar que encontrará en Microsoft .NET Framework, sino porque simplifica el código, acorta

los tiempos de desarrollo, y bajo mi particular punto de vista, permite que el desarrollador desarrolle

aplicaciones más productivas.

LINQ significa Language INtegrated Query, o lo que es lo mismo, lenguaje integrado de consultas.

Se trata de una de las novedades incluidas en Microsoft .NET Framework 3.5, y representa una forma

nueva de desarrollo tal y como la conocíamos hasta ahora.

LINQ está pensado desde la orientación a objetos, pero su objetivo fundamental es la manipulación y

trabajo con datos.

Cuando hablamos de datos siempre pensamos en bases de datos, pero LINQ tiene una implicación

mucho más generalista, de hecho, podemos trabajar con colecciones, matrices, etc.

Para que comprenda más aún la importancia de LINQ, diremos que la inmensa mayoría de las novedades

introducidas en Microsoft .NET Framework 3.5 tienen su razón de ser gracias a LINQ, y que LINQ jugará

un importante papel en las próximas novedades de Microsoft .NET Framework.


Pro

gram

ació

n V

isu

al II

18

A la hora de trabajar con datos, con LINQ tenemos la posibilidad de seleccionar, manipular y filtrar datos

como si estuviéramos trabajando con una base de datos directamente.

Evidentemente, podemos usar LINQ con bases de datos, pero también con matrices, colecciones de

datos, etc como decíamos antes.

En todo esto, Intellisense juega un papel muy importante evitando que cometamos errores a la hora de

escribir nuestras aplicaciones, errores como por ejemplo seleccionar el dato erróneo o el tipo de dato

inadecuado, ya que el compilador nos avisaría de estos y otros errores.

Por lo tanto, el desarrollo de aplicaciones con LINQ, permite diseñar aplicaciones más seguras a la hora

de trabajar con datos y sus tipos.

Orígenes de datos

Dentro de LINQ encontramos diferentes orígenes de datos dentro de Microsoft .NET Framework 3.5.

Estos orígenes de datos son los siguientes:

LINQ to Objects: representa el uso de LINQ sobre objetos.

LINQ to XML: representa el uso de LINQ sobre documentos XML.

ADO.NET y LINQ: dentro de este grupo encontramos los diferentes orígenes de datos de

LINQ que tienen relación directa con datos relacionales. Los orígenes de datos de LINQ y

ADO.NET son:

LINQ to DataSet: representa el uso de LINQ sobre DataSet.

LINQ to SQL: representa el uso de LINQ sobre orígenes de datos de SQL Server.

LINQ to Entities: representa el uso de LINQ sobre cualquier origen de datos, SQL Server,

Oracle, MySql, DB2, etc.

Como vemos, LINQ abarca más que el propio trabajo con datos de bases u orígenes de datos.

Así, con LINQ podemos manipular y trabajar con datos de objetos o de documentos XML. Este último

representa una importante ventaja para los desarrolladores de VB respecto a los desarrolladores de C#,

ya que el equipo de trabajo de VB ha hecho especial énfasis al trabajo de LINQ con documentos XML

motivado por el feedback recibido por la Comunidad de desarrolladores de todo el mundo.

1.1.9 Especificación común de lenguaje CLS

Para conseguir la interoperabilidad entre lenguajes no sólo llega con el lenguaje intermedio, sino que es

necesario disponer de unas "reglas del juego" que definan un conjunto de características que todos los

lenguajes deben incorporar. A este conjunto regulador se le denomina Common Language Specification

(CLS) o, en castellano, especificación común de los lenguajes.

Entre las cuestiones que regula la CLS se encuentran la nomenclatura, la forma de definir los miembros

de los objetos, los metadatos de las aplicaciones, etc... Una de las partes más importantes de la CLS es la

que se refiere a los tipos de datos.

Si alguna vez ha programado la API de Windows o ha tratado de llamar a una DLL escrita en C++ desde

Visual Basic 6 habrá comprobado lo diferentes que son los tipos de datos de VB6 y de C++. Para evitar

este tipo de problemas y poder gestionar de forma eficiente y segura el acceso a la memoria, la CLS


Pro

gram

ació

n V

isu

al II

19

define un conjunto de tipos de datos comunes (Common Type System o CTS) que indica qué tipos de

datos se pueden manejar, cómo se declaran y se utilizan éstos y de qué manera se deben gestionar

durante la ejecución.

Si nuestras bibliotecas de código utilizan en sus interfaces hacia el exterior datos definidos dentro de la

CTS no existirán problemas a la hora de utilizarlos desde cualquier otro código escrito en la plataforma

.NET.

Cada lenguaje .NET utiliza una sintaxis diferente para cada tipo de datos. Así, por ejemplo, el tipo común

correspondiente a un número entero de 32 bits (System.Int32) se denomina Integer en Visual Basic .NET,

pero se llama int en C#. En ambos casos representan el mismo tipo de datos que es lo que cuenta.

1.1.10 Tipos de .NET Framework

El .NET framework tiene tres variantes principales, todas descargables gratuitamente desde Internet

1 .NET Framework Redistributable Package: este es el mínimo componente de la plataforma .NET

que se necesita para poder ejecutar aplicaciones. Normalmente ésta es la variante que se instala

en los entornos productivos, una vez que el desarrollo y las pruebas de la aplicación han

finalizado.

Está compuesto por:

El entorno de ejecución de la plataforma .NET

Las bibliotecas de funcionalidad reutilizable

2 .NET Framework SDK: esta versión contiene herramientas de desarrollo de línea de comandos

(compiladores, depuradores, etc.), documentación de referencia, ejemplos y manuales para

desarrolladores de aplicaciones. Normalmente ésta variante se instala en los entornos de

desarrollo de aplicaciones, y es más útil a los programadores que a los usuarios finales. Para

poder instalar la versión SDK (Software Development Kit) es necesario instalar previamente el

Redistributable Package.

3 .NET Compact Framework: esta es una versión reducida del .NET Framework Redistributable,

especialmente pensada para ser instalada en dispositivos móviles como Pocket PC’s y

SmartPhones.

El .NET Framework puede ser instalado en cualquier sistema operativo de la familia Windows superior a

Windows 98. Para más información acerca de los prerrequisitos se puede consultar:

http://msdn.microsoft.com/netframework/technologyinfo/sysreqs/default.aspx


Pro

gram

ació

n V

isu

al II

20

Actualmente, Windows 2003 Server y Windows XP SP2 traen el .NET Framework preinstalado. Para más

información acerca de las descargas gratuitas, por favor consulte

http://msdn.microsoft.com/netframework/downloads/updates/default.aspx

1.9 ¿Dónde instalar el .NET Framework?

Instalación de Framework en aplicaciones

El .NET Framework debe estar instalado en cualquier dispositivo de hardware para que la ejecución de

una aplicación .NET sea posible. En el caso de las aplicaciones de escritorio (también llamadas “De

Formularios Windows”) y las aplicaciones de consola (aplicaciones cuya interfaz de usuario es una

consola de comandos), el Framework debe estar presente del lado del cliente (computadora donde se

ejecuta la parte de la aplicación que interactúa con el usuario), y en el servidor sólo en caso de que la

aplicación sea distribuida y tenga parte de su funcionalidad centralizada en una única computadora.

En el caso de las aplicaciones Web, el único requisito del lado del cliente es tener un navegador y una

conexión de red al servidor, el cual debe tener instalado el .NET Framework. Veremos más sobre

aplicaciones Web a lo largo del curso.

Para las aplicaciones móviles, que se ejecutan sobre Windows Mobile en algún dispositivo tipo Pocket PC

o SmartPhone, es necesario tener instalado el .NET Compact Framework en el dispositivo.

Actualmente hay 3 versiones de la plataforma Microsoft .NET:

La versión 1.0: fue liberada a principios del año 2002, e incluía la versión 1.0 del .NET

Framework, la versión 2002 de Visual Studio y varios lenguajes de programación

nuevos compatibles con la plataforma (como C#.NET y Visual Basic.NET)

La versión 1.1: fue liberada en 2003, aproximadamente un año después que su

predecesora. Esta versión introdujo el .NET Framework 1.1 junto con Visual Studio .NET


Pro

gram

ació

n V

isu

al II

21

2003, la primer versión del .NET Compact Framework y un nuevo lenguaje de

programación llamado J#.NET.

La versión 2.0: fue liberada a finales del año 2005, y es la primer gran renovación que

sufrió la plataforma en su tiempo de vida. Con la idea de ser una “evolución” en lugar

de una “revolución”, esta versión trajo consigo las versiones 2.0 del .NET Framework y

el .NET Compact Framework, asi como también una nueva versión de Visual Studio.

Ya existen planes en desarrollo para la próxima generación de la plataforma .NET, nombre código

“Orcas”, que verá la luz aproximadamente al mismo tiempo que el sistema operativo Windows Vista.

1.1.11 Versiones del .NET Framework

Existen varias versiones del .NET Framework: 1.0, 1.1, 2.0, 3.0 y 3.5. En estas dos últimas versiones, el

CLR es el mismo de la versión 2.0, pero con el agregado de 3 componentes más:

Versiones de arquitectura framewokzx

Lo interesante viene de la mano del Framework 3.0 y 3.5.El Framework 3.0, con fecha de salida

06/11/2006, incluye los siguientes agregados:


Pro

gram

ació

n V

isu

al II

22

Windows Communication Foundation (WCF): modelo de programación unificado para generar

aplicaciones orientadas a servicios. Permite a los programadores generar soluciones con

transacción seguras y de confianza, que se integren en diferentes plataformas y que interoperen

con las inversiones existentes. Lo más importante de WCF es que permite unificar las distintas

tecnologías de servicios, haciendo posible mantener el Servicio de Aplicación, más allá de la

implementación “física” del mismo (configurable).

Windows Presentation Foundation (WPF): proporciona a los programadores un modelo de

programación unificado con el que generar experiencias de cliente inteligentes de Windows, en

las que se incorpora la interfaz de usuario, multimedia y documentos. WPF a diferencia de

Windows Forms nos permite crear apliaciones más ricas en contenido y presentación para el

usuario.

Windows Workflow Foundation (WF): es un componente del Framework 3.0 que provee un

modelo de programación para construir aplicaciones basadas en Workflows o Flujos de

Trabajos. Un Workflow es una serie de actividades discretas involucrado en el proceso de

negocio.

CardSpace: es la implementación de Microsoft de un meta sistema de identidad que permite a

los usuarios elegir una de una serie de identidades que les pertenecen, y utilizarla en contextos

en que son aceptadas, independientemente de los sistemas de identidad subyacentes donde las

identidades se originan y utilizan. O sea, es una implementación integrada que permite hacer

que los usuarios se identifiquen en distintos sistemas, sin la necesidad de mantener un usuario y

contraseña en cada uno de ellos.

Como último tomamos lo más nuevo, el Framework 3.5, con fecha de salida 19/11/2007, incluye los

siguientes agregados:

LINQ: incorpora eficaces capacidades de consulta a la sintaxis de los lenguajes C# y Visual Basic

en forma de patrones de consulta estándar fáciles de aprender. Esta tecnología se puede

extender para que sea compatible con cualquier tipo de almacén de datos. .NET Framework 3.5

incluye ensamblados de proveedor de LINQ que habilitan el uso de LINQ para consultar

colecciones de .NET Framework (LINQ to Objects), bases de datos de SQL Server (LINQ to SQL),

conjuntos de datos ADO.NET (LINQ to DataSet) y documentos XML (LINQ to XML). Este es un

tema muy interesante por explorar, asique lo estaré retomando en próximos posts.

AJAX: ASP.NET agrega compatibilidad con el desarrollo de AJAX centrado en el servidor

mediante un conjunto de nuevos controles de servidor y nuevas API. Puede habilitar una página

ASP.NET 2.0 existente en AJAX agregando un control ScriptManager y un control UpdatePanel,

de modo que la página pueda actualizarse sin que sea necesario realizar una actualización de la

página completa.

REST: integración de REST en WCF.

Además modificaciones importantes en WCF, WPF y WF. Vale la pena destacar que actualmente se

encuentra disponible el Framework 3.5 SP1, con fecha de salida 11/08/2008, dicho Service Pack

además de arreglar errores provee nuevas


Pro

gram

ació

n V

isu

al II

23

Características:

ADO.NET Entity Framework: es una biblioteca de datos de alto nivel que aumenta el nivel de

abstracción que los desarrolladores necesitamos para trabajar con los datos en las bases de

datos relacionales. Brinda todas las clases y herramientas necesarias para poder trabajar en

nuestras aplicaciones con objetos, a partir de un modelo de datos subyacente en Base de Datos

relacionales. A diferencia de LINQ to SQL, ADO.Net EF no limita sus capacidades de Bases de

Datos Sql Server. (ya lo retomaremos)

ADO.NET Data Services: servicio de publicación y federación de datos con una interface

estándar usando REST. Expone un modelo de objetos (no una base de datos) sobre la web.

ASP.NET Dynamic Data: una característica que permite la creación rápida de aplicaciones web

dirigidas por datos (aplicaciones con ABMs). Permite la creación de aplicaciones web basándose

en ASP.NET WebForms y ASP.NET MVC.

ASP.NET Routing: define puntos de entrada a la application. Genera URLs basado en una tabla

de ruteo. Es aprovechado por ASP.NET.Se mejoró ASP.NET AJAX, WCF, WPF, WinForms.

1.1.12 Aplicaciones Windows Forms

Aplicación Windows

Las aplicaciones de escritorio son aquellas basadas en ventanas y controles comunes de Windows que se

ejecutan en local. Son el mismo tipo de aplicaciones que antes construiríamos con Visual Basic 6 u otros

entornos similares.

En la plataforma .NET el espacio de nombres que ofrece las clases necesarias para construir aplicaciones

de escritorio bajo Windows se denomina Windows Forms. Este es también el nombre genérico que se le

otorga ahora a este tipo de programas basados en ventanas.


Pro

gram

ació

n V

isu

al II

24

Windows Forms está constituido por multitud de clases especializadas que ofrecen funcionalidades para

el trabajo con ventanas, botones, rejillas, campos de texto y todo este tipo de controles habituales en las

aplicaciones de escritorio.

1.1.13 Aplicaciones Web Forms

Tradicionalmente las aplicaciones Web se han desarrollado siguiendo un modelo mixto que intercalaba

código HTML y JavaScript propio de páginas Web (parte cliente), junto con código que se ejecutaría en el

servidor (parte servidora). Este modelo contrastaba por completo con el modelo orientado a eventos

seguido por las principales herramientas de desarrollo de aplicaciones de escritorio.

En el modelo orientado a eventos se define la interfaz de usuario colocando controles en un contenedor

y se escribe el código que actuará como respuesta a las interacciones de los usuarios sobre estos

controles. Si conoce el diseñador de VB6 o de Windows Forms mencionado en el apartado anterior sabe

exactamente a qué nos referimos.

Hacer esto en una aplicación de escritorio no tiene mayor dificultad ya que todo el código se ejecuta en

el mismo lugar. La principal característica de las aplicaciones Web sin embargo es que se la interfaz de

usuario (lo que los usuarios de la aplicación ven) se ejecuta en un lugar diferente al código de la

aplicación que reside en un servidor. Para mayor desgracia estas aplicaciones se basan en el uso del

protocolo HTTP que es un protocolo sin estado y que no conserva la conexión entre dos llamadas

consecutivas.

Por ejemplo, el siguiente código ilustra el código que es necesario escribir en ASP para disponer de una

página que rellena una lista de selección con unos cuantos nombres (podrían salir de una base de datos y

aún sería más complicado), y que dispone de un botón que escribe un saludo para el nombre que se haya

elegido de la lista.


Pro

gram

ació

n V

isu

al II

25

Aplicación Web

1.2 CARACTERÍSTICAS DEL LENGUAJE C#

C# (leído en inglés “C Sharp” y en español “C Almohadilla”) es el nuevo lenguaje de propósito general

diseñado por Microsoft para su plataforma .NET. Sus principales creadores son Scott Wiltamuth y

Anders Hejlsberg, éste último también conocido por haber sido el diseñador del lenguaje Turbo Pascal y

la herramienta RAD Delphi.

Aunque es posible escribir código para la plataforma .NET en muchos otros lenguajes, C# es el único que

ha sido diseñado específicamente para ser utilizado en ella, por lo que programarla usando C# es mucho

más sencillo e intuitivo que hacerlo con cualquiera de los otros lenguajes ya que C# carece de elementos

heredados innecesarios en .NET. Por esta razón, se suele decir que C# es el lenguaje nativo de .NET

La sintaxis y estructuración de C# es muy parecida a la de C++ o Java, puesto que la intención de

Microsoft es facilitar la migración de códigos escritos en estos lenguajes a C# y facilitar su aprendizaje a

los desarrolladores habituados a ellos. Sin embargo, su sencillez y el alto nivel de productividad son

comparables con los de Visual Basic.

Un lenguaje que hubiese sido ideal utilizar para estas herramientas es Java, pero debido a problemas con

la empresa creadora del mismo -Sun-, Microsoft ha tenido que desarrollar un nuevo lenguaje que


Pro

gram

ació

n V

isu

al II

26

añadiese a las ya probadas virtudes de Java las modificaciones que Microsoft tenía pensado añadirle para

mejorarlo aún más y hacerlo un lenguaje orientado al desarrollo de componentes.

Con la idea de que los programadores más experimentados puedan obtener una visión general del

lenguaje, a continuación se recoge de manera resumida las principales características de C# Alguna de las

características aquí señaladas no son exactamente propias del lenguaje sino de la plataforma .NET en

general, y si aquí se comentan es porque tienen una repercusión directa en el lenguaje:

Sencillez: C# elimina muchos elementos que otros lenguajes incluyen y que son innecesarios en

.NET. Por ejemplo:

o El código escrito en C# es autocontenido, lo que significa que no necesita de ficheros

adicionales al propio fuente tales como ficheros de cabecera o ficheros IDL

o El tamaño de los tipos de datos básicos es fijo e independiente del compilador, sistema

operativo o máquina para quienes se compile (no como en C++), lo que facilita la

portabilidad del código.

o No se incluyen elementos poco útiles de lenguajes como C++ tales como macros,

herencia múltiple o la necesidad de un operador diferente del punto (.) acceder a

miembros de espacios de nombres (::)

Modernidad: C# incorpora en el propio lenguaje elementos que a lo largo de los años ha ido

demostrándose son muy útiles para el desarrollo de aplicaciones y que en otros lenguajes como

Java o C++ hay que simular, como un tipo básico decimal que permita realizar operaciones de

alta precisión con reales de 128 bits (muy útil en el mundo financiero), la inclusión de una

instrucción foreach que permita recorrer colecciones con facilidad y es ampliable a tipos

definidos por el usuario, la inclusión de un tipo básico string para representar cadenas o la

distinción de un tipo bool específico para representar valores lógicos.

Orientación a objetos: Como todo lenguaje de programación de propósito general actual, C#

es un lenguaje orientado a objetos, aunque eso es más bien una característica del CTS que de

C#. Una diferencia de este enfoque orientado a objetos respecto al de otros lenguajes como C++

es que el de C# es más puro en tanto que no admiten ni funciones ni variables globales sino que

todo el código y datos han de definirse dentro de definiciones de tipos de datos, lo que reduce

problemas por conflictos de nombres y facilita la legibilidad del código.

C# soporta todas las características propias del paradigma de programación orientada a

objetos: encapsulación, herencia y polimorfismo.


Pro

gram

ació

n V

isu

al II

27

En lo referente a la encapsulación es importante señalar que aparte de los típicos

modificadores public, private y protected, C# añade un cuarto modificador llamado internal,

que puede combinarse con protected e indica que al elemento a cuya definición precede sólo

puede accederse desde su mismo ensamblado.

Respecto a la herencia -a diferencia de C++ y al igual que Java- C# sólo admite herencia simple

de clases ya que la múltiple provoca más quebraderos de cabeza que facilidades y en la mayoría de

los casos su utilidad puede ser simulada con facilidad mediante herencia múltiple de interfaces. De

todos modos, esto vuelve a ser más bien una característica propia del CTS que de C#.

Orientación a componentes: La propia sintaxis de C# incluye elementos propios del diseño de

componentes que otros lenguajes tienen que simular mediante construcciones más o menos

complejas. Es decir, la sintaxis de C# permite definir cómodamente propiedades (similares a

campos de acceso controlado), eventos (asociación controlada de funciones de respuesta a

notificaciones) o atributos (información sobre un tipo o sus miembros)

Gestión automática de memoria: Como ya se comentó, todo lenguaje de .NET tiene a su

disposición el recolector de basura del CLR. Esto tiene el efecto en el lenguaje de que no es

necesario incluir instrucciones de destrucción de objetos. Sin embargo, dado que la destrucción

de los objetos a través del recolector de basura es indeterminista y sólo se realiza cuando éste

se active –ya sea por falta de memoria, finalización de la aplicación o solicitud explícita en el

fuente-, C# también proporciona un mecanismo de liberación de recursos determinista a través

de la instrucción using.

Seguridad de tipos: C# incluye mecanismos que permiten asegurar que los accesos a tipos de

datos siempre se realicen correctamente, lo que permite evita que se produzcan errores difíciles

de detectar por acceso a memoria no perteneciente a ningún objeto y es especialmente

necesario en un entorno gestionado por un recolector de basura. Para ello se toman medidas

del tipo:

o Sólo se admiten conversiones entre tipos compatibles. Esto es, entre un tipo y

antecesores suyos, entre tipos para los que explícitamente se haya definido un

operador de conversión, y entre un tipo y un tipo hijo suyo del que un objeto del

primero almacenase una referencia del segundo (downcasting) Obviamente, lo último

sólo puede comprobarlo en tiempo de ejecución el CLR y no el compilador, por lo que

en realidad el CLR y el compilador colaboran para asegurar la corrección de las

conversiones.

o No se pueden usar variables no inicializadas. El compilador da a los campos un valor

por defecto consistente en ponerlos a cero y controla mediante análisis del flujo de


Pro

gram

ació

n V

isu

al II

28

control del fuente que no se lea ninguna variable local sin que se le haya asignado

previamente algún valor.

o Se comprueba que todo acceso a los elementos de una tabla se realice con índices que

se encuentren dentro del rango de la misma.

o Se puede controlar la producción de desbordamientos en operaciones aritméticas,

informándose de ello con una excepción cuando ocurra. Sin embargo, para conseguirse

un mayor rendimiento en la aritmética estas comprobaciones no se hacen por defecto

al operar con variables sino sólo con constantes (se pueden detectar en tiempo de

compilación)

Instrucciones seguras: Para evitar errores muy comunes, en C# se han impuesto una serie de

restricciones en el uso de las instrucciones de control más comunes. Por ejemplo, la guarda de

toda condición ha de ser una expresión condicional y no aritmética, con lo que se evitan errores

por confusión del operador de igualdad (==) con el de asignación (=); y todo caso de un switch

ha de terminar en un break o goto que indique cuál es la siguiente acción a realizar, lo que evita

la ejecución accidental de casos y facilita su reordenación.

Sistema de tipos unificado: A diferencia de C++, en C# todos los tipos de datos que se definan

siempre derivarán, aunque sea de manera implícita, de una clase base común llamada

System.Object, por lo que dispondrán de todos los miembros definidos en ésta clase (es decir,

serán “objetos”)

Extensibilidad de tipos básicos: C# permite definir, a través de estructuras, tipos de datos para

los que se apliquen las mismas optimizaciones que para los tipos de datos básicos. Es decir, que

se puedan almacenar directamente en pila (luego su creación, destrucción y acceso serán más

rápidos) y se asignen por valor y no por referencia. Para conseguir que lo último no tenga

efectos negativos al pasar estructuras como parámetros de métodos, se da la posibilidad de

pasar referencias a pila a través del modificador de parámetro ref.

Extensibilidad de modificadores: C# ofrece, a través del concepto de atributos, la posibilidad de

añadir a los metadatos del módulo resultante de la compilación de cualquier fuente información

adicional a la generada por el compilador que luego podrá ser consultada en tiempo ejecución

a través de la librería de reflexión de .NET . Esto, que más bien es una característica propia de la

plataforma .NET y no de C#, puede usarse como un mecanismo para definir nuevos

modificadores.

Versionable: C# incluye una política de versionado que permite crear nuevas versiones de tipos

sin temor a que la introducción de nuevos miembros provoquen errores difíciles de detectar en


Pro

gram

ació

n V

isu

al II

29

tipos hijos previamente desarrollados y ya extendidos con miembros de igual nombre a los

recién introducidos.

Si una clase introduce un nuevo método cuyas redefiniciones deban seguir la regla de llamar a la

versión de su padre en algún punto de su código, difícilmente seguirían esta regla miembros de

su misma signatura definidos en clases hijas previamente a la definición del mismo en la clase

padre; o si introduce un nuevo campo con el mismo nombre que algún método de una clase

hija, la clase hija dejará de funcionar. Para evitar que esto ocurra, en C# se toman dos medidas:

o Se obliga a que toda redefinición deba incluir el modificador override, con lo que la

versión de la clase hija nunca sería considerada como una redefinición de la versión de

miembro en la clase padre ya que no incluiría override. Para evitar que por accidente

un programador incluya este modificador, sólo se permite incluirlo en miembros que

tengan la misma signatura que miembros marcados como redefinibles mediante el

modificador virtual. Así además se evita el error tan frecuente en Java de creerse haber

redefinido un miembro, pues si el miembro con override no existe en la clase padre se

producirá un error de compilación.

o Si no se considera redefinición, entonces se considera que lo que se desea es ocultar el

método de la clase padre, de modo que para la clase hija sea como si nunca hubiese

existido. El compilador avisará de esta decisión a través de un mensaje de aviso que

puede suprimirse incluyendo el modificador new en la definición del miembro en la

clase hija para así indicarle explícitamente la intención de ocultación.

Eficiente: En principio, en C# todo el código incluye numerosas restricciones para asegurar su

seguridad y no permite el uso de punteros. Sin embargo, y a diferencia de Java, en C# es posible

saltarse dichas restricciones manipulando objetos a través de punteros. Para ello basta marcar

regiones de código como inseguras (modificador unsafe) y podrán usarse en ellas punteros de

forma similar a cómo se hace en C++, lo que puede resultar vital para situaciones donde se

necesite una eficiencia y velocidad procesamiento muy grandes.

Compatible: Para facilitar la migración de programadores, C# no sólo mantiene una sintaxis muy

similar a C, C++ o Java que permite incluir directamente en código escrito en C# fragmentos de

código escrito en estos lenguajes, sino que el CLR también ofrece, a través de los llamados

Platform Invocation Services (PInvoke), la posibilidad de acceder a código nativo escrito como

funciones sueltas no orientadas a objetos tales como las DLLs de la API Win32. Nótese que la

capacidad de usar punteros en código inseguro permite que se pueda acceder con facilidad a

este tipo de funciones, ya que éstas muchas veces esperan recibir o devuelven punteros.


Pro

gram

ació

n V

isu

al II

30

ACTIVIDADES EXTRACLASE

En el siguiente subtema analizamos brevemente una introducción a la plataforma .NET.

Basándote en la lectura que realizaste a este subtema responde:

¿Qué no es .NET?:

.…………………………………..……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………

¿Qué es .NET?:

.…………………………………..……………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………

Describa en que consiste el entorno de ejecución intermedio CLR.

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

………………………………………………………

¿Cuál es la función del compilador JIT (just-in-time)?

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………

¿Cuál es el propósito del .Net Framework Class Library?

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………..

Describa los tipos principales del .Net Framework y explique cada uno de ellos.


Pro

gram

ació

n V

isu

al II

31

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………

Para la ejecución de una aplicación distribuida en .NET donde debe ser instalado el Framework.

Defina cada uno de los siguientes conceptos del lenguaje integrado de consultas LINQ.

LINQ.-

………………………………………………………………………………………………………………………………………………………...

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

………………………………………………….………………………………………….

LINQ OBJECTS.-

……………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………

LINQ TO XML.-

……………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………

LINQ ADO .NET.-

……………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………


Pro

gram

ació

n V

isu

al II

32

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………

Realice un cuadro comparativo entre las versiones 2.0, 3.0, 3.5, 4.0 del Framework de la plataforma .NET.

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………...………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

……………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………

Basándote en la lectura que realizaste a este subtema responde:

¿Describe cuatro características principales del lenguaje C#?:

.…………………………………..……………………………………………………………………………………………………………………………

………..…………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

……………………………………………………………………………………………..

Defina cada uno de los siguientes conceptos.

IDE..…………………………………..………………………………………………………………………………………………………………………

……………..……………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………..

Explorador de soluciones.-

………………………………………………………………………………………………………………………….………………………………………

…………………………………………………………………………………………………………………………………………………………………

………………………………………………………………………………………………………………………………………

Diseñador de proyectos.-

……………………………………………………………………………………………………………………………….…………………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………..………………………………………………………………………………………

……….

Vista de clases.-


Pro

gram

ació

n V

isu

al II

33

……………………………………………………………………………………………………………………………………………….…………………

…………………………………………………………………………………………………………………………………………………………………

……………………………………………………………………………….…………………………………………………………………………………

…………….

Examinador de objetos.-

..………………………………………………………………………………………………………………………………….……………………………

…………………………………………………………………………………………………………………………………………………………………

…………………………………………………………………………………………………………………………………………………………………

1.3 Introducción a Visual C #.

Microsoft Visual C# es un lenguaje de programación diseñado para crear una amplia gama de

aplicaciones que se ejecutan en .NET Framework. C# es simple, eficaz, con seguridad de tipos y orientado

a objetos.

Visual Studio admite Visual C# con un editor de código completo, plantillas de proyecto, diseñadores,

asistentes para código, un depurador eficaz y fácil de usar, además de otras herramientas. La biblioteca

de clases .NET Framework ofrece acceso a una amplia gama de servicios de sistema operativo y a otras

clases útiles y adecuadamente diseñadas que aceleran el ciclo de desarrollo de manera significativa.

Hasta ahora en el capítulo I hemos realizado una caracterización de la plataforma .net al inicio de este

capítulo se dio una introducción al lenguaje C# de aquí en adelante nos centraremos específicamente a

la plataforma de desarrollo .net con el lenguaje C# utilizando Visual Studio. Net 2012.

Para crear un nuevo proyecto existen dos formas uno desde la página de inicio y otra en menú archivo,

haga clic en el menú Archivo, elija Nuevo y haga clic en Proyecto.


Pro

gram

ació

n V

isu

al II

34

Cuadro de dialogo de nuevo proyecto

Seleccione el tipo de proyecto que desea realizar puede ser Consola, Windows, Web, WPF, Biblioteca de

clase, etc. Luego debe seleccionar el lenguaje a utilizar en la programación en nuestro caso utilizaremos

el lenguaje C#.

Luego debe especificar en nombre del proyecto, ubicación y nombre de la solución.

Cuando ponga el nombre a un proyecto es recomendable utilizar las siguientes

nomenclaturas: Aplicación Windows AppWinNombredelProyecto, aplicación Web

WebAppNombredelProyecto.


Pro

gram

ació

n V

isu

al II

35


Después de seleccionar una plantilla de proyecto y hacer clic en Aceptar, Visual Studio crea el proyecto y

todo está listo para comenzar la codificación pero antes vamos a realizar una introducción al entrono de

desarrollo IDE.

1.3.1 Entorno de desarrollo de Visual C #.


El entorno de desarrollo integrado (IDE) de Visual C# es un conjunto de herramientas de desarrollo

expuestas a través de una interfaz de usuario común. Algunas de las herramientas se comparten con

otros lenguajes de Visual Studio, y otras, como el compilador de C#, son únicas de Visual C#.


Pro

gram

ació

n V

isu

al II

36

IDE de Visual Studio .Net 2012

A continuación se detallan las herramientas y ventanas más importantes de Visual C#. Las ventanas de la

mayoría de estas herramientas se pueden abrir desde el menú Ver.

El Editor de código, para escribir código fuente.

El compilador de C#, para convertir el código fuente de C# en un programa ejecutable.

El depurador de Visual Studio, para probar el programa.

El Cuadro de herramientas y el Diseñador, para desarrollar rápidamente interfaces de usuario

con el mouse. Se puede arrastrar controles a la ventana desde la

Barra de herramientas, que se puede hacer visible haciendo clic

en el botón Cuadro de herramientas del margen derecho o en

su defecto en el menú ver.

El Explorador de soluciones, muestra todos los archivos del proyecto en una vista de árbol

jerárquica. Cuando se utiliza el menú Proyecto para agregar nuevos archivos al proyecto, se

verán reflejados en el Explorador de soluciones. Además de los archivos, el Explorador de

soluciones también muestra la configuración del proyecto y las referencias a las bibliotecas

externas que necesita la aplicación.


Pro

gram

ació

n V

isu

al II

37

Para obtener acceso a las páginas de propiedades

del Diseñador de proyectos, haga clic con el botón

secundario del mouse en el nodo Propiedades

del Explorador de soluciones y, a continuación,

haga clic en Abrir.

Utilice estas páginas para modificar opciones de

generación, requisitos de seguridad, detalles de

implementación y muchas otras propiedades del

proyecto.

Una solución puede tener agregado 1, 2 o más proyectos

incorporados dentro de una misma solución.

El Diseñador de proyectos, El compilador de C# no tiene ninguna ventana porque no es una

herramienta interactiva, pero puede establecer sus opciones en el Diseñador de proyectos.

Cuando se hace clic en Generar en el menú Generar, el IDE invoca el compilador de C#. Si la

generación se realiza correctamente, el panel de estado muestra un mensaje Generación

satisfactoria. Si se producen errores de generación, aparece la ventana Lista de errores aparece

debajo de la ventana del editor/diseñador con una lista de errores. Haga doble clic en un error

para ir a la línea de código fuente que presenta el problema. Presione F1 para consultar la

documentación de Ayuda correspondiente al error resaltado. El depurador tiene distintas

ventanas que muestran valores de variables e información de tipos a medida que se ejecuta la

aplicación. Puede utilizar la ventana Editor de código mientras depura el programa para

especificar una línea en la que desee hacer una pausa durante la ejecución en el depurador y

para recorrer el código línea a línea.


Pro

gram

ació

n V

isu

al II

38

La Vista de clases, para desplazarse por el código fuente según los tipos, no los archivos.

La Ventana Propiedades, para configurar propiedades y eventos en los controles de la interfaz

de usuario.

El Examinador de objetos, para ver los métodos y clases disponibles en las bibliotecas de

vínculos dinámicos, incluidos los ensamblados de .NET Framework y los objetos COM.


Pro

gram

ació

n V

isu

al II

39

Document Explorer, para explorar y buscar la documentación del producto en su equipo local y

en Internet.

Formularios, Cuando se crea un proyecto de formularios Windows Forms, Visual C# agrega de

forma predeterminada un formulario al proyecto y lo llama Form1. Los dos archivos que

representan el formulario se llaman Form1.cs y Form1.designer.cs. El código se escribe en

Form1.cs. El Diseñador de Windows Forms escribe en el archivo designer.cs el código que

implementa todas las acciones que se realizaron al arrastrar y colocar objetos desde el Cuadro

de herramientas.

Puede agregar un nuevo formulario haciendo clic en el elemento de menú Proyecto y

seleccionando Agregar Windows Forms. Cada formulario tiene dos archivos asociados.

Form1.cs, o como haya decido llamarlo, contiene el código fuente que se escribe para

configurar el formulario y sus controles, como cuadros de lista y cuadros de texto, y responde a

eventos tales como los clics en botones y las pulsaciones de teclas. En los proyectos de

formularios Windows Forms simples, la mayoría o incluso la totalidad de la codificación se hace

en este archivo.

El archivo Designer.cs contiene el código fuente que escribe el Diseñador de formularios

cuando se arrastran controles y se colocan en el formulario, cuando se establecen las

propiedades en la ventana Propiedades, etc. Normalmente, no debería modificar manualmente

este archivo.

El Editor de código y el Diseñador de Windows Forms utilizan la ventana principal

grande. Para alternar entre la vista de código y la vista Diseño, puede presionar F7 o

hacer clic en Código o Diseñador en el menú Ver. En la vista Diseño,

1.3.2 Estructura general de un programa en C #

Los programas en C# pueden constar de uno o varios archivos. Cada archivo puede contener cero o

varios espacios de nombres. Un espacio de nombres puede contener tipos como clases, estructuras,

interfaces, enumeraciones y delegados, además de otros espacios de nombres. A continuación, se

muestra el esqueleto de un programa en C# que contiene todos estos elementos.


Pro

gram

ació

n V

isu

al II

40


Pro

gram

ació

n V

isu

al II

41

1.4 Tipos de datos en C# .NET.

Visual C# 2010 o 2012 está totalmente integrado con .NET Framework, por tanto los tipos de datos que

podremos usar con este lenguaje serán los definidos en este "marco de trabajo", por este motivo vamos

a empezar usando algunas de las definiciones que nos encontraremos al recorrer la documentación que

acompaña a este lenguaje de programación.

Los tipos de datos que podemos usar en Visual C# 2012 son los mismos tipos de datos definidos en .NET

Framework y por tanto están soportados por todos los lenguajes que usan esta tecnología. Estos tipos

comunes se conocen como el Common Type System, (CTS), que traducido viene a significar el sistema de

tipos comunes de .NET.

Tipos primitivos.

Veamos en la siguiente tabla los tipos de datos definidos en .NET Framework y los alias utilizados en

Visual C# 2012.

Tipos de datos de .NET y su equivalencia en C#


Pro

gram

ació

n V

isu

al II

42

El único tipo de datos que no tiene un "alias" en C# es tipo DateTime, por tanto siempre usaremos el

definido en el propio .NET. Debemos tener en cuenta, al menos si el rendimiento es una de nuestra

prioridades, que las cadenas en .NET son inmutables, es decir, una vez que se han creado no se pueden

modificar y en caso de que queramos cambiar el contenido, .NET se encarga de desechar la anterior y

crear una nueva cadena, por tanto si usamos las cadenas para realizar concatenaciones (unión de

cadenas para crear una nueva), el rendimiento será muy bajo, si bien existe una clase en .NET que es

ideal para estos casos y cuyo rendimiento es superior al tipo string: la clase StringBuilder.

Variables y constantes.

Disponer de todos estos tipos de datos no tendría ningún sentido si no los pudiéramos usar de alguna

otra forma que de forma literal. Y aquí es donde entran en juego las variables y constantes.

Definamos brevemente estos conceptos.

Las constantes son valores que nunca cambian y pueden ser de dos tipos:

Constantes literales, por ejemplo, cuando usamos 12345, estamos usando un valor constante, ya que ese

número siempre tendrá el mismo valor.

Constantes con nombre, son constantes a las que le damos un nombre y tampoco pueden cambiar.

Por otro lado, las variables son como las constantes con nombres, pero su valor es variable, por tanto,

puede que no siempre tengan el mismo valor, de ahí que se llamen variables.

Declaración de constantes:

const int maximo = 12345678;

Declaración de variables:

Cuando declaramos variables en C#, estas estarán en un estado "no iniciado", es decir, no tendrán

ningún valor inicial asignado de forma automática, salvo cuando estas variables están definidas como

campos de una clase.

Por tanto, si queremos que en C# tengan un valor inicial, tendremos que asignarlos de forma expresa.

Por ejemplo:

int i;

decimal m;

int a, b, c;

int a = 10;


Pro

gram

ació

n V

isu

al II

43

int b = 12, c = 15;

decimal m = 22.5M; double d = 55.556;

decimal m = 22.5M;

double d = 55.556;

const int maximo = 12345678;

int i = maximo;

Tipo De Dato Char

Tal como comentamos anteriormente, el tipo char de C# es un caso especial, realmente es un carácter

Unicode, pero internamente es un valor int. Veamos primero cómo declarar variables (o constantes) de

tipo char y después veremos que realmente son enteros (o al menos que en algunas circunstancias se

comportan como tales):

char c1 = 'a';

char c2 = (char)49;

En la primera declaración utilizamos una constante literal para asignarla a una variable de tipo char. Esa

constante la indicaremos entre comillas simples.

En la segunda usamos una conversión explícita de un tipo numérico entero a un valor char.

Al ser un valor entero, podremos hacer operaciones aritméticas con variables de ese tipo, aunque el

resultado siempre será un valor entero, no un carácter. En este código sumamos el valor de las dos

constantes y lo asignamos en una variable de tipo int:

int i2 = c1 + c2;


Pro

gram

ació

n V

isu

al II

44

Si queremos volver a convertir el contenido de la variable i en un valor de tipo char tendremos que hacer

una conversión (cast) o bien usar la clase Convert.

char c3 = (char)i2;

char c4 = Convert.ToChar(i2);

Cadena de caracteres.

Las cadenas de caracteres en .NET, y por tanto en C#, se definen indicando la cadena entre comillas

dobles. Tal como vimos en la tabla 2.1, la instrucción para declarar cadenas es string:

string s1 = "Hola, ";

Tal como indicamos en el comentario de esa tabla, las cadenas de C# son inmutables, es decir una vez

que hemos creado una cadena y la modificamos, se creará una nueva cadena y se desechará la cadena

anterior.

Por ejemplo, si hacemos esto:

s1 = s1 + "mundo";


Pro

gram

ació

n V

isu

al II

45

1.5 Desarrollo de Aplicaciones con formularios Windows

Ejercicio 1

Crear un proyecto con el nombre AppWinPractica, agregar al formulario label,

cuadro de texto, botón desde la barra de herramientas, e imprimir en un

Mesaggebox.

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 AppWinPractica


Pro

gram

ació

n V

isu

al II

46

{

public partial class Form3 : Form

{

public Form3()

{

InitializeComponent();

}

private void button1_Click(object sender, EventArgs e)

{

string nombre=textBox1.Text,apellido = textBox2.Text;

string cadena=" Bienvenido al mundo de la programacion.NET";

string mensaje= nombre +" "+ apellido + cadena;

MessageBox.Show(mensaje);

}

}

}

Enumeraciones.

Una enumeración es una serie de constantes que están relacionadas entre sí. La utilidad de las

enumeraciones es más manifiesta cuando queremos manejar una serie de valores constantes con

nombre, es decir, podemos indicar un valor, pero en lugar de usar un literal numérico, usamos un

nombre, ese nombre es, al fin y al cabo, una constante que tiene un valor numérico.

En Visual C# 2010 las enumeraciones pueden ser de cualquier tipo numérico integral, incluso enteros sin

signo, aunque el valor predefinido es el tipo int.


Pro

gram

ació

n V

isu

al II

47

Ejercicio 2

Crear un proyecto con el nombre AppWinDos, agregar al formulario un

Combobox y un botón desde la barra de herramientas, e imprimir en un

Mesaggebox los días festivos de ese mes.


Pro

gram

ació

n V

isu

al II

48

using System;



using System.Data;


using System.Text;


namespace AppWinDos

{


{

public Form11()

{


}

int var = 0;

public enum meses : int

{

enero = 1,

febrero = 2,

marzo = 3,

abril = 4,

mayo = 5,

junio = 6,

julio = 7,

agosto = 8,

septiembre = 9,


Pro

gram

ació

n V

isu

al II

49

octubre = 10,

noviembre = 11,

diciembre = 12

}


{

meses mes;

mes = meses.enero;

if (comboBox1.SelectedIndex >= 0)

{

var = Convert.ToInt32(comboBox1.Text);

if (var == 1)

mes = meses.enero;

if (var == 2)

mes = meses.febrero;

if (var == 3)

mes = meses.marzo;

if (var == 4)

mes = meses.abril;

switch (mes)

{

case meses.enero: MessageBox.Show("rey de reyes");

break;

case meses.febrero: MessageBox.Show("carnaval");

break;

case meses.marzo: MessageBox.Show("marzo");

break;

case meses.abril: MessageBox.Show("semana santa");


Pro

gram

ació

n V

isu

al II

50

break;

default: MessageBox.Show("NO HAY FERIADO");

break;

}

}

else

{

MessageBox.Show("ELIGE UNA OPCION ANTES!!!!");

}

}

}

}

Arrays.

Los arrays (o matrices) nos permitirán agrupar valores que de alguna forma queremos que estén

relacionados entre sí.

Son variables que permiten almacenar un conjunto de datos del mismo tipo a la vez, su diferencia es en

la cantidad de columnas que cada uno de estos tipos contiene

Arreglos tipo lista

Un arreglo tipo lista se define como una variable que permite almacenar un conjunto de datos del mismo

tipo organizados en una sola columna y uno o más renglones.Una función puede tener parámetros de

salida (out)


Pro

gram

ació

n V

isu

al II

51

Los procesos normales con una lista o con sus elementos, incluyen declarar toda la lista, capturar sus

elementos, desplegarlos, realizar operaciones con ellos, desplegarlos, etc.

Declaración de arreglos tipo lista

int[] numeros;

numeros = new int[4];

int[] num2 = new int[3];

En ambos casos debemos usar new seguido del tipo de datos y entre corchetes el número de elementos

que tendrá el array. Ese número indicará el total de elementos que tendrá el array, pero debido a como

.NET trata los arrays, el índice inferior será cero y el índice superior será uno menos del número de

elementos que hemos indicado al crear el array.

num2[0] = 3;

num2[1] = 22;

string[] nombres = {"Pepe", "Juan", "Luisa"};

Arreglos tipo tabla

Un arreglo tipo tabla se define como un conjunto de datos del mismo tipo organizados en dos o mas

columnas y uno o más renglones.

La declaración de una tabla será de acuerdo al siguiente formato:


Pro

gram

ació

n V

isu

al II

52

Si el array es bidimensional (o con más dimensiones), también podemos inicializarlos al declararlo, pero

en este caso debemos usar doble juego de llaves:

string[,] nombres = { { "Juan", "Pepe" }, { "Ana", "Eva" } };

En este código tendríamos un array bidimensional con los siguientes valores:

nombres[0,0]= Juan

nombres[0,1]= Pepe

nombres[1,0]= Ana

nombres[1,1]= Eva

Operaciones con los Arreglos

Copy().

Para hacer la copia hemos usado el método CopyTo, al que le indicamos el array de destino, (que

previamente debe estar dimensionado con el número de elementos que recibirá), y el índice a partir del

cual queremos copiar ese array, en nuestro caso le indicamos la primera posición, que como sabemos es

la posición cero.

En el siguiente código podemos ver estos pasos:

int[] original = { 1, 2, 3, 4 };

int[] copia = new int[original.Length];

// Copiamos el original en la copia

original.CopyTo(copia, 0);

// Añadimos 5 elementos más

original = new int[original.Length + 5];

// Asignamos nuevamente lo copiado a partir del primer elemento

copia.CopyTo(original, 0);

Si el array contiene valores por valor, podemos usar otro método: Clone, ya que este método devuelve

una copia "superficial" del objeto en cuestión, en nuestro caso el array; esa copia superficial significa que


Pro

gram

ació

n V

isu

al II

53

solo copiará el contenido del array, si este tuviera referencia a objetos, no copiaría los objetos, solo las

referencias, (de todo esto de los objetos y referencias a objetos nos ocuparemos en la próxima lección),

pero el valor que devuelve ese método es del tipo object, es decir el tipo genérico de .NET, por tanto

tendríamos que hacer una conversión al tipo array, tal como vemos en este código:

int[] copia = (int[])original.Clone();

Una vez que hemos declarado un array y le hemos asignado valores, es posible que nos interese eliminar

esos valores de la memoria, para lograrlo, en C# podemos hacerlo de dos formas:

1. Redimensionando el array indicando que tiene cero elementos, aunque en el mejor de los

casos, si no estamos trabajando con arrays de más de una dimensión, tendríamos un array de

un elemento, ya que, como hemos comentado anteriormente, los arrays de .NET el índice

inferior es cero.

2. Asignar un valor null al array. Esto funciona en C# porque los arrays son tipos por referencia.

Sort().

Permite realizar la ordenación del vector en forma ascendente ejm.

int[] vectorA=new int[5];

Array.Sort(vectorA);

Reverse().

En el mismo caso que se puede ordenar un vector, se puede reordenar exactamente al revés de cómo

estaba ejm.


Array.Reverse(vectorA);

Length.

Permite determinar el tamaño o números de elementos de un vector ejm:


int ne = vectorA.Length


Pro

gram

ació

n V

isu

al II

54

Clear().

Permite borrar los elementos del vector ejm.


Array.Clear(vectorA,0,vectorA.Length);

Ejercicio 3

Crear un proyecto con el nombre AppWinVectores, agregar al formulario tres

listbox, cuatro label y un botón desde la barra de herramientas, realizar la suma

de dos vectores y agregar el resultado en un tercer vector.

using System;



using System.Data;



Pro

gram

ació

n V

isu

al II

55

using System.Text;


namespace AppWinVectores

{


{

public Form15()

{


}

int[] vec1 = new int[] { 3, 4, 3, 6, 5 };

int[] vec2 = new int[] { 4, 7, 56, 32, 45 };

int[] vec3 = new int[5];

public void sumavector(int[] vec1, int[] vec2, int[] vec3)

{

int a = vec1.Length;

for (int i = 0; i < a; i++)

{

vec3[i] = vec1[i] + vec2[i];

}

}


{

TextBox[] txt = new TextBox[5];


Pro

gram

ació

n V

isu

al II

56

sumavector(vec1, vec2, vec3);

int n = vec3.Length;

for (int i = 0; i < n; i++)

{

listBox3.Items.Add(vec3[i]);

//txt[i].Text = " "+vec3[i];

}

}

private void Form15_Load(object sender, EventArgs e)

{

int n = vec1.Length;

for (int j = 0; j < n; j++)

{

listBox1.Items.Add(vec1[j]);

listBox2.Items.Add(vec2[j]);

}

}

}

}


Pro

gram

ació

n V

isu

al II

57

Ejercicio 4

Crear un proyecto con el nombre AppOperacionesVectores, agregar al formulario

un cuadro de texto, dos label, 6 botones desde la barra de herramientas, realizar

el ingreso de cinco elementos al vector e imprimir el vector, en un contenedor

realizar las operaciones con vectores Copy, Sort, Reversa, Clear.

using System;



using System.Data;


using System.Linq;

using System.Text;


namespace AppOperacionesVector


Pro

gram

ació

n V

isu

al II

58

{

public partial class Arrays : Form

{


int pos = 0;

public Arrays()

{


}

private void btn_ingresar_Click(object sender, EventArgs e)

{

if (pos <= vectorA.Length - 1)

{

vectorA[pos] = int.Parse(textBox1.Text);

pos = pos + 1;

textBox1.Clear();

}

else

{

MessageBox.Show("elementos en el vector " + vectorA.Length.ToString(), "Tamano vector en limite", MessageBoxButtons.OK, MessageBoxIcon.Warning);

textBox1.Clear();

}

}

private void btn_imprimir_Click(object sender, EventArgs e)

{

string valores="";

for (int i = 0; i <= vectorA.Length -1; i++)


Pro

gram

ació

n V

isu

al II

59

valores = valores + vectorA[i].ToString();

MessageBox.Show("valores del vector " + "\n" + valores);

}


{

string valores="";

int[] copiavector = new int[vectorA.Length];

// Copiamos el original en la copia

vectorA.CopyTo(copiavector, 0);

for (int i = 0; i <= copiavector.Length-1;i++ )

valores = valores + "\n" + copiavector[i];

MessageBox.Show("Valores en el vector copiado " + valores);

}


{

Array.Sort(vectorA);

string valores = "";

for (int i = 0; i <= vectorA.Length - 1; i++)


MessageBox.Show("valores del vector usando funcione Sort " + "\n" + valores);

}


{

Array.Reverse(vectorA);

string valores = "";

for (int i = 0; i <= vectorA.Length - 1; i++)


Pro

gram

ació

n V

isu

al II

60


MessageBox.Show("valores del vector usando funcion Reverse " + "\n" + valores);

}


{

Array.Clear(vectorA,0,vectorA.Length);

}

}

}

Ejercicio 5

Crear un proyecto con el nombre AppWinMatriz, agregar al formulario tres

Datagridview, cuatro label y un botón desde la barra de herramientas, realizar la

multiplicación de matrices.


Pro

gram

ació

n V

isu

al II

61

using System;



using System.Data;


using System.Text;


namespace AppWinMatriz

{


{

public Form5()

{


}

int[,] m1 = new int[3, 3] { { 3, 4, 5 }, { 7, 8, 5 }, { 2, 4, 3 } };

int[,] m2 = new int[3, 3] { { 7, 5, 2 }, { 2, 1, 9 }, { 8, 6, 3 } };

int[,] m3 = new int[3, 3];

DataTable matriz1 = new DataTable("Matriz1");


{

for (int i = 0; i <= 2; i++)

{

for (int j = 0; j <= 2; j++)

{


Pro

gram

ació

n V

isu

al II

62

dataGridView1.Rows.Add();


dataGridView1[i, j].Value = "" + m1[i, j];


}

}

}

public void multiplicar(int[,] m1, int[,] m2, int[,] m3)

{

for (int i = 0; i <= 2; i++)

{

for (int j = 0; j <= 2; j++)

{

m3[i, j] = 0;

for (int k = 0; k <= 2; k++)

m3[i, j] += (m1[i, k] * m2[k, j]);

}

}

}


{

multiplicar(m1, m2, m3);

for (int i = 0; i <= 2; i++)

{


Pro

gram

ació

n V

isu

al II

63

for (int j = 0; j <= 2; j++)

{



listBox3.Items.Add(m3[i, j]);

}

}

}

}

}

En este ejercicio hemos utilizado la sentencia de repetición for.

Nota: Investigar el componente datagridview.

1.6 Sentencias de Control y Repetición

Sentencia if / else

La instrucción if de selección simple realiza una acción indicada solamente cuando la condición es

verdadera(true); de no ser así, se evita dicha acción. La instrucción if/else de selección doble permite al

programador especificar una acción a realizar cuando la condición es verdadera, y otra distinta cuando la

condición es falsa.

if (expresión)

{

sentencias a ejecutar;

si la expresión es cierta;


Pro

gram

ació

n V

isu

al II

64

}

else

{

sentencias a ejecutar;

si la expresión es falsa;

}

Sentencia Switch.

Si va a utilizarse un condicional múltiple para comparar un mismo dato respecto amúltiples valores de

referencia, en lugar de usar varios if/else anidados podemos recurrir a la instrucción switch, que tiene la

siguiente sintaxis:

switch(dato)

{

case valor1:

instrucciones;

case valor2:

instrucciones;

default:

instrucciones;

}


Pro

gram

ació

n V

isu

al II

65

Ejercicio 6

Crear un proyecto con el nombre AppWinSwitch, realizar un ejercicio que ingrese

un numero en un cuadro de texto del 1 al 4 e imprimir el resultado en letras.

using System;



using System.Data;


using System.Linq;

using System.Text;


namespace AppWinSwitch

{



Pro

gram

ació

n V

isu

al II

66

{

public Form2()

{


}


{

int num = int.Parse(textBox1.Text);

switch (num)

{

case 1: MessageBox.Show("Uno");

break;

case 2: MessageBox.Show("Dos");

break;

case 3: MessageBox.Show("Tres");

break;

case 4: MessageBox.Show("Cuatro");

break;

default: MessageBox.Show("No esta en el rango 1 -4");

break;

}

}

}

}


Pro

gram

ació

n V

isu

al II

67

While.

Una estructura de repetición también llamada estructura de ciclo permite al programador especificar

que un programa debe repetir una acción mientras cierta condición sea verdadera. Sintaxis:

Mientras existan más artículos en la lista de compras

Comprar el siguiente artículo

while(condición)

{

Sentencias;

}

Int i=1;

While(i<=10)

{

i++

}

Do-While.

La instrucción do…while es similar a la instrucción while; ya que el programador evalua la condición de

continuación de ciclo al principio, antes de ejecutar el cuerpo del ciclo. Si la condición es falsa, el cuerpo

del ciclo while nunca se ejecutara. La estructura de repetición do..while evalúa la condición de

continuación de ciclo después de ejecutar el cuerpo del ciclo, por lo tanto el cuerpo del ciclo siempre se

ejecutara una vez

do {

sentencias;

} while(condición);


Pro

gram

ació

n V

isu

al II

68

Int i=1;

do{

i++;

}While(i<=10)

For.

Especifica los detalles sobre la repetición controlada por contador en una sola línea de código.

for(int n = 1; n <= 10; n++)

{

sentencias;

}

Ejercicio 7

Crear un proyecto con el nombre AppDoWhile, realizar un ejercicio que imprima

los cinco números consecutivos.


Pro

gram

ació

n V

isu

al II

69

namespace AppDoWhile

{


{

public Form17()

{


}


{

for (int i = 0; i <= 5; i++)

{

MessageBox.Show("Número: " + i);

}

}

}

}

Foreach

Finalmente, en cuanto a bucles se refiere, tenemos la instrucción foreach.

Ésta se dirige especialmente a los casos en que se precisa recorrer todos los elementos de una matriz o

una colección, por ejemplo:

foreach(string nombre in nombres)

{

sentencias;

}


Pro

gram

ació

n V

isu

al II

70

foreach (string dispositivo in checkedListBox1.CheckedItems)

des += "" + dispositivo;

Ejercicio 8

Crear un proyecto con el nombre AppWinForeach, realizar un ejercicio que

imprima los ítems seleccionados en un checklistbox.

namespace AppWinForeach

{


{

public Form18()

{


}

string lista;


Pro

gram

ació

n V

isu

al II

71


{

foreach (string des in checkedListBox1.CheckedItems)

{

lista += des;

}

listBox1.Items.Add(lista);

lista = "";

}

}

}

Estructuras.

Las estructuras pueden contener los mismos miembros que las clases, aunque algunos de ellos se

comporten de forma diferente o al menos tengan algunas restricciones, como que los campos definidos

en las estructuras no se pueden inicializar al mismo tiempo que se declaran o no pueden contener

constructores "simples", ya que el propio compilador siempre se encarga de crearlo, para así poder

inicializar todos los campos definidos.

Otra de las características de las estructuras es que no es necesario crear una instancia para poder

usarlas, ya que es un tipo por valor y los tipos por valor no necesitan ser instanciados para que existan.


Pro

gram

ació

n V

isu

al II

72

El siguiente código define una estructura llamada Punto en la que tenemos dos campos públicos.

struct Punto

{

public int X;

public int Y;

}

Para usarla podemos hacer algo como esto:

Punto p;

p.X = 100;

p.Y = 75;

También podemos usar new al declarar el objeto:

Punto p = new Punto();

Aunque en las estructuras, usar new, sería algo redundante y por tanto no necesario.

Como Usar las estructuras

Tal como hemos comentado las estructuras son tipos por valor, para usar los tipos por valor no es

necesario instanciarlos explícitamente, ya que el mero hecho de declararlos indica que estamos creando

un nuevo objeto en memoria. Por tanto, a diferencia de las clases o tipos por referencia, cada variable

definida como un tipo de estructura será independiente de otras variables declaradas, aunque no las

hayamos instanciado.

Esta característica de las estructuras nos permite hacer copias "reales", no una copia de la referencia (o

puntero) al objeto en memoria, como ocurre con los tipos por referencia.

Veámoslos con un ejemplo:

Punto p = new Punto(100, 75);

Punto p1;


Pro

gram

ació

n V

isu

al II

73

p1 = p;

p1.X = 200;

// p.X vale 100 y p1.X vale 200

Ejercicio 9

Crear un proyecto con el nombre AppWinEstructura, agregar al formulario tres

cuadros de textos, tres label dos botones desde la barra de herramientas.

Realizar una estructura pública y una privada que permita el ingreso de los datos

de un libro titulo, autor y precio e imprimir en un Mesaggebox.

using System;



using System.Data;


Pro

gram

ació

n V

isu

al II

74


using System.Text;


namespace AppWinEstructura

{


{

public Form2()

{


}

// Declaracion de una estructura publica

struct libro

{

public string titulo;

public string autor;

public int precio;

}

// Decalaracion de una estructura privada

struct libro_privado

{

private string Titulo;

private string Autor;

private int Precio;

public libro_privado(string t, string a, int p)

{

Titulo = t;


Pro

gram

ació

n V

isu

al II

75

Autor = a;

Precio = p;

}

public string titulo

{

get

{

return this.Titulo;

}

set

{

this.Titulo = value;

}

}

public string autor

{

get { return this.Autor;}

set { this.Autor = value;}

}

public int precio

{

get {return this.Precio;}

set {this.Precio = value;}

}

}


{


Pro

gram

ació

n V

isu

al II

76

libro mylibro = new libro();

mylibro.titulo = textBox1.Text;

mylibro.autor = textBox2.Text;

mylibro.precio = int.Parse(textBox3.Text);

MessageBox.Show(mylibro.titulo + " "+ mylibro.autor + " "+ mylibro.precio.ToString());

}


{

string t = textBox1.Text;

string a = textBox2.Text;

int p = int.Parse(textBox3.Text);

libro_privado mylibro = new libro_privado(t,a,p);

MessageBox.Show(mylibro.titulo + " "+mylibro.autor+" "+mylibro.precio.ToString());

}

}

}


Pro

gram

ació

n V

isu

al II

77

Ejercicio 10

Crear un proyecto con el nombre AppPerson, realizar una lista de estructuras.

Lista de estructuras.

Construir una aplicación que cumpla con los requisitos siguientes:

Declarar un tipo estructura Person (Persona) que contenga la siguiente información de una persona:

- nombre

- apellido

- edad

- número de seguro social

Implementar un procedimiento que reciba la estructura antes definida y llenarla con la información

proporcionada por el usuario.

Implementar un método que reciba las estructuras Person y devuelva la más antigua.

Nota: uno de los algoritmos más conocidos y sencillos para organizar es Bubble Sort o organizar a su

elección.


Pro

gram

ació

n V

isu

al II

78

using System;



using System.Data;


using System.Text;


namespace AppPerson

{


{

/// Declaracion globales

cliente[] persona = new cliente[20];

cliente[] aux = new cliente[20];

int i = 0;

public Form1()

{



Pro

gram

ació

n V

isu

al II

79

}

public struct cliente

{

public string nombre;

public string apellido;

public int edad;

public int social;

};

public void llenar(string nom,string apel,int ed,int soc)

{

persona[i].nombre = nom;

persona[i].apellido = apel;

persona[i].edad = ed;

persona[i].social = soc;

}

public void borrar()

{

textBox1.Text = "";

textBox2.Clear();

textBox3.Text = "";

textBox4.Text = "";

}

public void ordenar()

{


Pro

gram

ació

n V

isu

al II

80

for(int m=0;m<persona.Length;m++)

{

for (int y = 1; y <persona.Length; y++)

{

if (persona[m].social < persona[y].social)

{

aux[m] = persona[m];

persona[m] = persona[y];

persona[y] = aux[m];

}

}

}

MessageBox.Show(persona[0].nombre + persona[0].social,"Es el registro mayor");

}


{

string no,ap;

int so,ex;

no = textBox1.Text;

ap = textBox3.Text;

ex = int.Parse(textBox3.Text);

so = int.Parse(textBox4.Text);

llenar(no, ap, ex, so);

borrar();

MessageBox.Show("Registro Guardado Exitosamente");


Pro

gram

ació

n V

isu

al II

81

i++;

}


{

Ordenar();

}

}

}

1.7 Manejo de Excepciones estructuradas.

En Visual C# 2010 se utiliza un tratamiento estructurado de excepciones, de esta forma podemos

detectar los errores que se produzcan en nuestras aplicaciones de una forma más "ordenada".

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, por último,

independientemente de que se produzca o no una excepción, podemos ejecutar el código que

incluyamos en el bloque finally.

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. Por tanto podemos crear un "manejador" de excepciones usando

los tres bloques, usando try y catch o usando try y finally.

Veamos ahora con más detalle cada uno de estos bloques y que es lo que podemos hacer en cada uno de

ellos.


Pro

gram

ació

n V

isu

al II

82

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:

Bloque finally

En este bloque podemos indicar las instrucciones que queremos que se ejecuten, se produzca o no una

excepción. De esta forma nos aseguramos de que siempre se ejecutará un código, por ejemplo para

liberar recursos, se haya producido un error o no.

En este código tenemos tres capturas de errores diferentes y un bloque finally que siempre se ejecutará,

se produzca o no un error:

try

{

int i = int.Parse(textBox1.Text);

int j = int.Parse(textBox2.Text);

int k = i / j;

}

catch (Exception error)

{

MessageBox.Show(error.Message.ToString());

}


Pro

gram

ació

n V

isu

al II

83

1.8 Uso componentes Textbox, Label, Groupbox, Radiobutton. Realizar un programa que permita realizar las operaciones matemáticas

Ejercicio 11

Crear un proyecto con el nombre AppWinOperacionesMatematicas,

agregar al formulario label, cuadro de texto, radiobuttons, botón desde

la barra de herramientas, realizar la codificación para realizar las

operaciones matemáticas utilizando procedimientos e imprimir en un

Mesaggebox.

using System;



using System.Data;


using System.Text;


namespace AppWinOperacionesMatematicas


Pro

gram

ació

n V

isu

al II

84

{


{

public Form1()

{


}

private void btn_calcular_Click(object sender, EventArgs e)

{

try

{

if (addition.Checked)

Suma();

if (subtraction.Checked)

Resta();

if (multiplication.Checked)

Multiplicacion();

if (division.Checked)

Division();

if (remainder.Checked)

Resto();

}

catch(Exception cause )

{

textBox3.Text = "";


Pro

gram

ació

n V

isu

al II

85

textBox4.Text = cause.Message;

}

}

private void Suma()

{

int num1 = int.Parse(textBox1.Text);


int res = num1+num2;

textBox3.Text = textBox1.Text + "+" + textBox2.Text;

textBox4.Text = res.ToString();

}

private void Resta()

{



int res = num1 - num2;

textBox3.Text = textBox1.Text + "-" + textBox2.Text;


}

private void Multiplicacion()

{



int res = num1 * num2;

textBox3.Text = textBox1.Text + "*" + textBox2.Text;


Pro

gram

ació

n V

isu

al II

86


}

private void Division()

{



int res = num1 / num2;

textBox3.Text = textBox1.Text + "/" + textBox2.Text;


}

private void Resto()

{



int res = num1 % num2;

textBox3.Text = textBox1.Text + "%" + textBox2.Text;


}

}

}


Pro

gram

ació

n V

isu

al II

87

1.9 Uso componentes Textbox, Listbox, Label, Groupbox, Radiobutton. .

Ejercicio 12

Crear un proyecto con el nombre AppWinRestaurant,

simular a un restaurante donde deseamos un plato seleccionando los

ingredientes. Con el botón Añadir >>, si se desea excluir el ingrediente del

plato con el botón Excluir <<, si se desea añadir un ingrediente que no

esté en la lista de ingredientes presionamos el botón Especial.

Presionamos F4 para obtener las propiedades de nuestro formulario

Name le ponemos el nombre de frm_restaurant,

Texto escribimos Arme su plato preferido,

StartPosicion CenterScreen.

Agregamos los componentes a nuestro formulario, de la pantalla superior con las

siguientes propiedades:


Pro

gram

ació

n V

isu

al II

88

COMPONENTE PRPIEDADES VALOR

Label1

Label2

Label3

Text

Text

Text

plato

ingredientes

plato

Listbox1

Listbox2

Name

Name

lsb_ingredientes

lsb_plato

Button1

Buton2

Button3

Button4

Button5

Name

Text

Name

Text

Name

Text

Name

Text

Name

Text

btn_anadir

añadir >>

btn_excluir

excluir <<

btn_nuevo

nuevo plato

btn_especial

especial

btn_finalizar

finalizar armado plato

Radiobutton1

Radiobutton1

Name

Text

Name

Text

rbt_comer

comer aqui

rbt_llevar

para llevar

Checkbox1

Checkbox2

Checkbox3

Name

Text

……..

……..

Ckb_plastico

Plástico

Ckb_aluminio / Aluminio

Ckb_isopor / Isopor


Pro

gram

ació

n V

isu

al II

89

Checkbox4

Checkbox5

Checkbox5

……..

……..

……..

Ckb_jugo / Jugo

Ckb_cerveza / Cerveza

Ckb_vino / Vino

using System;



using System.Data;


using System.Text;


namespace AppWinRestaurante

{

public partial class frm_restaurant : Form

{

public frm_restaurant()

{


groupBox2.Enabled = false;

}

private void frm_restaurant_Load(object sender, EventArgs e)

{


Pro

gram

ació

n V

isu

al II

90

lsb_ingredientes.Items.Add("Ajo");

lsb_ingredientes.Items.Add("Aceite");

lsb_ingredientes.Items.Add("Brocoli");

lsb_ingredientes.Items.Add("Espageti");

lsb_ingredientes.Items.Add("Sal");

lsb_ingredientes.Items.Add("Queso Parmasano");

lsb_ingredientes.Items.Add("Salsa Blanca");

lsb_ingredientes.Items.Add("Oregano");

}

private void btn_anadir_Click(object sender, EventArgs e)

{

if (lsb_ingredientes.SelectedIndex >= 0)

{

if((this.lsb_plato.FindString((string)lsb_ingredientes.SelectedItem)) == -1)

{

this.lsb_plato.Items.Add(lsb_ingredientes.SelectedItem);

}

}

else

{

MessageBox.Show("seleccione el ingrediente");

}


Pro

gram

ació

n V

isu

al II

91

}

private void btn_excluir_Click(object sender, EventArgs e)

{

if (this.lsb_plato.SelectedIndex >= 0 )

{

this.lsb_plato.Items.Remove(this.lsb_plato.SelectedItem);

}

}

private void rbt_comer_CheckedChanged(object sender, EventArgs e)

{

if (rbt_comer.Checked == true)

{

groupBox2.Enabled = false;

}

else

{

groupBox2.Enabled = true;

}

}

private void btn_nuevo_Click(object sender, EventArgs e)

{

DialogResult result;


Pro

gram

ació

n V

isu

al II

92

result = MessageBox.Show("¿Desea armar un plato nuevo?","Sr",MessageBoxButtons.YesNo );

if(result == DialogResult.Yes)

{

this.lsb_plato.Items.Clear();

edt_plato.Text = "";

}

}

private void btn_especial_Click(object sender, EventArgs e)

{

Form2 frm_i = new Form2();

frm_i.Show();

}

}

}


Pro

gram

ació

n V

isu

al II

93

1.10 Uso Mensajes MessageBox.

Realizar un programa en el cual se ingresa su nombre y presenta un mensaje de saludo con dos

botones y se debe seleccionar cualquiera de ello, luego debe mostrar otro mensaje que diga

cual botón selecciono.

Ejercicio 13

Crear un proyecto con el nombre AppMessageBox,

simular un ingrediente que no esté en la lista de ingredientes

presionamos el botón Especial.

using System;



using System.Data;


using System.Text;



Pro

gram

ació

n V

isu

al II

94

namespace WinAppMenssagesBox

{

public partial class frm_nuevo : Form

{

public frm_nuevo()

{


}


{

/* mensaje sencillo

MessageBox.Show("Hola "+textBox1.Text);*/

// mensaje con botones

MessageBox.Show("hola " + textBox1.Text,"mensaje con botones",MessageBoxButtons.YesNo);

DialogResult resul;

resul= MessageBox.Show("hola " + textBox1.Text,"mensaje con botones",MessageBoxButtons.YesNo);;

if (resul == DialogResult.Yes)

MessageBox.Show("presiono si", "boton Si");

else

MessageBox.Show("presiono no","boton No");

textBox1.Clear();


Pro

gram

ació

n V

isu

al II

95

}

}

}

1.11 Uso de componente TabControl.

Ejercicio 14

Realizar un programa en el cual se ingrese dos valores y el resultado

deberá aparecer en el siguiente tab al presionar el botón siguiente.

using System;



using System.Data;


using System.Text;



Pro

gram

ació

n V

isu

al II

96

namespace deber

{


{

public Form1()

{


}

float n1, n2, area;


{

TabPage pag2 = new TabPage();

Label lb1 = new Label();

TextBox txt1 = new TextBox();

n1 = float.Parse( textBox1.Text);

n2 = float.Parse(textBox2.Text);

area = n1 * n2;

txt1.Text = "" + area;

pag2.Text = "Resultado";

lb1.Text = "Area calculada";

txt1.Location = new System.Drawing.Point(106, 24);

txt1.ReadOnly=true;

lb1.Location = new System.Drawing.Point(16, 24);

lb1.Size = new System.Drawing.Size(224, 96);


Pro

gram

ació

n V

isu

al II

97

pag2.Controls.Add(txt1);

pag2.Controls.Add(lb1);

tabControl1.TabPages.Add(pag2);

tabControl1.SelectTab(this.tabControl1.TabIndex + 1);

}

}

}

1.12 Uso de componente listBox, checkedListBox, ComboBox.

Ejercicio 15

Realizar un programa que permita lista en un listbox los elementos de un

computador seleccionados al presionar el botón GUARDAR.


Pro

gram

ació

n V

isu

al II

98

using System;



using System.Data;


using System.Text;


namespace programas_utsam

{


{

public Form9()

{


}

string proc;

string mem;

string disco;

string lista;

string video;

string video1;

string cad;


{proc = radioButton1.Checked ? radioButton1.Text : radioButton2.Checked ? radioButton2.Text : radioButton3.Checked ? radioButton3.Text : radioButton4.Text;mem = radioButton5.Checked ? radioButton5.Text : radioButton6.Checked ? radioButton6.Text : radioButton7.Checked ? radioButton7.Text : radioButton8.Text;


Pro

gram

ació

n V

isu

al II

99

if (comboBox1.SelectedIndex >= 0)

{

disco = comboBox1.SelectedText;

}

foreach (string des in checkedListBox1.CheckedItems)

{

lista += des;

}

if (checkBox1.Checked == true)

{

video = checkBox1.Text;

}

if (checkBox2.Checked == true)

{

video1 = checkBox2.Text;

}

cad = proc + mem + disco + lista + video + video1;

listBox1.Items.Add(cad);

}

}

}


Pro

gram

ació

n V

isu

al II

100

1.13 Uso de componente dataGridView, checkedListBox, ComboBox.

Ejercicio 16

Realizar un programa que genere una factura de los elementos

seleccionados de las partes de un computador, el cual debe cargar en el

datagridview todos lo elementos seleccionados al presionar el botón

generar luego debe realizar la suma total a pagar de los productos al

presionar calcular total.

using System;



using System.Data;


using System.Text;



Pro

gram

ació

n V

isu

al II

101

namespace practica3

{

public partial class factura : Form

{

public string [] vector=new string [30];

public int col;

public int p1 = 200;

public int tarv = 350;

public int tars = 150;

public int par = 40;




public int mem1 = 8;


public int cont;



public int moni1 = 130;




public int pre, monitor, n, me, accesorios1, accesorios2, accesorios3; String che;

String x, y, z;

public factura()

{



Pro

gram

ació

n V

isu

al II

102

}


{

che = "";cont = 0;monitor = 0;pre = 0;

accesorios1 = 0; accesorios2 = 0; accesorios3 = 0;

x = "";y = "";z = "";me = 0;

if (radioButton1.Checked)

{

x = radioButton1.Text;

pre = p1;

}

else

{


{


pre = p2;

}

else

{


{


pre = p3;

}

else


Pro

gram

ació

n V

isu

al II

103

{


{


pre = p4;

}

}

}

}


{

y = radioButton5.Text;

me = mem1;

}

else

{


{


me = mem2;

}

else

{


{


me = mem3;

}


Pro

gram

ació

n V

isu

al II

104

else

{


{


me = mem4;

}

}

}

}

z = comboBox1.SelectedItem.ToString();

if (comboBox1.SelectedIndex == 0)

{

monitor = moni1;

}


{

monitor = moni2;

}


{

monitor = moni3;

}


{

monitor = moni4;

}

foreach (String des in checkedListBox1.CheckedItems)


Pro

gram

ació

n V

isu

al II

105

{

vector[cont] = des;

cont = cont + 1;

}

col = 0;

dataGridView1.Rows.Add() ;

dataGridView1[0, col].Value = "1";

dataGridView1[1, col].Value = x;

dataGridView1[2, col].Value = pre;

dataGridView1[3, col].Value = pre;

col = col + 1;



dataGridView1[1, col].Value = y;

dataGridView1[2, col].Value = me;

dataGridView1[3, col].Value = me;

col = col + 1;



dataGridView1[1, col].Value = z;

dataGridView1[2, col].Value = monitor;

dataGridView1[3, col].Value = monitor;

n = vector.Length;

for (int i = 0; i < n; i++)

{

if (vector[i]=="Tarjeta de video")

{


Pro

gram

ació

n V

isu

al II

106

col = col + 1;



dataGridView1[1, col].Value = "Tarjeta de video";

dataGridView1[2, col].Value = tarv ;

dataGridView1[3, col].Value = tarv ;

accesorios1 = tarv;

}

if (vector[i]=="Tarjeta de Sonido")

{

col = col + 1;



dataGridView1[1, col].Value = "Tarjeta de Sonido";

dataGridView1[2, col].Value = tars ;

dataGridView1[3, col].Value = tars;

accesorios2 = tars;

}

if (vector[i]=="Parlantes")

{

col = col + 1;



dataGridView1[1, col].Value = "Parlantes";

dataGridView1[2, col].Value = par ;

dataGridView1[3, col].Value = par;

accesorios3 = par;

}


Pro

gram

ació

n V

isu

al II

107

}

}

public enum precio : int

{

lg14 =250, lg17=300,ssg14=240,ssg17=310

}

public enum memoria : int

{

baja = 5, media = 15, mediaalta = 40, alta = 85

}


{

double total, subtotal; double IVA;

IVA = 0;

subtotal = 0;

total = 0;

subtotal = pre + me + monitor + accesorios1 + accesorios2 + accesorios3;

IVA = subtotal * 0.12;

textBox1.Text = "" + subtotal;

textBox2.Text = "" + IVA;

total = subtotal + IVA;

textBox3.Text = "" +total;

}

}

}


Pro

gram

ació

n V

isu

al II

108

1.14 Uso de componente ProgressBar y Timer.

Ejercicio 17

Realizar un programa que genere proceso de carga en unn tiempo

determinado.

using System;



using System.Data;


using System.Text;


namespace progresBar

{


{

public Form13()

{



Pro

gram

ació

n V

isu

al II

109

}

int inc2 = 0;


{

timer1.Enabled = true;

}

private void timer1_Tick(object sender, EventArgs e)

{

inc2++;

this.progressBar1.Value+=1;

if (inc2 >= 170)

{

this.Hide();

timer1.Enabled = false;

}

}

}

}


Pro

gram

ació

n V

isu

al II

110

1.15 Control de textbox. Permite el ingreso de un tipo flotante con dos decimales Ej. 25,52

private void textBox1_KeyPress(object sender, KeyPressEventArgs e)

{

if (e.KeyChar == 8)

{

e.Handled = false;

return;

}

int nd = 0;

bool id = false;

for (int i = 0; i < textBox2.Text.Length; i++)

{

if (textBox2.Text[i] == ',')

id = true;

if (id && nd++ >= 2)

{

e.Handled = true;

return;

}

}

if (e.KeyChar >= 48 && e.KeyChar <= 57)


Pro

gram

ació

n V

isu

al II

111

e.Handled = false;

else

if (e.KeyChar == 44)

e.Handled = (id);

else

e.Handled = true;

}


Pro

gram

ació

n V

isu

al II

112

ACTIVIDADES EXTRACLASE

TIPOS DE DATOS EN C# .NET

¿Cuáles son los tipos de datos primitivos?

……………………………………………………………………………………………………………………………………………………

……………………………………………………………………………………………………

………………………………………………………………………………………………

……………………………………………………………………………………………………………………………………………………

…………………..………………………………………………………………………………

…………………………………………………………………………………………

¿Cuándo debemos utilizar los tipos de enumeraciones.

……………………………………………………………………………………………………………………………………………………

……………………………………………………………………………………………………

………………………………………………………………………………………………

……………………………………………………………………………………………………………………………………………………

…………………..………………………………………………………………………………

……………………………………………………………………………………………

¿ Que son los Arrays?.

……………………………………………………………………………………………………………………………………………………

……………………

……………………………………………………………………………………………………………………………………………………

………………………

……………………………………………………………………………………………………………………………………………………

……………………

……………………………………………………………………………………………………………………………………………………

………………………

INSTRUCCIONES DE CONTROL Y REPETICIÓN

Mediante ejemplos, realice un resumen de las estructuras de control.

IF / ELSE

SWITCH


Pro

gram

ació

n V

isu

al II

113

WHILE

DO-WHILE

FOR

FOREACH

ESTRUCTURAS

Mediante ejemplos, realice lo siguiente.

Realice lo siguiente mediante ejemplos, declarar

un tipo estructura Person (Persona) que

contenga la siguiente información de una

persona:

Declarar una lista de estructuras usando List<>.


Pro

gram

ació

n V

isu

al II

114

MANEJO DE ERRORES

Defina cada uno de los siguientes conceptos y explique cuando deberíamos usar el manejo de

errores y realice un ejemplo.

Bloque try

……………………………………………………………………………………………………………………………………………………

……………………………………………………………………………………………………

………………………………………………………………………………………………

……………………………………………………………………………………………………………………………………………………

…………………..

Bloque catch

……………………………………………………………………………………………………………………………………………………

……………………………………………………………………………………………………

………………………………………………………………………………………………

……………………………………………………………………………………………………………………………………………………

……………………

Bloque finally

……………………………………………………………………………………………………………………………………………………

……………………………………………………………………………………………………

……………………………………………………………………………………………

……………………………………………………………………………………………………………………………………………………

……


Pro

gram

ació

n V

isu

al II

115

DESARROLLO DE PRÁCTICAS

PRACTICAS:

Desarrolla la solución a los siguientes prácticas, creando en un solo proyecto.

Práctica 1: Creación y uso de métodos

Objetivos

Al final de esta práctica, usted será capaz de:

Crear y hacer llamadas a métodos con y sin parámetros.

Utilizar distintos mecanismos para pasar parámetros.

Requisitos previos

Antes de realizar la práctica debe estar familiarizado con los siguientes temas: Creación

y uso de variables.

Instrucciones de C#

Uso de procedimientos y funciones en métodos que devuelven valores

En este ejercicio definirá y usará procedimientos para realizar una de las seis operaciones

matemáticas, al presionar el botón calcular en el cuadro operación deberá salir la operación

matemática, en el cuadro resultado será el resultado de las operación seleccionada

Luego realice el mismo ejercicio pero en lugar de utilizar procedimientos utilice funciones.


Pro

gram

ació

n V

isu

al II

116

Práctica 2: Creación y uso de componentes RadioButton,

CheckBox, checkListBox.

Objetivos


Crear y utilizar los componentes mencionados anteriormente.

Requisitos previos

Antes de realizar la práctica debe estar familiarizado con los siguientes temas: Uso

de componentes CheckListBox , Foreach.

Selección de las partes de un computador

Realizar una aplicación que permita seleccionar las partes de un computador, en el grupo de

procesadores existen cuatro tipos de procesadores el usuario deberá seleccionar uno de ellos, al

igual que la memoria, disco, y accesorios como teclado, Mouse, micrófono.

Solo los controladores raid y grabación de video son opcionales el resto debe estar validado para

que se realice la selección el usuario.

Luego al presionar el botón guardar deberá registrarse en un listbox los datos seleccionados.


Pro

gram

ació

n V

isu

al II

117

Práctica 3: Creación de una factura

Objetivos


Utilizar el componente datagirdView, y simular una factura de

compra.

Requisitos previos

Antes de realizar la práctica debe investigar utilizar el componente datagirdView.

Factura de un Computador

Realiza lo siguiente el usuario escogerá el procesador de su gusto, este internamente tendrá un precio al

igual que la memoria, el monitor.

Al escoger los accesorios estos también tienen un precio, cuando se presiona el botón generar factura el

dataGridView deberá llenarse con la información que el usuario selecciono y el costo de cada uno de

estos componentes.

Al presionar el botón calcular total, debera realizar la suma de todos los totales de la factura, y debera

mostrar en el cuadro Subtotal de la compra, el IVA de la compra y el total a pagar.


Pro

gram

ació

n V

isu

al II

118

Práctica 4: Creación y uso de componentes RadioButton,

CheckBox, checkListBox, Arrays.

Objetivos


Crear y utilizar los componentes mencionados anteriormente y

arrays list.

Restaurant

Realizar una aplicación que permita seleccionar los ingredientes para una pizza a la elección del

cliente, para cada ingrediente que se agregué tendrá un precio, si desea un ingrediente extra

deberá aparecer un segundo formulario Fig. 2 en el cual se ingresara el ingrediente y el costo,

este ingrediente extra deberá mostrarse en el listboxs de plato.

Debe seleccionarse si el pedido es para llevar o para comer aquí, si es para comer aquí las

opciones de envase deberán estar deshabilitados, si es para llevar deberá habilitarse los envases.


Pro

gram

ació

n V

isu

al II

119

Fig. 2

Al finalizar para calcular el total a pagar este debe ser la suma de los ingredientes utilizados más el

costo de los envases y las bebidas.

NOTA: Ud puede utilizar vectores / matrices / o arraylist, queda a su elección


Pro

gram

ació

n V

isu

al II

120

DESARROLLO DE EJERCICIOS

EJERCICIOS:

Desarrolla la solución a los siguientes problemas creando en un solo proyecto.

Realizar la codificación en C# de las siguientes series matemáticas para ello necesitaras la

librería MATCH:

Ejercicio 1:

Una serie geométrica es una serie en la cual cada término se obtiene

multiplicando el anterior por una constante, llamada razón. Ejemplo (con

constante 1/2):

Ejercicio 2:

Una serie alternada es una serie donde los términos alternan el signo. Ejemplo:

Ejercicio 3:

Una fórmula permite determinar si una persona tiene un peso normal, bajo o

excedido.

La fórmula es la siguiente:

X=Estatura (en cm.)-Peso (en Kg.)

100

El valor de X es un coeficiente que se relaciona con la edad de la persona de la siguiente

manera:

Hasta 20 años Más de 20 hasta 30 Más de 30 hasta 40 Más de 40

Peso normal X entre 0,90 y 1,10 X entre 0,85 y 1,15 X entre 0,80 y 1,10 X entre 0,75 y 1,10

http://es.wikipedia.org/wiki/Serie_geom%C3%A9trica

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


Pro

gram

ació

n V

isu

al II

121

TUTORÍAS PROGRAMADAS

Bajo peso X más de 1,10 X más de 1,15 X más de 1,10 X más de 1,10

Excedido X menos de 0,90 X menos de 0,85 X menos de 0,80 X menos de 0,75

Confeccionar un programa para que a partir del ingreso de los datos: estatura (en cm), peso (en

Kg) y edad (en años), informe si la persona tiene un peso normal, bajo o excedido.

Por ejemplo si se ingresa Estatura: 180 cm, Peso: 70 kg, Edad: 28, se calculará:

180 – 70=110 / 100 = 1,1. Como la edad está entre 20 y 30, X = 1,1 es Peso Normal.

Consulte en su centro de información o a su tutor el horario de los encuentros presenciales, y/o

virtuales (Chat) o las consultas por teléfono. Anote a continuación para que lo tenga en cuenta

en el desarrollo de este tema:

Fecha Hora Actividad


Pro

gram

ació

n V

isu

al II

122

UNIDAD DIDÁCTICA

2

CLASES Y OBJETOS

Tiempo estimado de estudio:

32 Horas

programacion i guia- cap i

Education