Introducción a Visual Studio .NET y C

VISUAL STUDIO .NET
2012
Guía de Estudio
C# - ADO .Net - LINQ - SQL SERVER - WPF

EI | Ing. Joffre Cartuche C Programación Visual
ProgramaciónVisualII
2
PROGRAMACIÓN
VISUAL
C# .Net
Guía de Estudio

3
ÍNDICE

4

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

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

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.

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

9
UNIDAD DIDÁCTICA
1
INTRODUCCIÓN A
VISUAL STUDIO
.NET
Tiempo estimado de estudio:
32 Horas

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

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.

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

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

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.

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

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.

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.

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

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

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

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:

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

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.

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.

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

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.

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

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

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.

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.

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

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

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.

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.

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

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.

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.

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.

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.

40

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#

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;

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;

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

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

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.

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.

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,

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

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)

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:

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

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

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;

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

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

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

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

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

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.

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");
private void Form5_Load(object sender, EventArgs e)
{
for (int i = 0; i <= 2; i++)
{
for (int j = 0; j <= 2; j++)
{

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

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;

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

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
{

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

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

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.

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

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;

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.

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;

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;

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;

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;}
}
}
{

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

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.

Introducción a Visual Studio .NET y C

Introducción a Visual Studio .NET y C

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (6)

Similar a Introducción a Visual Studio .NET y C

Similar a Introducción a Visual Studio .NET y C (20)

Último

Último (20)

Introducción a Visual Studio .NET y C