Lenguaje de Programación

SERVICIO NACIONAL DE ADIESTRAMIENTO EN TRABAJO INDUSTRIAL
COMPUTACIN E
INFORMTICA
MANUAL DE APRENDIZAJE
LENGUAJE DE
PROGRAMACIN I
CDIGO: 89001562
Profesional Tcnico
LENGUAJE DE PROGRAMACIN I
TABLA DE CONTENIDO
I. ANALIZAR EL ENTORNO DE TRABAJO CON MICROSOFT VISUAL STUDIO. ............ 7
1.1. DEFINIR EL CONCEPTO DE VISUAL NET. ....................................................................... 8
1.2. ANALIZAR LA ESTRUCTURA DEL FRAMEWORK. .......................................................... 8
1.3. INSTALAR Y TRABAJAR CON EL ENTORNO DE DESARROLLO DE VISUAL NET. 9
FUNDAMENTO TERICO. .................................................................................................... 14
DEFINIR EL CONCEPTO DE VISUAL NET. ............................................................................. 14
ANALIZAR LA ESTRUCTURA DEL FRAMEWORK. ............................................................... 15
INSTALAR Y TRABAJAR CON EL ENTORNO DE DESARROLLO DE VISUAL NET....... 23
II. DIFERENCIAR LA PROGRAMACIN POR CONSOLA Y CON FORMULARIOS. ........ 28
2.1. DEFINICIN DE UN PROYECTO EN VISUAL NET. ....................................................... 29
2.2. ELABORAR PROGRAMA EN MODO CONSOLA. ........................................................... 31
2.3. DISEAR Y PROGRAMAR UN FORMULARIO. ............................................................... 47
FUNDAMENTO TERICO: .................................................................................................... 57
Definicin de un proyecto en Visual Net. .................................................................................... 57
Elaborar programa en modo consola. ......................................................................................... 63
Disear y programar un formulario. ............................................................................................. 72
III. PROGRAMAR ESTRUCTURAS CONDICIONALES. ....................................................... 85
3.1. TRABAJAR CON CONSTANTES Y VARIABLES. ............................................................ 86
3.2. IDENTIFICAR LOS TIPOS DE DATOS QUE EXISTEN EN VISUAL NET. ................... 87
3.3. ANALIZAR LA IMPORTANCIA DE UNA ESTRUCTURA CONDICIONAL. ................... 88
FUNDAMENTO TERICO. .................................................................................................. 100
Trabajar con constantes y variables. ........................................................................................ 100
IDENTIFICAR LOS TIPOS DE DATOS QUE EXISTEN EN VISUAL NET: ........................ 108
ANALIZAR LA IMPORTANCIA DE UNA ESTRUCTURA CONDICIONAL. ........................ 117
IV. PROGRAMAR ESTRUCTURAS REPETITIVAS. ............................................................ 140
4.1. DEFINIR UNA ESTRUCTURA REPETITIVA: .................................................................. 141
4.2. TIPOS DE ESTRUCTURAS REPETITIVAS EN VISUAL NET...................................... 141
4.3. ELABORAR CASOS PRCTICOS UTILIZANDO ESTRUCTURAS REPETITIVAS. 142
TIPOS DE ESTRUCTURAS REPETITIVAS EN VISUAL NET. ............................................ 158
DEFINIR UNA ESTRUCTURA REPETITIVA. ......................................................................... 158
ELABORAR CASOS PRCTICOS UTILIZANDO ESTRUCTURAS REPETITIVAS. ........ 169
V. PROGRAMAR ESTRUCTURAS ANIDADAS SIMPLES Y COMPLEJAS. .................... 190
5.1. DEFINIR LA IMPORTANCIA DE ANIDAR CORRECTAMENTE DOS O MS
ESTRUCTURAS. ......................................................................................................................... 191
5.2. DESARROLLAR ESTRUCTURAS ANIDADAS PARA LA SOLUCIN DE
PROBLEMAS. .............................................................................................................................. 192
FUNDAMENTO TERICO: .................................................................................................. 195
Definir la importancia de anidar correctamente dos o ms estructuras.............................. 195
DESARROLLAR ESTRUCTURAS ANIDADAS PARA LA SOLUCIN DE PROBLEMAS.
197
VI. ELABORAR PROCEDIMIENTOS PARA RESOLVER CASOS PRCTICOS. .............. 200
6.1. IDENTIFICAR LA IMPORTANCIA DE UN PROCEDIMIENTO. .................................... 201
6.2. PROGRAMAR PROCEDIMIENTOS PARA RESOLVER CASOS PRCTICOS........ 202
Identificar la importancia de un procedimiento. ....................................................................... 220
PROGRAMAR PROCEDIMIENTOS PARA RESOLVER CASOS PRCTICOS. .............. 223
ESCUELA DE TECNOLOGAS DE LA INFORMACIN 5


01
I. ANALIZAR EL ENTORNO DE TRABAJO CON MICROSOFT

VISUAL STUDIO.
En esta tarea trataremos las siguientes operaciones:

Definir el concepto de Visual Net.
Analizar la estructura del Framework.
Instalar y trabajar con el entorno de desarrollo de Visual Net.
Equipos y Materiales:
Computadora con microprocesadores core 2 Duo o de mayor
capacidad.
Sistema operativo Windows.
Acceso a internet.
Software de maquetacin y desarrollo de pginas web.
Orden de Ejecucin:
Definir el concepto de Visual Net.
Analizar la estructura del Framework.
Instalar y trabajar con el entorno de desarrollo de Visual Net.

1.1. DEFINIR EL CONCEPTO DE VISUAL NET.
Visual Basic es hoy el lenguaje de programacin ms popular del mundo.
.Net conduce a la tercera generacin de Internet. La primera generacin

consisti en trabajar con informacin esttica que poda ser consultada a travs
de exploradores como si de un tabln de noticias se tratara. La segunda
generacin se ha basado en que las aplicaciones pudieran interaccionar con
las personas; sirva como ejemplo los famosos carros de compra. La tercera
generacin se caracterizara por aplicaciones que puedan interaccionar con
otras aplicaciones; por ejemplo una reunin de negocios, su aplicacin de
contactos interaccionara con su aplicacin de calendario que, a su vez,
interaccionara con una aplicacin de reserva de billetes para viajar en avin,
que consultara a su aplicacin preferencias de usuario por si tuviera que
cancelar alguna actividad ya programada.
Precisamente, el principio de .Net es que los sitios Web aislados y los

diferentes dispositivos trabajen conectados a travs de Internet para ofrecer
soluciones mucho ms ricas. Esto se conseguir gracias a la aceptacin de los
estndares abiertos basados en XML. (Extensible Markup Languaje Lenguaje
extensible para describir documentos). De esta manera, Internet se convierte
en una fuente de servicios, no slo de datos.
En definitiva, Internet y XML han dado lugar a una nueva fase de la informtica
en la que los datos del usuario residen en Internet, no en un ordenador
personal, y se puede acceder a ellos desde cualquier ordenador de sobremesa,
porttil, telfono mvil o agenda de bolsillo (PDA: Personal Digital Assistant).
Ello se debe fundamentalmente a que XML ha hecho posible que se puedan
crear aplicaciones potentes, para ser utilizadas por cualquiera, desde cualquier
lugar.
1.2. ANALIZAR LA ESTRUCTURA DEL FRAMEWORK.
.NET Framework es una plataforma de desarrollo para compilar aplicaciones

para Windows, Windows Phone, Windows Server y Windows Azure. Est
formado por Common Language Runtime (CLR) y la biblioteca de clases de
.NET Framework, que incluye clases, interfaces y tipos de valor que son
compatibles con una amplia gama de tecnologas. .NET Framework
proporciona un entorno de ejecucin administrado, un desarrollo e
implementacin simplificados y la integracin con una gran variedad de
lenguajes de programacin, incluidos Visual Basic y Visual C#.
Se requiere una estructura, no solo para facilitar el desarrollo de aplicaciones,

sino tambin para hacer que el proceso de encontrar un servicio Web e
integrarlo en una aplicacin resulte transparente para usuarios y

desarrolladores: .NET Framework proporciona esa estructura.
Segn se puede ver en la figura siguiente, .NET Framework es un componente

de desarrollo multilenguaje y un entorno de ejecucin:
1.3. INSTALAR Y TRABAJAR CON EL ENTORNO DE DESARROLLO DE

VISUAL NET.
La instalacin de esta versin es un proceso realmente sencillo. Lejos queda la

instalacin de la versin 2.003 que era realmente engorrosa, as que vamos a
seguir estos sencillo pasos para instalar nuestro Visual Basic.
Todo lo referente a las versiones Express de Microsoft se encuentran en la

pgina Web: http://www.microsoft.com/express as que nos iremos a esta
pgina:

Este es el centro de todo el mundo "Express" de Microsoft, vamos a hacer clic

en el men "Download" que aparece en la barra y que te he marcado con un
recuadro rojo para acceder a los programas que conforman el Visual Studio
2.010:
Tenemos dos formas de instalar el programa: conectado a Internet con

instalacin en lnea o descargando el DVD y luego realizando la instalacin en
local.

Por experiencia he visto que la instalacin Web no os ha funcionado en todos

los casos as que este ao vamos a cambiar y nos vamos a descargar el DVD
completo, as haremos todo de una vez. Seleccionaremos la parte inferior en la
que pone "All - Offline Install ISO image file" y luego la versin en espaol:
Se abrir la habitual ventana de descarga de ficheros:
As que lo descargaremos completo, ya vez que tiene 1,71 GB as que un poco

de paciencia pero mejor tenerlo en nuestro equipo descargado. Una vez
descargado tenemos un fichero con extensin .ISO que es un fichero de
imagen para grabarlo en un DVD. Podemos evitarnos esto de una forma muy
sencilla, nos descargaremos uno de los descompresores ms conocidos y que
se llama WinRAR. Lo descargaremos desde la pgina www.WinRAR.es y lo
instalamos.

Tambin nos valdra un programa para montar imgenes "ISO" como unidades
pero as lo podemos hacer de una forma rpida y sencilla. Al ejecutarlo como
ves en la pantalla anterior le asocia los ficheros con extensin "ISO" que es lo
que queremos. As que una vez descargada la imagen de .NET e instalado
este descompresor, asociando las extensiones ISO, podemos irnos al
administrador de archivos para indicar que nos descomprima el DVD que nos
hemos descargado en una carpeta. Para eso solo pincharemos con el botn
derecho del ratn para indicar en el men contextual:
Ya lo tenemos descomprimido as que nos vamos a la carpeta y hacemos

doble clic sobre el fichero "Setup.Hta" que nos mostrar esta pantalla:

As que finalmente pulsaremos en "Visual Basic 2010 Express".
Al cabo de unos momentos tendremos el asistente de instalacin en pantalla:
Pulsamos en "Siguiente" para comenzar la instalacin...

Y al cabo de unos minutos nos mostrar que el proceso ha finalizado...
Puede que nos pida reinicio, lo hacemos y ya tenemos nuestro Visual Basic
2010 instalado. Hasta aqu ha sido todo muy fcil.
FUNDAMENTO TERICO.
DEFINIR EL CONCEPTO DE VISUAL NET.

Visual Basic .NET (VB.NET) es un lenguaje de programacin orientado a
objetos que se puede considerar una evolucin de Visual Basic implementada
sobre el framework .NET. Su introduccin result muy controvertida, ya que
debido a cambios significativos en el lenguaje VB.NET no es retrocompatible
con Visual Basic, pero el manejo de las instrucciones es similar a versiones
anteriores de Visual Basic, facilitando as el desarrollo de aplicaciones ms
avanzadas con herramientas modernas.
La gran mayora de programadores de VB.NET utilizan el entorno de desarrollo
integrado Microsoft Visual Studio en alguna de sus versiones (desde el primer
Visual Studio .NET hasta Visual Studio .NET 2012, que es la ltima versin de
Visual Studio para la plataforma .NET), aunque existen otras alternativas, como
SharpDevelop (que adems es libre).
Al igual que con todos los lenguajes de programacin basados en .NET, los
programas escritos en VB .NET requieren el Framework .NET o Mono para
ejecutarse.
Visual Basic 2010 ofrece soporte para entorno de ejecucin dinmico..
VB 2010 forma parte de Microsoft Silverlight. visual basic es un lenguaje de

programacion que permite realizar diferentes programas de registro anudados.

ANALIZAR LA ESTRUCTURA DEL FRAMEWORK.
La palabra inglesa "framework" (marco de trabajo) define, en trminos

generales, un conjunto estandarizado de conceptos, prcticas y criterios para
enfocar un tipo de problemtica particular que sirve como referencia, para
enfrentar y resolver nuevos problemas de ndole similar.
En el desarrollo de software, un framework o infraestructura digital, es una

estructura conceptual y tecnolgica de soporte definido, normalmente con
artefactos o mdulos de software concretos, que puede servir de base para la
organizacin y desarrollo de software. Tpicamente, puede incluir soporte de
programas, bibliotecas, y un lenguaje interpretado, entre otras herramientas,
para as ayudar a desarrollar y unir los diferentes componentes de un proyecto.
Representa una arquitectura de software que modela las relaciones generales

de las entidades del dominio, y provee una estructura y una especial
metodologa de trabajo, la cual extiende o utiliza las aplicaciones del dominio.
Son diseados con la intencin de facilitar el desarrollo de software,

permitiendo a los diseadores y programadores pasar ms tiempo identificando
requerimientos de software que tratando con los tediosos detalles de bajo nivel
de proveer un sistema funcional. Por ejemplo, un equipo que usa Apache Struts
para desarrollar un sitio web de un banco, puede enfocarse en cmo los retiros
de ahorros van a funcionar en lugar de preocuparse de cmo se controla la
navegacin entre las pginas en una forma libre de errores. Sin embargo, hay
quejas comunes acerca de que el uso de frameworks aade cdigo innecesario
y que la preponderancia de frameworks competitivos y complementarios
significa que el tiempo que se pasaba programando y diseando ahora se
gasta en aprender a usar los frameworks.
Fuera de las aplicaciones en la informtica, puede ser considerado como el

conjunto de procesos y tecnologas usados para resolver un problema
complejo. Es el esqueleto sobre el cual varios objetos son integrados para
facilitar una solucin dada.
.Net Framework
.NET Framework es un entorno de ejecucin administrado que proporciona

diversos servicios a las aplicaciones en ejecucin. Consta de dos componentes
principales: Common Language Runtime (CLR), que es el motor de ejecucin
que controla las aplicaciones en ejecucin; y la biblioteca de clases de .NET
Framework, que proporciona una biblioteca de cdigo probado y reutilizable al
que pueden llamar los desarrolladores desde sus propias aplicaciones. Los
servicios que ofrece .NET Framework a las aplicaciones en ejecucin son los
siguientes:

Administracin de la memoria. En muchos lenguajes de programacin, los

programadores son responsables de asignar y liberar memoria y de
administrar duraciones de objeto. En las aplicaciones de .NET Framework,
CLR proporciona estos servicios en nombre de la aplicacin.
Sistema de tipos comunes. En los lenguajes de programacin tradicionales,

el compilador definen los tipos bsicos, que complica la interoperabilidad
entre lenguajes. En .NET Framework, los tipos bsicos se definen segn el
sistema de tipos de .NET Framework y son comunes para todos los
lenguajes cuyo destino es .NET Framework.
Biblioteca de clases extensa. En lugar de tener que escribir cantidades

extensas de cdigo para controlar operaciones comunes de programacin
de bajo nivel, los programadores puede usar una biblioteca de tipos de
acceso directo y sus miembros de la biblioteca de clases de .NET
Framework.
Frameworks y tecnologas de desarrollo. .NET Framework incluye bibliotecas

para determinadas reas de desarrollo de aplicaciones, como ASP.NET para
aplicaciones web, ADO.NET para el acceso a los datos y Windows
Communication Foundation para las aplicaciones orientadas a servicios.
Interoperabilidad de lenguajes. Los compiladores de lenguajes destinados a

.NET Framework emiten un cdigo intermedio denominado Lenguaje
intermedio comn (CIL), que, a su vez, se compila en tiempo de ejecucin
por Common Language Runtime. Con esta caracterstica, unos lenguajes
pueden acceder a las rutinas escritas en otros, y los programadores pueden
concentrarse en crear aplicaciones en su lenguaje o lenguajes preferidos.
Compatibilidad de versiones. Con raras excepciones, las aplicaciones que se

desarrollan con una versin determinada de .NET Framework se pueden
ejecutar sin modificaciones en una versin posterior.
Ejecucin en paralelo. .NET Framework ayuda a resolver conflictos entre

versiones permitiendo que varias versiones de Common Language Runtime
existan en el mismo equipo. Esto significa que tambin pueden coexistir
varias versiones de las aplicaciones, y que una aplicacin se puede ejecutar
en la versin de .NET Framework con la que se compil.
Compatibilidad con mltiples versiones (multi-targeting). Al usar la Biblioteca

de clases portable de .NET Framework, los desarrolladores pueden crear
ensamblados que funcionan en varias plataformas de .NET Framework,
como Windows 7, Windows 8, Windows Phone y Xbox 360.

.NET Framework para usuarios.
Si no desarrollara aplicaciones de .NET Framework, pero las usa, no es

necesario tener conocimiento concreto sobre .NET Framework o su
funcionamiento.En general, .NET Framework es completamente transparente
para los usuarios.
Si usa el sistema operativo Windows, es posible que .NET Framework ya est

instalado en el equipo. Adems, si instala una aplicacin que requiera .NET
Framework, el programa de instalacin de la aplicacin puede instalar una
versin concreta de .NET Framework en el equipo. En algunos casos, puede
aparecer un cuadro de dilogo que le pide que instale .NET Framework. Si
acaba de intentar ejecutar una aplicacin cuando aparece este cuadro de
dilogo y si el equipo tiene acceso a Internet, puede ir a una pgina web que le
permita instalar la versin de .NET Framework que falta.
En general, no debe desinstalar ninguna versin de .NET Framework que est

instalada en el equipo, porque una aplicacin que use puede depender de una
versin concreta y se puede interrumpir si se quita esa versin. Observe que
varias versiones de .NET Framework se pueden cargar en un nico equipo al
mismo tiempo. Esto significa que no tiene que desinstalar las versiones
anteriores para instalar una versin posterior.
.NET Framework para Silverlight para desarrolladores.
Si es desarrollador, puede elegir cualquier lenguaje de programacin

compatible con .NET Framework para crear la aplicacin. Dado que .NET
Framework proporciona independencia e interoperabilidad entre lenguajes,
puede interactuar con otras aplicaciones de .NET Framework y componentes
independientemente del lenguaje con el que se desarrollaron.
Para desarrollar aplicaciones o componentes de .NET Framework, haga lo

siguiente:
1. Instale la versin de .NET Framework que ser destino de su aplicacin. La

versin de produccin ms reciente es .NET Framework 4.5. .NET
Framework 4.5.1, que se libera con Visual Studio 2013 y se incluye con
Windows 8.1 Preview, tambin est disponible desde el centro de
descarga. Hay paquetes adicionales de .NET Framework que se liberan
fuera de banda. Para obtener informacin acerca de estos paquetes,
vea .NET Framework y versiones fuera de banda.
2. Seleccione el lenguaje o los lenguajes de .NET Framework que utilizar para

desarrollar las aplicaciones. Varios idiomas estn disponibles, incluido Visual

Basic, C#, Visual F# y C++ en Microsoft. (Un lenguaje de programacin que

permite desarrollar aplicaciones de .NET Framework se adhiere a la
especificacin de Common Language Infrastructure (CLI).) Para obtener una
lista de lenguajes de programacin disponibles, vea Lenguajes de Visual
Studio.
3. Seleccione e instale el entorno de desarrollo que utilizar para crear

aplicaciones y que admita el lenguaje o los lenguajes de programacin que
seleccione. El entorno de desarrollo integrado de Microsoft para las
aplicaciones de .NET Framework es Descargas de Visual Studio. Est
disponible en diversas ediciones de minoristas y gratuitas.
.NET Framework es una tecnologa que admite la compilacin y la ejecucin de

la siguiente generacin de aplicaciones y servicios Web XML. El diseo de
.NET Framework est enfocado a cumplir los objetivos siguientes:
Proporcionar un entorno coherente de programacin orientada a objetos, en

el que el cdigo de los objetos se pueda almacenar y ejecutar de forma local,
ejecutar de forma local pero distribuida en Internet o ejecutar de forma
remota.
Proporcionar un entorno de ejecucin de cdigo que minimiza los conflictos

en el despliegue y versionado de software.
Ofrecer un entorno de ejecucin de cdigo que promueva la ejecucin

segura del mismo, incluso del creado por terceras personas desconocidas o
que no son de plena confianza.
Proporcionar un entorno de ejecucin de cdigo que elimine los problemas

de rendimiento de los entornos en los que se utilizan scripts o intrpretes de
comandos.
Ofrecer al programador una experiencia coherente entre tipos de

aplicaciones muy diferentes, como las basadas en Windows o en el Web.
Basar toda la comunicacin en estndares del sector para asegurar que el

cdigo de .NET Framework se puede integrar con otros tipos de cdigo.
.NET Framework est compuesto por dos componentes principales: Common

Language Runtime y la biblioteca de clases de .NET Framework. Common
Language Runtime es el fundamento de .NET Framework. El motor en tiempo
de ejecucin se puede considerar como un agente que administra el cdigo en
tiempo de ejecucin y proporciona servicios centrales, como la administracin
de memoria, la administracin de subprocesos y la comunicacin remota, al

tiempo que aplica una seguridad estricta a los tipos y otras formas de
especificacin del cdigo que promueven su seguridad y solidez. De hecho, el
concepto de administracin de cdigo es un principio fundamental del motor en
tiempo de ejecucin. El cdigo destinado al motor en tiempo de ejecucin se
denomina cdigo administrado, a diferencia del resto de cdigo, que se conoce
como cdigo no administrado. La biblioteca de clases es una completa
coleccin orientada a objetos de tipos reutilizables que se pueden emplear para
desarrollar aplicaciones que abarcan desde las tradicionales herramientas de
interfaz grfica de usuario (GUI) o de lnea de comandos hasta las aplicaciones
basadas en las innovaciones ms recientes proporcionadas por ASP.NET,
como los formularios Web Forms y los servicios Web XML.
.NET Framework puede hospedarse en componentes no administrados que

cargan Common Language Runtime en sus procesos e inician la ejecucin de
cdigo administrado, con lo que se crea un entorno de software en el que se
pueden utilizar caractersticas administradas y no administradas. En .NET
Framework no slo se ofrecen varios hosts de motor en tiempo de ejecucin,
sino que tambin se admite el desarrollo de estos hosts por parte de terceros.
Por ejemplo, ASP.NET hospeda el motor en tiempo de ejecucin para

proporcionar un entorno de servidor escalable para el cdigo
administrado. ASP.NET trabaja directamente con el motor en tiempo de
ejecucin para habilitar aplicaciones de ASP.NET y servicios Web XML, que se
tratan ms adelante en este tema.
Internet Explorer es un ejemplo de aplicacin no administrada que hospeda el

motor en tiempo de ejecucin (en forma de una extensin de tipo MIME). Al
usar Internet Explorer para hospedar el motor en tiempo de ejecucin, puede
incrustar componentes administrados o controles de Windows Forms en
documentos HTML. Al hospedar el runtime de esta manera se hace posible el
uso de cdigo mvil administrado, pero con mejoras significativas que slo el
cdigo administrado puede ofrecer, como la ejecucin con confianza parcial y
el almacenamiento aislado de archivos.
En la ilustracin siguiente se muestra la relacin de Common Language

Runtime y la biblioteca de clases con las aplicaciones y el sistema en su
conjunto. En la ilustracin se representa igualmente cmo funciona el cdigo
administrado dentro de una arquitectura mayor.

.NET Framework en contexto.
En las secciones siguientes se describen con ms detalle las caractersticas

principales de .NET Framework.
Caractersticas de Common Language Runtime.
Common Language Runtime administra la memoria, ejecucin de subprocesos,

ejecucin de cdigo, comprobacin de la seguridad del cdigo, compilacin y
dems servicios del sistema. Estas caractersticas son intrnsecas del cdigo
administrado que se ejecuta en Common Language Runtime.
Con respecto a la seguridad, los componentes administrados reciben grados de

confianza diferentes, en funcin de una serie de factores entre los que se
incluye su origen (como Internet, red empresarial o equipo local). Esto significa
que un componente administrado puede ser capaz o no de realizar operaciones
de acceso a archivos, operaciones de acceso al Registro y otras funciones
delicadas, incluso si se est utilizando en la misma aplicacin activa.
El motor en tiempo de ejecucin impone la seguridad de acceso del cdigo. Por

ejemplo, los usuarios pueden confiar en que un archivo ejecutable incrustado
en una pgina Web puede reproducir una animacin en la pantalla o entonar
una cancin, pero no puede tener acceso a sus datos personales, sistema de
archivos o red. Por ello, las caractersticas de seguridad del motor en tiempo de
ejecucin permiten que el software legtimo implementado en Internet sea
excepcionalmente variado.
Adems, el motor en tiempo de ejecucin impone la solidez del cdigo

mediante la implementacin de una infraestructura estricta de comprobacin de
tipos y cdigo denominado CTS (Common Type System, Sistema de tipos
comn). CTS garantiza que todo el cdigo administrado es autodescriptivo. Los

diversos compiladores de lenguaje de Microsoft y de otros fabricantes generan

cdigo administrado que se atiene al CTS. Esto significa que el cdigo
administrado puede consumir otros tipos e instancias administrados, al tiempo
que se exige fidelidad de tipos y seguridad de tipos estrictamente.
Adems, el entorno administrado del motor en tiempo de ejecucin elimina

muchos problemas de software comunes. Por ejemplo, el motor en tiempo de
ejecucin controla automticamente la disposicin de los objetos, administra
las referencias a stos y los libera cuando ya no se utilizan. Esta administracin
automtica de la memoria soluciona los dos errores ms comunes de las
aplicaciones: la prdida de memoria y las referencias no vlidas a la memoria.
Adems, el motor en tiempo de ejecucin aumenta la productividad del

programador. Por ejemplo, los desarrolladores pueden crear aplicaciones en el
lenguaje que prefieran y seguir sacando todo el provecho del motor en tiempo
de ejecucin, la biblioteca de clases y los componentes escritos en otros
lenguajes por otros colegas. El proveedor de un compilador puede elegir
destinarlo al motor en tiempo de ejecucin. Los compiladores de lenguajes que
se destinan a .NET Framework hacen que las caractersticas de .NET
Framework estn disponibles para el cdigo existente escrito en dicho
lenguaje, lo que facilita enormemente el proceso de migracin de las
aplicaciones existentes.
Aunque el motor en tiempo de ejecucin est diseado para el software del

futuro, tambin es compatible con el software actual y el software antiguo. La
interoperabilidad entre el cdigo administrado y no administrado permite que
los desarrolladores continen utilizando los componentes COM y las DLL que
necesiten.
El motor en tiempo de ejecucin est diseado para mejorar el

rendimiento. Aunque Common Language Runtime proporciona muchos
servicios estndar de motor en tiempo de ejecucin, el cdigo administrado
nunca se interpreta. Una caracterstica denominada compilacin JIT (Just-In-
Time) permite ejecutar todo el cdigo administrado en el lenguaje mquina
nativo del sistema en el que se ejecuta. Mientras tanto, el administrador de
memoria evita que la memoria se pueda fragmentar y aumenta la zona de
referencia de la memoria para mejorar an ms el rendimiento.
Por ltimo, el motor en tiempo de ejecucin se puede hospedar en aplicaciones

de servidor de gran rendimiento, como Microsoft SQL Server e Internet
Information Services (IIS). Esta infraestructura permite utilizar cdigo
administrado para escribir lgica empresarial, al tiempo que se disfruta del
superior rendimiento de los mejores servidores empresariales del sector que
pueda hospedar el motor en tiempo de ejecucin.

Biblioteca de clases de .NET Framework.
La biblioteca de clases de .NET Framework es una coleccin de tipos

reutilizables que se integran estrechamente con Common Language
Runtime. La biblioteca de clases est orientada a objetos, lo que proporciona
tipos de los que su propio cdigo administrado puede derivar funciones. Esto
ocasiona que los tipos de .NET Framework sean sencillos de utilizar y reduce el
tiempo asociado con el aprendizaje de las nuevas caractersticas de .NET
Framework.Adems, los componentes de terceros se pueden integrar sin
dificultades con las clases de .NET Framework.
Por ejemplo, las clases de coleccin de .NET Framework implementan un

conjunto de interfaces que puede usar para desarrollar sus propias clases de
coleccin. stas se combinarn fcilmente con las clases de .NET Framework.
Como en cualquier biblioteca de clases orientada a objetos, los tipos de .NET

Framework permiten realizar diversas tareas de programacin comunes, como
son la administracin de cadenas, recoleccin de datos, conectividad de bases
de datos y acceso a archivos. Adems de estas tareas habituales, la biblioteca
de clases incluye tipos adecuados para diversos escenarios de desarrollo
especializados. Por ejemplo, puede utilizar .NET Framework para desarrollar
los siguientes tipos de aplicaciones y servicios:
Aplicaciones de consola Vea Compilar aplicaciones de consola en .NET

Framework.
Aplicaciones GUI de Windows (Windows Forms) Vea Windows Forms.
Aplicaciones de Windows Presentation Foundation (WPF) Vea Introduccin

a WPF.
Aplicaciones de ASP.NET Vea Desarrollar aplicaciones web mediante

ASP.NET.
Servicios de Windows Vea Introduccin a las aplicaciones de servicios de

Windows.
Aplicaciones orientadas a servicios utilizando Windows Communication

Foundation (WCF). Vea Desarrollar aplicaciones orientadas a servicios
mediante WCF.
Aplicaciones habilitadas para el flujo de trabajo utilizando Windows Workflow

Foundation (WF). Vea Crear flujos de trabajo en .NET Framework.
Por ejemplo, las clases de Windows Forms son un conjunto completo de tipos
reutilizables que simplifican enormemente el desarrollo de interfaces GUI para

Windows. Si escribe una aplicacin Web Form de ASP.NET, puede utilizar las
clases de formularios Web Forms.
INSTALAR Y TRABAJAR CON EL ENTORNO DE DESARROLLO DE

VISUAL NET.
Entorno de desarrollo.
Existe un nico entorno de desarrollo para Visual Basic, desarrollado por

Microsoft: Microsoft Visual Basic x.0, correspondientes a versiones desde la
1.0 hasta la 6.0, (con respectivas diferencias entre versiones del lenguaje).
El entorno de desarrollo es muy similar al de otros lenguajes. Realizando una

instalacin tpica del producto, las caractersticas bsicas se presentan de la
siguiente forma:
En la parte superior aparecen tres elementos, en este orden: la barra de

ttulo donde figura el nombre del proyecto en curso y su estado (diseo o
ejecucin); la barra de men con 13 opciones desplegables y una barra de
herramientas; esta ltima se puede personalizar, posibilitando la inclusin de
prcticamente la totalidad de los comandos del IDE.
En la parte central, cubriendo la franja de mayor rea, se encuentra el
espacio de trabajo. ste incluye y muestra las ventanas del proyecto, las
vistas del cdigo fuente de los mdulos, los objetos y los controles que
contienen las ventanas de la aplicacin y el panel de controles.
El panel de controles, que aunque es mvil normalmente est ubicado a la
derecha, por defecto cuenta con los siguientes controles:
- PictureBox: Caja de imgenes
- Label: Etiqueta
- TextBox: Caja de texto
- Frame: Marco
- CommandButton: Botn de comando
- CheckBox: Casilla de verificacin
- OptionButton: Botn de opcin
- ComboBox: Lista desplegable
- ListBox: Lista
- HScrollBar: Barra de desplazamiento horizontal
- VScrollBar: Barra de desplazamiento vertical
- Timer: Temporizador
- DriveListBox: Lista de unidades de disco
- DirListBox: Lista de directorios
- FileListBox: Lista de archivos
- Shape: Figura
- Line: Lnea
- Image: Imagen
- Data: Conexin a origen de datos
- OLE: Contenedor de documentos embebidos compatibles con Object
Linking and Embedding
Adems de los listados, se pueden agregar todo tipo de controles de terceros, y

hay una gran cantidad de ellos que se proveen con el propio Visual Basic 6.0.
Los controles vienen embebidos dentro de archivos con extensin OCX.
Las ventanas de proyecto, aunque mviles, se encuentran en el panel lateral

derecho y contienen dos vistas principales:
- El Explorador de proyectos, que muestra todos los elementos que

componen el proyecto o grupos de proyectos (formularios, interfaz de
controles, mdulos de cdigo, mdulos de clase, etc.).
- El Panel de propiedades, donde se muestran todos los atributos de los
objetos, controles, formularios, informacin de mdulos clase, entre
muchos otros.
La Ventana inmediato, por defecto se encuentra en la parte inferior, aunque

puede no estar visible (se presionan las teclas Ctrl+G, en ese caso, para
mostrar la ventana). Esta ventana resulta una herramienta muy til a la hora
de depurar el programa o bien para realizar pruebas rpidas, ya que permite
imprimir mensajes de texto desde el cdigo y ejecutar sentencias y
comandos simples inmediatamente (slo sentencias que se puedan escribir
en una sola lnea). Por ejemplo, de la aplicacin en curso, se puede
consultar el valor de una variable o llamar a un mtodo declarado en el
mdulo que se est depurando. Se puede ejecutar cdigo "al vuelo", por
ejemplo con sentencias como:
? sqr(2)
Siendo el signo ? un reemplazo natural del comando Print en Basic, al
ejecutar la sentencia se mostrara por pantalla el valor de la raz cuadrada de
2. Tambin se pueden usar variables del propio programa, o sentencias de
cdigo tales como:
Msgbox "Prueba de cuadro de mensaje de error.", vbCritical, "Ttulo del
mensaje"
A la hora de la depuracin puede ser til para consultar el valor de variables
del programa, o el cdigo de error como:
? Err.Number
Objetos y eventos.

Se designa como objeto cualquier elemento, por ejemplo, un formulario, una

imagen, un control, tal como una caja de texto; a su vez, los objetos tienen
propiedades, que en el caso de la caja de texto una es la propiedad "text" que
se encarga de contener el texto que aparecer en la caja. A los objetos se les
puede asociar eventos. Un evento es la ocurrencia de un suceso, comnmente
la accin que realiza el usuario sobre el objeto, que como resultado puede, por
ejemplo, provocar un cambio en alguna propiedad de un objeto. Por ejemplo:
Visual Basic tiene un evento llamado KeyPress, que ocurre cuando el usuario
presiona una tecla; ese evento se puede asociar a la caja de texto, y en l
definir (por programacin) qu accin se tomar cuando se oprima una tecla.
En sntesis, un objeto posee propiedades, responde a eventos y puede ejecutar

mtodos asociados a l.
Algunos eventos comunes definidos en Visual Basic son:
Click: ocurre cuando se presiona y suelta un botn del mouse sobre un

objeto.
DblClick: ocurre cuando se presiona y suelta dos veces un botn del mouse
sobre un objeto.
DragDrop: ocurre al arrastrar y soltar un determinado objeto con el mouse.
DragOver: ocurre si una operacin de arrastrar y soltar est en curso.
GotFocus: ocurre cuando un objeto recibe el control o foco, ya sea mediante
una accin del usuario como hacer click en un objeto ventana, o cambiando
el foco de objeto desde el programa, mediante el mtodo SetFocus.
LostFocus: contrario al anterior, este evento ocurre cuando el objeto pierde
el enfoque, sea mediante accin del usuario o efectuado desde la aplicacin.
KeyDown: ocurre cuando el usuario mantiene presionada una tecla.
KeyUp: ocurre cuando el usuario deja de presionar una tecla. Este evento
sucede precisamente al terminar el evento KeyDown.
KeyPress: ocurre como cuando se presiona y suelta una tecla.
MouseDown: ocurre cuando el usuario presiona un botn del mouse.
MouseUp: se produce cuando el usuario suelta el botn del mouse.
MouseMove: este evento ocurre mientras el usuario mueve o desplaza el
puntero del mouse sobre un objeto.
Imagnese un auto como un objeto; el auto tiene diversas propiedades como

color, modelo, etc. Algunas con slo 2 posibles valores, como encendido y
apagado, incluso otras que a simple vista no se ven, como podra ser la
cantidad de gasolina. Para definir el color de este objeto Auto, segn Visual
Basic, se hara de la siguiente manera:
Auto.color = rojo

y para definirle un evento podra ser como el siguiente ejemplo:
Sub girarllave( )
Auto.encendido=true
end sub.
Ejemplo de cdigo
El siguiente fragmento de cdigo muestra un cuadro de mensaje, en una

ventana, que dice "Hola, mundo!":
Private Sub Form_Load()

MsgBox ("Hola, mundo!")
End Sub
Ventajas:
Posee una curva de aprendizaje muy rpida.

Integra el diseo e implementacin de formularios de Windows.
Permite usar con facilidad la plataforma de los sistemas Windows, dado que
tiene acceso prcticamente total a la API de Windows, incluidas libreras
actuales.
Es uno de los lenguajes de uso ms extendido, por lo que resulta fcil
encontrar informacin, documentacin y fuentes para los proyectos.
Fcilmente extensible mediante libreras DLL y componentes ActiveX de
otros lenguajes.
Posibilita aadir soporte para ejecucin de scripts, VBScript o JScript, en las
aplicaciones mediante Microsoft Script Control.
Tiene acceso a la API multimedia de DirectX (versiones 7 y 8). Tambin est
disponible, de forma no oficial, un componente para trabajar con OpenGL
1.1.
Existe una versin, VBA, integrada en las aplicaciones de Microsoft Office,
tanto Windows como Mac, que permite programar macros para extender y
automatizar funcionalidades en documentos, hojas de clculo y bases de
datos (Access).
Si bien permite desarrollar grandes y complejas aplicaciones, tambin
provee un entorno adecuado para realizar pequeos prototipos rpidos.
Inconvenientes:
Las crticas hechas en las ediciones de Visual Basic anteriores a VB.NET son
variadas; se citan entre ellas:
Problema de versionado asociado con varias libreras runtime DLL, conocido

como DLL Hell.
Soporte pobre para programacin orientada a objetos.

Incapacidad para crear aplicaciones multihilo, sin tener que recurrir a

llamadas de la API de Windows.
Dependencia de complejas y frgiles entradas de registro COM
Ejercicios y tareas de investigacin
1. Ingrese por teclado un numero, calcule y visualice:
a) El doble del nmero ingresado.

b) La tercera parte del nmero ingresado.
c) El cubo del nmero ingresado
2. Ingrese por teclado un numero de 3 cifras, calcule y visualice:

a) La suma de sus cifras
b) Promedio de las cifras

02
II. DIFERENCIAR LA PROGRAMACIN POR CONSOLA Y CON
FORMULARIOS.

Definicin de un proyecto en Visual Net
Elaborar programa en modo consola
Disear y programar un formulario
" Un fracaso es slo una cicatriz, un mapa hacia la

victoria.... ANONIMO.
Computadora con microprocesadores core 2 Duo de mayor
capacidad.
Acceso a internet.
Orden de Ejecucin:
Definicin de un proyecto en Visual Net
Elaborar programa en modo consola
Disear y programar un formulario

2.1. DEFINICIN DE UN PROYECTO EN VISUAL NET.
Para iniciar la codificacin en Visual Net 2010 seguimos los siguientes pasos:
1) En inicio ejecutar escribir DEVENV
Comenzar a cargar el programa
2) En FILE NEW PROYECT

3) Elegir la opcin CONSOLE APPLlCATION.
4) Escribimos el nombre del proyecto
5) Seguidamente pulsamos OK.
4
5
Por defecto se tiene el modulo:
En esta seccin dentro del

main se va codificar el
algoritmo

2.2. ELABORAR PROGRAMA EN MODO CONSOLA.
Ejemplo:
1.- Calcular el rea de un tringulo.
Imports System.Console
Imports System.Math
Module Module1
Sub Main()
Dim b,h As Integer
Dim area As Double
Write(Ingresar la base.:)
b=ReadLine()
Write(Ingresa la altura)
h=ReadLine()
rea=(b*h)/2
WriteLine(El rea es: & rea)
ReadLine()
End Sub
End Module
Ejecutamos la aplicacion hacienda clic en Start Debugging o usando la tecla de

funcin F5.
Visualizaremos el programa en modo consola
Ingresamos los datos de los lados del triangulo y Enter

2.- Ingrese por teclado un nmero de dos cifras, visualice su nmero invertido.
Imports System.Math
Module Module2
Sub Main()
Dim nmero, inverso, unidad, decena As Integer
Write("Ingresa un nmero de 2 cifras.:")

nmero = ReadLine()
unidad = nmero Mod 10
decena = nmero \ 10
inverso = 10 * unidad + decena
WriteLine("El nmero invertido es:" & inverso)
ReadLine()
End Sub
End Module
3.- Ingrese por teclado un nmero de 3 cifras, visualice la suma de las cifras del
nmero ingresado.
Imports System.Math
Module Module3
Sub Main()
Dim nmero, unidad, decena, centena, suma As Integer
Write("Ingresa un nmero de 3 cifras...:")

nmero = ReadLine()
unidad = nmero Mod 10

decena = (nmero \ 10) Mod 10

centena = nmero \ 100
suma = unidad + decena + centena
WriteLine("La suma de cifras es...:" & suma)
ReadLine()
End Sub
End Module
4.- Una empresa dedicada a la venta de electrodomesticos, realiza una

promocion del 20 % + 15 % de descuento. Ingrese el nombre y precio de un
electrodomstico, calcule y visualice su descuento y el neto a pagar.
Imports System.Math
Module Module3
Sub Main()
Dim nombre, precio, descuento1, descuento2, neto As Double
Write("Ingresa el nmero del electrodomestico...:")

nombre= ReadLine()
Write("Ingresa el nmero del electrodomestico...:")
precio= ReadLine()
descuento1= precio * 0.20
descuento2= (precio descuento) * 0.15
neto = precio (descuento1 + descuento2)
WriteLine("El precio del " & nombre && y su precio es & neto)
ReadLine()
End Sub
End Module

Trabajar con constantes y variables.

Variables:
Es un espacio en la memoria de la computadora que permite almacenar
temporalmente un dato durante la ejecucin de un proceso, su contenido puede
cambiar durante la ejecucin del programa.
Para poder reconocer una variable en la memoria de la computadora, es
necesario darle un nombre con el cual podemos identificarla dentro de un
algoritmo.
Su valor puede ser modificado, pero en un instante dado solo contiene un valor
determinado.
Declaracin:
Las variabloes pueden asumir valores numricos, carcter y lgicos.
Existen 2 tipos de duracin o mbito de las variables estas son (global y local)
Las variables globales se pueden utilizar en cualquier parte del algoritmo.
Las variables locales son dentro de un sub-programa (procedimiento o funcin)
Ejm:
DECLARACION:
ABC VALIDO
A123 VALIDO
1A2B NO VALIDO
_MiVariable VALIDO
Mi_Variable VALIDO
Mi@Variable NO VALIDO

Clasificacion de las Variables:

Numericas
Por su contenido Logicas
Alfanumericas
Variables
Del trabajo
Por su Uso Contadores
Acumuladores
Declaracion:
Para declarar variables en un algoritmo se hace uso de la siguiente sintaxis:
Tipo_Dato: Lista_Variables
Ejemplos:
ENTERO: A, B, C
REAL: X, Y, Z
CARCTER: Car1, Car2
CADENA: Texto1, Texto2
LOGICO: Estado, Ok, Done
En visual las analogas son:

DIM, VAR1, VAR2 AS TIPO
Seudocdigo Visual
Entero Integer
Entero largo Long
Real Doubl
Carcter Char
Cadenas String

CONSTANTES:
Objeto de datos que contiene un valor invariable conocido por su identificador.
Es necesario inicializar las constantes al principio del algoritmo. Eso determina
el tipo de constante.
Ejemplos
PI=3,14
SALUDO=HOLA MUNDO
MAXIMO=500
RESPUESTA=S
Analizar la importancia de una estructura condicional.

ESTRUCTURA CONDICIONAL.
Las estructuras condicioanles tambin reciben el nombre de estructuras de
seleccin, permite elegir entre diferentes cursos de accin en funcin de
condiciones.
Las estructuras condicionales comparan una variable contra otro(s) valor(es),

para que en base al resultado de esta comparacin, se siga un curso de accin
dentro del programa. Cabe mencionar que la compracion se puede hacer
contra otra variable o contra una constante, segn se necesite.
En una estructura condicional se evalua una expresin lgica y dependiendo

del resultado se ejecutan una sentencias u otras.
Clasificacion:
Las estructuras condicionales o selectivas se clasifican en:
1. Condicional Simple (SI / FIN-SI)
2. Condicional Doble (SI / SINO / FIN-SI)
3. Condicional Anidada (SI / SINO / FIN-SI)
4. Condicional Multiple (EN_CASO / FIN-EN_CASO)
Estrucutura Condicional Simple
Es aquella estructura de control que evalua una condicin:
Si la condicin se cumple se ejecutan determinadas acciones.
Si la condicin no se cumple, no se ejecutan esas acciones

SINTAXIS:
DIAGRAMA DE FLIJO
NO
CONDICION
SI
CONSECUENCIAS
PSEUDOCDIGO
Si <condicion> entonces
<consecuencias>
Fin si
EJERCICIOS.
Ingrese por teclado 2 numeros enteros y visualice el mayor de los 2 numeros
ingresados
ALGORITMO Ejemplo1
VARIABLES
ENTERO: A, B, Mayor
INICIO
LEER (A,B)
Mayor A
SI (B > A) ENTONCES
Mayor B
FIN-SI
ESCRIBIR (Mayor)
FIN

CODIFICACION EN VISUAL A NIVEL DE CONSOLA.

Imports System.Math
Module Module1
Sub Main()
Dim A, B, Mayor As Integer
Write("Ingrese el valor 1...:")

A = ReadLine()
B = ReadLine()
Mayor = A
IF B > A THEN
Mayor = B
END IF
WriteLine("El mayor es...:" & mayor)

ReadLine()
End Sub
End Module
Ingrese por teclado un numero entero, si es mayor a 10 sumele 10 unidades y

visualice el nuevo valor.
ALGORITMO Ejemplo2
VARIABLES
ENTERO> N
INICIO
LEER (N)
SI ( N > 10 ) ENTONCES
N N + 10
FIN-SI
ESCRIBIR (N)
FIN

Codificacion en visual a nivel de consola.
Imports System.Math
Module Module2
Sub Main()
Dim N As Integer

A = ReadLine()
IF N > 10 THEN
N = N + 10
END IF
WriteLine("El nuevo es...:" & N)

ReadLine()
End Sub
End Module
Ingrese por teclado la edad de una persona; si su edad es mayor a 17,

visualice un mensaje Es mayor de Edad.
ALGORITMO Ejemplo3
VARIABLES
ENTERO: edad
INICIO
LEER (edad)
SI (edad > 17 ) ENTONCES
ESCRIBIR Es mayor de edad
FIN-SI
FIN
Imports System.Math
Module Module3

Sub Main()
Dim edad As Integer
Write("Ingrese su edad...:")
edad = ReadLine()
IF edad > 17 THEN
WriteLine("Eres mayor de edad)
END IF
ReadLine()
End Sub
End Module
Ingrese por teclado la talla de una persona; visualice un mensaje Servicio

Obligatorio, si tiene un talla minima de 1.70 metros
ALGORITMO Ejemplo4
VARIABLES
REAL: talla
INICIO
LEER (talla)
SI (talla >=1.70) ENTONCES
ESCRIBIR Servicio Obligatorio
FIN-SI
FIN
Codificacin en visual a nivel de consola.
Imports System.Math
Module Module4
Sub Main()
Dim talla As double
Write("Ingrese su edad...:")

talla = ReadLine()
IF talla> 1.70 THEN
WriteLine("Servicio Obligatorio)
END IF
ReadLine()
End Sub
End Module
Ejemplos de programas en consola.

Ejemplo 01:
Programar el mtodo Main para interactuar con el usuario, pedirle la fecha, y
encargarnos que la introduzca correctamente
Codigo:
private static void Main(string[] args)
{
//Variables que usaremos para la fecha de nacimiento
int dia_nacimiento, mes_nacimiento, ao_nacimiento=0;
Console.WriteLine("Escriba su nombre");
string nombre = Console.ReadLine();
Console.WriteLine("Hola {0}, bienvenido a mi aplicacion!",nombre);
Console.WriteLine("Por favor, introduce tu fecha de nacimiento:");
//El while solo termina cuando se hace break
while (true)
{
//Pedimos el dia y lo validamos
Console.Write("Dia de nacimiento: ");
dia_nacimiento = int.Parse(Console.ReadLine());
if (dia_nacimiento < 1 || dia_nacimiento > 31)
Console.WriteLine("Por favor, especifique un dia entre 1 y 31");
else
//Si el dia es valido, entonces pasamos a pedir el mes
break;
}
while (true)
{
//Pedimos el mes y lo validamos
Console.Write("Mes de nacimiento: ");
mes_nacimiento = int.Parse(Console.ReadLine());

if (mes_nacimiento < 1 || mes_nacimiento > 12)

Console.WriteLine("Por favor, especifique un mes entre 1 y 12");
else
break;
}
while (true)
{
//Pedimos el ao y lo validamos
Console.Write("Ao de nacimiento: ");
ao_nacimiento = int.Parse(Console.ReadLine());
//El ao no puede ser posterior a 1900 y anterior al ao actual
if (ao_nacimiento < 1900 || ao_nacimiento > DateTime.Now.Year)
Console.WriteLine("Por favor, especifique un ao entre 1900 y el {0}",
DateTime.Now.Year);
else
break;
}
//Si llegamos aqui, es porque tenemos una fecha correcta, vamos a calcular
la edad con
//el mtodo DameEdad() que escribimos antes
int edad = DameEdad(dia_nacimiento, mes_nacimiento,ao_nacimiento);
Console.WriteLine(nombre+", usted tiene " + edad + " aos.");
Console.WriteLine("Presione cualquier tecla para terminar el programa");
Console.ReadKey();
}
Ejemplo 02:
Area de un rectngulo
Cdigo:
using System;
using System.Collections.Generic;
using System.Text;
namespace Area_de_un_rectangulo
{
class Program
{
static void Main(string[] args)
{
//Area de un regtangulo CristianAbelardo
float Base;
float Altura;

float Area;
Console.WriteLine("Area de un Regtangulo");
Console.WriteLine();
Console.WriteLine("ingrese la base");
Base=float.Parse(Console.ReadLine());
Console.WriteLine("Ingrese la altura");
Altura=float.Parse(Console.ReadLine());
//Procesando datos
Area = Base * Altura;
Console.WriteLine("El rectangulo de base {0} y altura {1} tiene un area
de {2}", Base, Altura, Area);
Console.ReadLine();
}
}
}
Ejemplo 03:
Conversor de Pies a Metros
Codigo:
using System;
using System.Text;
namespace Convertir_pies_a_metros
{
class Program
{
{
//conversor pies a metros by cristianabelardo
//segun google 1 pie = 0,3048 metros
//1 metro = 3,2808399 pies
float Pie;
float Metro;
float Medida;
Medida=3.280839F;
Console.WriteLine("Conversor de medidas");
Pie = float.Parse(Console.ReadLine());

//procesando datos
Metro = Pie * Medida;
Console.WriteLine("{0} Pies es igual a {1}",Pie ,Metro);
Console.ReadLine();
}
}
}
Ejemplo 04:
Sumatoria de los N primeros numeros pares [Sin estructura repetitiva]
Cdigo:
using System;
using System.Text;
namespace Sumatoria_Numeros_Pares
{
class Program
{
{
//CristianAbelardo
int NPares;
int Sumatoria;
Console.WriteLine("Sumatoria de los N primeros Numeros Pares");
Console.WriteLine("Ingrese N");
NPares=int.Parse(Console.ReadLine());
//Procesar
Sumatoria = NPares*(NPares + 1);
Console.WriteLine("La sumatoria de los primeros {0} numeros pares es

{1}",NPares, Sumatoria );
Console.ReadLine();
}
}
}
Ejemplo 05:
Cajero automatico
Calcula la cantidad minima de billetes para la cantidad solicitadae indica la
cantidad de cada billete o moneda
El programa esta en "Soles"
Cdigo:
using System;
using System.Text;
namespace Cajero_Automatico
{
class Program
{
{
//CristianAbelardo
//Cajero automatico
//Entrega el dinero solicitado en la cantidad minima de billetes
int CantidadDinero;
int Billetes200;
int Billetes100;
int Billetes50;
int Billetes20;
int Billetes10;
int Monedas5;
int Monedas2;
int Monedas1;
int Residuo;
int Resultado;
Console.WriteLine("Ingrese la Cantidad de Dinero que desea retirar");

CantidadDinero = int.Parse(Console.ReadLine());
// Procesamineto
Billetes200 = CantidadDinero / 200;

Residuo = CantidadDinero % 200;
Billetes100 = Residuo / 100;

Residuo=Residuo%100;

Residuo = Residuo % 50;


Monedas5 = Residuo / 5;
Residuo=Residuo%5;
//Cantifad minima de billetes

Resultado = Billetes200 + Billetes100 + Billetes50 + Billetes20 +
Billetes10 + Monedas5 + Monedas2 + Monedas1;
//Mostrar resultados
Console.Clear();
Console.WriteLine("Dinero Solicitado : {0}", CantidadDinero);
Console.WriteLine("Billetes de 200 : {0}",Billetes200 );
Console.WriteLine("Billetes de 100 : {0}", Billetes100);
Console.WriteLine("Monedas de 5 : {0}",Monedas5 );
Console.WriteLine("Monedas de 2 : {0}", Monedas2);
Console.WriteLine("Monedas de 1 : {0}", Monedas1);
Console.WriteLine("La cantidad Mimima de");
Console.WriteLine("Billetes y monedas es:{0}", Resultado);
Console.WriteLine("");
Console.ReadLine();
}

}
}
2.3. DISEAR Y PROGRAMAR UN FORMULARIO.

Para el diseo de formularios:
Para crear un formulario nuevo
1. En el Administrador de proyectos, elija la ficha Documentos.

2. Seleccione el icono Formularios.
3. Elija Nuevo.
4. Seleccione Nuevo formulario. Aparecer la ventana Diseador de
formularios, en la que podr comenzar a crear el formulario.
O bien
En el men Archivo, elija Nuevo, seleccione Formulario y, a

continuacin, elija Nuevo archivo.
O bien
Utilice el comando CREATE FORM.
Modificar formularios
Si los formularios creados mediante el asistente o el generador no se adaptan a

sus necesidades, puede modificarlos con el Diseador de formularios. Con este
diseador resulta fcil mover y cambiar el tamao de los controles, copiar o
eliminar controles, alinear controles y modificar el orden de tabulacin.
Para modificar un formulario ya generado.
1. En el Administrador de proyectos, seleccione la ficha Documentos.

2. Elija el icono Formularios y seleccione el nombre del formulario.
3. Elija Modificar.
Agregar campos rpidamente
Si desea situar rpidamente los campos de una tabla o una vista en un

formulario, elija el comando Formulario rpido del men Formulario. Este
comando iniciar el Generador de formularios, que agregar los campos
seleccionados desde la tabla o la vista al formulario, empleando el estilo de
campo que elija. El Generador de formularios crea un formulario sin controles
de desplazamiento, de forma que pueda agregar los que desee. Puede utilizar

un generador de controles para agregar controles al formulario o elegirlos en la

biblioteca de controles de desplazamiento predefinidos que se suministra con
Visual FoxPro.
Para agregar campos a un formulario
1. En el Administrador de proyectos, abra el formulario.

2. En el Diseador de formularios vaya al men Formulario y elija Formulario
rpido. Aparecer el Generador de formularios.
3. En la ficha Estilo, seleccione el estilo que desea para el nuevo control.
4. En la ficha Seleccionar campos, seleccione el origen de los campos y los
campos que desea agregar.
5. Haga clic en Aceptar para generar el formulario.
O bien
6. En la barra de herramientas Controles de formularios, elija un control de

datos y arrstrelo a la ventana Diseador de formularios para crear el
control.
7. En la ventana Propiedades, elija la ficha Datos y seleccione la propiedad
ControlSource.
8. Introduzca un nombre de campo.
Crear una aplicacin de formularios Windows Forms.
En e l me n Archivo, haga clic en Nuevo proyecto.
Aparecer el cuadro de dilogo Nuevo proyecto. En este cuadro de dilogo se

muestra la lista de los diferentes tipos de aplicacin predeterminados que
puede crear Visual C# Express.
Seleccione Aplicacin de Windows Forms como tipo de proyecto.
Ca mbie e l nom bre de la a plica cin a Explorador web.
Ha ga clic e n Aceptar.
Visual C# Express crea una nueva carpeta para el proyecto con el nombre del
ttulo del proyecto y, a continuacin, muestra el nuevo formulario Windows
Forms titulado Form1 en la vista Diseador. Puede alternar entre esta vista y la
vista Cdigo en cualquier momento si hace clic con el botn secundario del
mouse en la superficie de diseo o en la ventana de cdigo y selecciona Ver
cdigo o Ver diseador.

El formulario Windows Forms que se ve en la vista Diseador es una

representacin visual de la ventana que se abrir al abrir la aplicacin. En la
vista Diseador, puede arrastrar diversos controles desde el Cuadro de
herramientas hasta el formulario. Estos controles no estn realmente "activos";
son slo imgenes que se pueden mover sin problemas por el formulario hasta
ocupar un lugar preciso.
Una vez colocado un control en el formulario, Visual C# funciona en segundo

plano para crear el cdigo que har que el control real ocupe la posicin
correcta cuando se ejecute el programa. Este cdigo fuente se encuentra en un
archivo que, generalmente, permanece anidado fuera de la vista. Puede ver
este archivo, denominado Form1.designer.cs, en el Explorador de soluciones si
expande Form1.cs.
S i e s t e n la vis ta Cdigo, cambie a la vista Diseador haciendo clic con el

botn secundario del mouse en la ventana de cdigo y, a continuacin,
haciendo clic en Ver diseador. Ahora, cambie el tamao del formulario
Windows Forms.
1. Haga clic en la esquina inferior derecha del formulario Windows Forms.

2. Cuando el puntero se convierta una flecha de dos puntas, arrastre la esquina
del formulario hasta que sea por lo menos tan ancho y profundo como un
cuarto de su pantalla.
Puesto que sta es la ventana en la que aparecern las pginas web, ser
mejor que no quede demasiado reducida.
As e gre s e de que s e mue s tra la ventana Propiedades. Su ubicacin

predeterminada es la seccin inferior derecha del IDE, pero puede moverla a

otra ubicacin si lo desea. La ilustracin siguiente la muestra en la esquina

superior derecha. Si la ventana Propiedades no est visible, en el men Ver
haga clic en Ventana Propiedades. Esta ventana muestra las propiedades del
control o formulario Windows Forms seleccionado y en ella se pueden cambiar
los valores existentes.
Ca mbie e l ttulo de l form ula rio Windows Form s .
1. Haga clic en el formulario para seleccionarlo.

2. En la ventana Propiedades, desplcese hacia abajo hasta Text, seleccione
el texto "Form1" y escriba Explorador web.
3. Presione ENTRAR o TAB para desplazar el foco del cuadro de texto "Text".
Ahora ver que el texto situado en la parte superior del formulario Windows
Forms (en el rea denominada barra de ttulo) ha cambiado.
Para cambiar rpidamente el nombre de un control, haga clic con el botn

secundario del mouse en el control y haga clic en Propiedades. Puede escribir
el nuevo nombre para el control en la propiedad Name.
Ha ga clic e n e l botn Cuadro de herramientas de la barra de herramientas, o

bien, haga clic en Cuadro de herramientas en el men Ver. Desplcese hacia
abajo por la lista de controles y expanda Mens y barras de herramientas hasta
que vea MenuStrip. Arrastre este control a cualquier lugar del formulario
Windows Forms.

Este control crea un men predeterminado en la parte superior del formulario.
En e l cua dro que dice Escriba aqu, escriba el nombre del men, en este
caso Navegar. Cuando presione ENTRAR, aparecern nuevos cuadros vacos
para crear otros mens y elementos de men. En el cuadro inferior, escriba
Inicio. Presione ENTRAR y aparecern ms cuadros. Escriba Hacia atrs.
Presione ENTRAR y escriba Hacia delante.
Estos elementos de men forman los controles de navegacin bsicos del sitio
Web.

Agre gue un botn.
En el Cuadro de herramientas, en la categora Controles comunes, arrastre un

control Button hasta aproximadamente la mitad del formulario Windows Forms,
justo debajo de la barra de mens. En la ventana Propiedades, cambie la
propiedad Text a Ir en lugar de button1, y cambie el nombre del diseo, que se
muestra como (Nombre), de button1 a BotonIr.
Sintaxis en C#
[ComVisibleAttribute(true)]
[ClassInterfaceAttribute(ClassInterfaceType.AutoDispatch)]
public class Button : ButtonBase, IButtonControl
Agre gue un control Com boBox.
En el Cuadro de herramientas, en la categora Controles comunes, arrastre un

control ComboBox y colquelo a la izquierda del nuevo botn. Arrastre los
bordes y las esquinas para cambiar el tamao y la posicin del control
ComboBox hasta que quede alineado con el botn.
Sintaxis en C#
[DefaultBindingPropertyAttribute("Text")]
public class ComboBox : ListControl
Nota:
Cuando mueva los controles en un formulario Windows Forms, ver aparecer
lneas azules. Estas lneas son guas que ayudan a alinear los controles en
direccin vertical y horizontal. Tambin puede alinear controles seleccionando
ms de uno a la vez. Para ello, haga clic y arrastre un cuadro de seleccin
alrededor de los controles, o mantenga presionada la tecla MAYS mientras
hace clic en ellos. Despus de tener varios controles seleccionados, puede
modificar la alineacin y el tamao utilizando los iconos de alineacin y cambio
de tamao. Estos iconos aparecen en la Barra de herramientas de diseo, en la
parte superior de la ventana Diseo.

Re lle ne e l controlComboBox.
Un control ComboBox proporciona una lista desplegable de opciones entre las

que el usuario puede seleccionar. En este programa, el control ComboBox va a
contener una lista de los sitios web favoritos para obtener un rpido acceso.
Para crear la lista de sitios, seleccione el control ComboBox y vea sus

propiedades. Seleccione la propiedad Items; ver la palabra (Coleccin) y un
botn puntos suspensivos (...). Haga clic en este botn para modificar el
contenido del control ComboBox. Agregue tantas direcciones URL del sitio Web
como desee, presionando RETORNO despus de cada una.
Nota:
Asegrese de incluir http:// delante de cada una de las direcciones de sitio web.
Agre gue e l controlWebBrowser.
En el Cuadro de herramientas, en la categora Controles comunes, desplcese

hacia abajo hasta llegar al control WebBrowser. Arrastre el control hasta el
formulario Windows Forms. Cambie el tamao del control WebBrowser para
ajustarlo al formulario Windows Forms sin ocultar los controles ComboBox y
Button. Si el tamao del control WebBrowser no se puede cambiar fcilmente,
configure primero el tamao deseado, abra las propiedades, busque el valor
Dock y asegrese de que est establecido en ninguno. Al establecer la
configuracin de Anchor en Superior, Inferior, Izquierda, Derecha, el control
WebBrowser cambiar su tamao correctamente cuando se cambie el tamao
de la ventana de la aplicacin.
El control WebBrowser realiza todo el trabajo difcil de representacin de

pginas Web. El acceso a este control en la aplicacin se realiza a travs de
una instancia de la clase WebBrowser. Observe form1.Designer.cs y ver que
se ha agregado una instancia de esta clase al cdigo de la aplicacin, junto con
instancias de clases que representan los dems elementos que se han
agregado utilizando el diseador. Estas son las instancias que utilizar cuando
agregue controladores de eventos para los controles y llame a los mtodos de
los citados controles.
Sintaxis en c#
[DockingAttribute(DockingBehavior.AutoDock)]
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = FullTrust")]

[PermissionSetAttribute(SecurityAction.LinkDemand, Name = "FullTrust")]

public class WebBrowser : WebBrowserBase
Agre gue un controla dor de e ve ntos pa ra e l controlButton.
Ya ha terminado la etapa de diseo de la aplicacin y ahora puede empezar a

agregar cdigo para proporcionar la funcionalidad del programa.
El programa debe tener los controladores de eventos para el botn y para cada
opcin de men. Un controlador de eventos es un mtodo que se ejecuta
cuando el usuario interacta con el control. Visual C# Express crea
automticamente controladores de eventos vacos.
Haga doble clic en el botn y ver aparecer el Editor de cdigo para el

proyecto. Tambin ver que se ha creado el controlador para el evento Click,
que es el mensaje que aparece cuando el usuario hace clic en un botn.
Agregue cdigo al mtodo del controlador de eventos de modo similar al
siguiente cdigo.
C#
private void goButton_Click(object sender, System.EventArgs e)
{
webBrowser1.Navigate(new Uri(comboBox1.SelectedItem.ToString()));
}
Este cdigo toma el elemento seleccionado del control ComboBox, una cadena
que contiene una direccin URL web, y lo pasa al mtodo Navigate del
explorador web. El mtodo Navigate se carga y muestra el contenido de la
pgina Web en esa ubicacin.
Agre gue controla dore s de e ve ntos pa ra la s opcione s de MenuStrip.
Vuelva a la ventana Diseador y haga doble clic en los subelementos del men
de uno en uno. Visual C# Express crear mtodos de control de eventos para
cada uno. Edite estos mtodos, de modo que se asemejen al cdigo siguiente.
C#
private void homeToolStripMenuItem_Click(object sender, System.EventArgs e)
{
webBrowser1.GoHome();
}

private void goForwardToolStripMenuItem_Click(object sender,

System.EventArgs e)
{
webBrowser1.GoForward();
}
private void goBackToolStripMenuItem_Click(object sender, System.EventArgs

e)
{
webBrowser1.GoBack();
}
Cada uno de estos controladores de men llama a un mtodo de navegacin

admitido en la clase WebBrowser.
Nota:
A partir de este cdigo, puede ver que los nombres predeterminados dados a
las opciones de men pueden resultar muy confusos. Por esta razn, es una
buena idea cambiar el nombre de cada control de men al crearlo mediante el
editor de Propiedades. El nombre del controlador reflejar entonces el nombre
de la opcin de men.
Ve a e l cdigo que Vis ua l C# ha e s crito a utom tica m e nte .
El IDE de Visual C# ya ha escrito cdigo de inicializacin. En la vista Cdigo,

busque el constructor de la clase Form1. Tiene una firma de public Form1().
Haga clic con el botn secundario del mouse en el mtodo InitializeComponent
al que se llama desde dentro del constructor y, a continuacin, haga clic en Ir a
definicin. Ahora ver todo el cdigo que se iba escribiendo en segundo plano
mientras arrastraba y colocaba controles y estableca propiedades en la
ventana Propiedades.
Agregue cdigo de inicializacin propio.
La ltima tarea es agregar su propio cdigo de inicializacin a Form1. El

constructor nunca debe utilizarse para llamar a cdigo que pueda producir una
excepcin. Por consiguiente, cualquier cdigo de este tipo se debe colocar en
otra parte; ese lugar es el mtodo Form1_Load. Haga clic en la ficha Form1.cs
[Diseo] en la parte superior del editor de cdigo para regresar al formulario
Windows Forms. Seleccione el formulario y, en la ventana Propiedades, haga
clic en el botn Eventos (el que tiene un icono de rayo) y, a continuacin, haga
doble clic en Cargar. Esto agregar un mtodo de control de eventos y colocar
el cursor en el mtodo en la vista Cdigo.

Cuando un usuario final inicie el programa, Windows notificar este hecho al

formulario de la aplicacin enviando un evento Load. Cuando el formulario
reciba ese evento, llamar al mtodo Form1_Load. Los mtodos a los que se
llama en respuesta a eventos se denominan controladores de eventos. El
sistema llamar al evento en el momento adecuado; ahora tiene que colocar el
cdigo en el controlador de eventos que desee que se ejecute cuando se
produzca el evento.
En la vista Cdigo, agregue dos lneas al mtodo Form1_Load, como se

muestra a en el siguiente cdigo. Esto har que el control WebBrowser muestre
la pgina principal predeterminada del equipo y establezca el valor inicial del
control ComboBox.
C#
private void Form1_Load(object sender, EventArgs e)
comboBox1.SelectedIndex = 0;
webBrowser1.GoHome();
Genere y ejecute el programa.
Presione F5 para generar y ejecutar el explorador web. Se mostrar en pantalla

el formulario Windows Forms creado y, a continuacin, aparecer la pgina
principal predeterminada del equipo. Puede utilizar el control ComboBox para
seleccionar un sitio web, y hacer clic en Ir para navegar al mismo. Las opciones
de men permiten volver a la pgina principal o desplazarse hacia delante y
hacia atrs a travs de los sitios Web visitados anteriormente.

FUNDAMENTO TERICO:
Definicin de un proyecto en Visual Net.
El proyecto es el punto de inicio para la creacin de aplicaciones, componentes

y servicios en Visual Studio 2008. El proyecto acta como un contenedor que
administra el cdigo fuente, las conexiones de datos y las referencias. Un
proyecto se organiza como parte de una solucin, que puede contener
mltiples proyectos dependientes entre s. Los temas de esta seccin
describen las diferentes tareas relativas a la creacin y la administracin de
proyectos de Visual Basic y Visual C#.
Administrar propiedades del proyecto con el Diseador de proyectos
El Diseador de proyectos es una til interfaz de usuario de Visual Studio

que le permite establecer las propiedades del proyecto, algunas de las
cuales se pueden establecer tambin mediante la Propiedades
(Ventana).
Proyectos locales y proyectos web
Hay varios factores que se deben considerar al decidir si se utiliza un

modelo de proyecto local o proyecto Web para una aplicacin.
En primer lugar, la estrategia de instalacin debera formar parte de los

factores que influyen en la decisin general. Si necesita una aplicacin de
rpida implementacin en un servidor con una configuracin de cliente
mnima, el modelo de proyecto Web es el ms recomendable. Se puede
instalar y ejecutar este proyecto en un servidor sin instalar archivos de
compatibilidad en cada cliente y realizar las actualizaciones slo en un
servidor. Sin embargo, para aquellos proyectos en los que el servidor no
juegue un papel importante o para aplicaciones autnomas, la mejor opcin
es un modelo de proyecto local. En este escenario, las actualizaciones
pueden completarse en cada equipo cliente individual.
Otro factor es la divisin de la carga de trabajo. Cuando analice el marco

de trabajo de la aplicacin, deber considerar dnde se realizar la mayor
parte del trabajo. Los proyectos Web ofrecen una estrategia basada en
servidor, donde la mayora de las operaciones se ejecutan en el servidor. El
equipo cliente utiliza un explorador web para enviar y mostrar informacin
procedente de la aplicacin del lado del servidor. Si los recursos del
servidor son limitados, considere la posibilidad de utilizar un modelo de

proyecto local para la aplicacin. El trabajo puede realizarse en el equipo

cliente sin consumir el valioso tiempo del servidor.
La tabla siguiente ofrece una comparacin frente a frente entre los

proyectos Web y los proyectos locales, tanto en el entorno de diseo como
en el de trabajo:
Consideracin Proyecto Web Proyecto local

Los archivos se almacenan en una
direccin URL especfica en un equipo
Almacenamiento de que tiene instalado Internet Information Los archivos del proyecto
archivos durante el Services (IIS). El proyecto mantiene se almacenan en el
desarrollo tambin una memoria cach temporal de equipo local.
archivos en los equipos cliente para
trabajar sin conexin.
El cdigo de la aplicacin se compila en
Modelo de El cdigo se compila y se
forma de biblioteca DLL y se ejecuta en el
generacin durante ejecuta en el equipo
servidor. Los resultados se ven en el
el desarrollo cliente.
equipo cliente.
Los archivos del proyecto
se instalan en el equipo
Mtodo de El proyecto se implementa en un servidor
cliente con los archivos
implementacin Web.
de compatibilidad
requeridos.
Los equipos cliente ejecutan la aplicacin
La aplicacin se ejecuta
de forma remota con un explorador web.
Carga de trabajo localmente en el equipo
El procesamiento se realiza primero en el
cliente.
servidor.
Las modificaciones de la aplicacin se
Las actualizaciones de la
realizan en el nivel del servidor, sin
Actualizacin aplicacin se instalan en
instalar archivos de compatibilidad en los
los equipos cliente.
equipos cliente.
Traslado de El comando Copiar proyecto se utiliza Los archivos del proyecto

archivos de para mover archivos a la direccin URL se copian fsicamente de
proyecto especificada. una ubicacin a otra.
Propiedades de archivo.
o Puede utilizar las propiedades de archivo para indicar qu acciones debe

ejecutar sobre los archivos el sistema del proyecto. Por ejemplo, puede
establecer propiedades de archivo para indicar si un archivo debe
compilarse o incrustarse en los resultados de la generacin como recurso.
o Puede seleccionar cualquier archivo en el Explorador de soluciones y, a
continuacin, examinar sus propiedades en la ventana Propiedades. Los

archivos de Visual Basic y Visual C# tienen cuatro propiedades:

FileName, BuildAction, CustomTool y CustomToolNamespace.
Nota:
Las propiedades BuildAction, CustomTool y CustomToolNamespace se
proporcionan para casos avanzados. Habitualmente, los valores
predeterminados son suficientes y no es necesario cambiarlos.
FileName (Propiedad).
Puede cambiar el nombre de un archivo haciendo clic en la propiedad

FileName en la ventana Propiedades y escribiendo el nuevo nombre.
Observe que si cambia el nombre del archivo, Visual Studio cambiar
automticamente el nombre de los archivos .vb o .resx que estn asociados
a l.
Propiedad BuildAction.
La propiedad BuildAction indica lo que hace Visual Studio con un archivo

cuando se ejecuta una generacin. BuildAction puede tener uno o
numerosos valores:
None: el archivo no est incluido en el grupo de resultados del proyecto,

ni se compila en el proceso de generacin. Un ejemplo es un archivo de
texto que contenga documentacin, como un archivo Lame.
Compile: el archivo est compilado en el resultado de la compilacin. Este
valor se utiliza para los archivos de cdigos.
Contenido: el archivo no est compilado, pero se incluye en el grupo de
resultados del contenido. Por ejemplo, este valor es el predeterminado de
un archivo .htm o cualquier otro tipo de archivo Web.
Recurso incrustado: este archivo est incrustado en el resultado de la
generacin del proyecto principal como un DLL o ejecutable. Este valor se
utiliza normalmente para los archivos de recursos.
El valor predeterminado de BuildAction depende de la extensin del archivo

que agregue a la solucin. Por ejemplo, si agrega un proyecto de Visual Basic
al Explorador de soluciones, el valor predeterminado de BuildAction es
Compile. Esto se debe a que la extensin .vb indica que se trata de un archivo
de cdigo que se puede compilar. Los nombres y las extensiones de archivo
aparecen en el Explorador de soluciones.
Observe que el nombre del archivo del proyecto no ser el identificador para el
recurso administrado en el manifiesto del ensamblado (vea Manifiesto del
ensamblado para obtener ms informacin). El identificador ser espacio de
nombres.nombre de archivo.extensin, donde espacio de nombres es el valor

de la propiedad DefaultNamespace en un proyecto de Visual C# o la propiedad

RootNamespace en un proyecto de Visual Basic. Nombre de archivo y
extensin mantienen su designacin original. Si el archivo es un archivo .resx,
el sistema del proyecto ejecutar el resgen.exe en el archivo, creando un
archivo de recursos. El archivo .resource se incrustar en el ensamblado. Por
consiguiente, el manifiesto del ensamblado har referencia al archivo
.resources, y no al archivo .resx.
Por ejemplo, si agrega el archivo MyFile.bmp a un proyecto cuyo espacio de

nombres predeterminado sea MyProj y establece la accin de generacin en
Recurso incrustado, MyProj.MyFile.bmp ser el identificador en el manifiesto
del ensamblado. Si posteriormente agrega el archivo MyFile.resx al proyecto, la
accin de compilacin predeterminada ser Recurso incrustado y
MyProj.MyFile.resources ser el identificador del manifiesto del ensamblado.
Tenga en cuenta que cuando el editor de recursos agrega una imagen,

establece Accin de generacin en Ninguno, porque el archivo .resx hace
referencia al archivo de imagen. En tiempo de generacin, la imagen se extrae
en el archivo .resources creado fuera del archivo .resx. A continuacin, se
puede tener acceso fcilmente a la imagen a travs de la clase con
establecimiento inflexible de tipos generada automticamente para el archivo
.resx. Por consiguiente, no debera cambiar esta configuracin a Recurso
incrustado, porque al hacerlo incluira la imagen dos veces en el ensamblado.
Para obtener ms informacin acera del acceso a los archivos de recursos

(compilados a partir de archivos .resx) en tiempo de ejecucin, consulte
ResourceManager (Clase). Para obtener ms informacin sobre cmo tener
acceso a todos los dems archivos y recursos incrustados en tiempo de
ejecucin, consulte Assembly.GetManifestResourceStream (Mtodo).
Propiedad CopyToOutputDirectory.
Esta propiedad especifica las condiciones en las que el archivo de cdigo

fuente seleccionada se copiar en el directorio de salida. Seleccione No copiar
si el archivo nunca se va a copiar en el directorio de resultados. Seleccione
Copiar siempre si el archivo siempre se copiar en el directorio de resultados.
Seleccione Copiar si es posterior si el archivo slo se copiar cuando sea ms
reciente que un archivo con el mismo nombre que est presente en el directorio
de resultados.
Nota:
En los proyectos para dispositivos inteligentes, la novedad de un archivo .dll o

.exe se determina mediante la comparacin de las versiones de Win32 de la

siguiente forma:
Si la versin del dispositivo es anterior a la del escritorio, se copia el archivo.
Si la versin del dispositivo es posterior a la del escritorio, no se copia el

archivo.
Si las versiones son iguales, se realiza una comparacin de la suma de

comprobacin. Si las sumas de comprobacin son iguales, no se copia el
archivo y si son diferentes, se copia el archivo.
La novedad de los archivos que no sean .dll ni .exe se basa nicamente en la

suma de comprobacin.
Nota:
Los archivos de datos se copiarn en una subcarpeta denominada Archivos de

los Datos en el directorio de resultados.
Propiedad CustomTool.
Las herramientas personalizadas son componentes que se pueden utilizar para

transformar archivos de un tipo a otro en tiempo de diseo. Por ejemplo, una
herramienta personalizada puede ser un generador de cdigo de conjunto de
datos que lee un archivo de esquema XML (.xsd), y genera clases en un
archivo de cdigo que expone sus tablas y columnas mediante programacin.
En el producto se dispone de una lista predefinida de las herramientas
personalizadas disponibles; esta propiedad permite ver la herramienta
personalizada que se aplica a un archivo. En raras ocasiones, quiz deba
cambiar el valor de esta propiedad. El valor de esta propiedad debe estar en
blanco o ser una de las herramientas personalizadas integradas.
Para establecer o cambiar la herramienta personalizada, haga clic en la

propiedad CustomTool en la ventana Propiedades y escriba el nombre de una
herramienta personalizada.
Propiedad CustomToolNamespace.
Si ha asignado una herramienta personalizada al proyecto, la propiedad

CustomToolNamespace permite especificar el espacio de nombres que desea
asignar al cdigo generado por la herramienta personalizada. Al especificar un
valor para la propiedad CustomToolNamespace, el cdigo generado por la
herramienta se colocar en el espacio de nombres especificado. Si la
propiedad est vaca, el cdigo generado se coloca en el espacio de nombres
predeterminado para la carpeta en la que se encuentra el archivo convertido.
Para Visual Basic, se trata del espacio de nombres raz del proyecto; para

Visual C#, corresponde al valor de la propiedad DefaultNamespace de la

carpeta.
Plantillas de proyectos predeterminadas en Visual Studio:
Cuando se crea un nuevo proyecto, los iconos de los cuadros de dilogo

Nuevo proyecto y Agregar proyecto representan los tipos de proyecto
disponibles y sus plantillas. La plantilla de proyecto asociada con el icono de
proyecto elegido determina el tipo de resultado y otras opciones disponibles
para el proyecto.
La tabla siguiente muestra los tipos predeterminados de proyectos
disponibles en Visual Studio.
Plantilla de
Se utiliza para crear:
proyecto
Clases o componentes reutilizables que puedan compartirse con otros
Plantilla de
proyectos. Este tipo de proyecto se considera que no tiene ventanas y
biblioteca de
no contendr una clase de formulario Windows Forms. Para obtener
clases
ms informacin, vea Clases de componentes.
Plantilla de Aplicaciones de lnea de comandos.
aplicacin de
consola
Proyecto vaco. La plantilla crea la estructura de archivos necesaria
Plantilla de
para almacenar la informacin de la aplicacin; las referencias, archivos
proyecto vaca
o componentes deben agregarse manualmente.
Plantilla de Controles personalizados para utilizarlos en pginas de formularios Web
biblioteca de Forms.
controles Web
Aplicaciones autnomas tradicionales para Windows o una interfaz rica
para una aplicacin Web distribuida. Para obtener ms informacin, vea
Plantilla de Crear aplicaciones para Windows.
aplicaciones para
Windows Nota para Visual Basic:
Reemplaza a la plantilla de proyecto EXE estndar de Visual Basic 6.0.
Controles personalizados para utilizarlos en formularios Windows

Forms. Para obtener ms informacin, vea Creacin de controles para
Plantilla de formularios Windows Forms.
biblioteca de
controles de Nota para Visual Basic:
Windows
Este tipo de proyecto es anlogo al proyecto Control ActiveX de Visual
Basic 6.0.
Aplicaciones de larga duracin que no tienen una interfaz de usuario.

Plantilla de Las aplicaciones de servicios de Windows (antes denominadas
servicio de "servicios NT") pueden supervisar elementos tales como el rendimiento
Windows del sistema. Para obtener ms informacin, vea Introduccin a las
aplicaciones de servicios de Windows.

Elaborar programa en modo consola.
Puede usar Visual C++ en el entorno de desarrollo integrado (IDE) de Visual

Studio para crear programas en C++ estndar. Si siguimos los pasos de este
tutorial, podemos crear un proyecto, agregar un nuevo archivo al proyecto,
modificar el archivo para agregar cdigo de C++ y, finalmente, compilar y
ejecutar el programa con Visual Studio.
Puede escribir su propio programa de C++ o utilizar uno de los programas de

ejemplo. El programa de ejemplo de este tutorial es una aplicacin de consola.
Esta aplicacin usa el contenedor set de la Biblioteca de plantillas estndar
(STL).
Visual C++ cumple la norma de 2003 C++ excepto en estos casos: bsquedas
de nombres en dos fases, especificaciones de excepciones y exportaciones.
Adems, Visual C++ admite varias caractersticas de C++0x, como lambda,
auto, static_assert, referencias rvalue y plantillas extern.
Nota
Si se requiere cumplimiento normativo, use la opcin del compilador /Za para
deshabilitar las extensiones de Microsoft para la norma. Para obtener ms
informacin, vea /Za, /Ze (Deshabilitar extensiones de lenguaje).
Pasos para crear un proyecto por consola:
1. Para crear un nuevo proyecto, en el men Archivo, elija Nuevo y haga clic en
Proyecto.
2. En el panel de tipos de proyecto de Visual C++, haga clic en Win32 y, a
continuacin, en Aplicacin de consola Win32.
3. Escriba un nombre para el proyecto.
De forma predeterminada, la solucin que contiene el proyecto tiene el mismo

nombre que el proyecto, pero puede escribir un nombre diferente. Tambin
puede escribir una ubicacin diferente para el proyecto.
Haga clic en Aceptar para crear el proyecto.
4. En el Asistente para aplicaciones Win32, haga clic en Siguiente, seleccione

Proyecto vaco y, a continuacin, haga clic en Finalizar.
5. Si no aparece el Explorador de soluciones, en el men Ver, haga clic en
Explorador de soluciones.
6. Agregue un nuevo archivo de origen al proyecto como se indica a
continuacin.

En el Explorador de soluciones, haga clic con el botn secundario en la

carpeta Archivos de origen, elija Agregar y, a continuacin, seleccione
Nuevo elemento.
En el nodo Cdigo, haga clic en Archivo C++ (.cpp), escriba un nombre
para el archivo y, a continuacin, haga clic en Agregar.
El archivo .cpp aparece en la carpeta de archivos de origen del Explorador

de soluciones y el archivo se abre en el editor de Visual Studio.
7. En el archivo del editor, escriba un programa de C++ vlido que use la

Biblioteca estndar de C++ o copie uno de los programas de ejemplo y
pguelo en el archivo.
Por ejemplo, puede usar el programa set::find (Ejemplos de STL), que es

uno de los ejemplos de Biblioteca de plantillas estndar incluidos en la
Ayuda.
Si usa el programa de ejemplo, observe la directiva using namespace std;.

Esta directiva permite al programa usar cout y endl sin requerir nombres
completos (std::cout y std::endl).
8. Guarde el archivo.
9. En el men Compilar, haga clic en Compilar solucin.

La Ventana de salida muestra informacin sobre el progreso de compilacin;
por ejemplo, la ubicacin del registro de compilacin y un mensaje que
indica el estado de la misma.
10. En el men Depurar, haga clic en Iniciar sin depurar.
Si us el programa de ejemplo, aparece una ventana de comandos que

indica si hay determinados enteros en el conjunto.
Ejemplo
Antes de seguir debes haber instalado Vistual Studio 2010 (en adelante
VS2010) en tu sistema Windows. Si no lo ha hecho an, consulta el documento
Visual C++ Instalacin en esta misma seccin Herramientas de desarrollo
del Campus Virtual. Sigue sus instrucciones para instalar VS2010 en su versin
para C++.
VS2010 adems de ofrecer un editor para crear los fuentes y archivos

encabezados de una aplicacin C++ integra a travs de opciones de men las
herramientas necesarias para compilar y enlazar una aplicacin C++.
Adicionalmente, VS2010 permite utilizar, a travs de la consola de comandos,

una gran parte de las herramientas que son invocadas automticamente a

travs de las opciones de men. Entre otras, es posible invocar al compilador y
al enlazador.
Para poder ejecutar las rdenes de compilacin de VS2010 necesitamos una

consola (o ventana de terminal), que es una ventana de modo texto que
permite dar instrucciones al sistema operativo (SO) ejecutando rdenes una
por una.
El SO entiende una serie de rdenes por defecto (dir, cd, copy, move, ...), cada
una con su sintaxis que hay que respetar. Y a medida que instalamos
determinados programas se aaden rdenes que se pueden ejecutar en la
consola. Por ejemplo, tras instalar MinGW podemos usar la orden g++ para
compilar programa en C++, o en el caso de VS2010 podemos utilizar las
herramientas de consola que vienen incluidas.
Por comodidad para el desarrollador, cuando se instala VS2010 se configura

un acceso directo a una consola (o terminal) preconfigurada para poder utilizar
directamente todas las herramientas en modo consola que vienen con el
VS2010. Para abrir una consola usa la opcin Smbolo del sistema para
Visual Studio 2010 del grupo de programas Microsoft Visual Studio 2010
Express. Se abrir una ventana similar a esta:
Como ves, es una ventana en modo texto. Lo nico que se pueden mostrar son
filas de caracteres. No hay grficos.
En las consolas siempre hay un indicativo (prompt) al que le sigue un cursor de

texto parpadeante que indica dnde se pondr el siguiente carcter que se
escriba (al principio, tras el indicativo, o tras el ltimo carcter escrito).

En la ilustracin, el indicativo es C:\Archivos de programa\Microsoft Visual

Studio 10.0\VC> y el cursor tiene la forma de un guin bajo (o subrayado). El
tu ventana lo vers parpadear.
El indicativo por defecto muestra la carpeta actual seguida del smbolo mayor
que (>). El cursor est esperando que escribamos una orden.
Por ejemplo, escribe dir. Es la orden que te permite ver el contenido de la

carpeta actual.
Una vez escrita una orden la ejecutamos pulsando la tecla Intro. Hazlo y vers
aparecer un listado de las subcarpetas y archivos que hay en esa carpeta
(C:\Archivos de programa\Microsoft Visual Studio 10.0\VC, en mi caso):
(Puedes alargar la ventana hacia abajo para ver ms lneas.) El listado tiene
cinco columnas: la fecha y la hora de creacin o modificacin, si se trata de una
subcarpeta (<DIR>), el tamao del archivo (en bytes) y el nombre del archivo o
carpeta.
La subcarpeta .. es especial, ya que hace referencia a la carpeta madre (en

este ejemplo, C:\Archivos de programa\Microsoft Visual Studio 10.0\).
Otra orden que necesitas conocer es la que te permite cambiar a otras

carpetas. Es cd y debe llevar a continuacin (separado por un espacio) el
nombre de la (sub)carpeta a la que queremos ir. O .., para ir a la carpeta
madre. Ejecuta cd .. y llegars a la carpeta madre.
Lo sabrs porque el indicativo as lo dice:

Puedes observar tambin que al ir ejecutando rdenes y al salir las lneas que
producen las rdenes se van desplazando las lneas anteriores hacia arriba y
se dejan de ver. Si queremos volver a verlas podemos utilizar la barra de
desplazamiento de la ventana.
Bueno, ya vas conociendo algunas rdenes del SO que utilizars a menudo en

las consolas. Usars pocas ms, ya que lo que nos interesa es compilar
programas, lo que haremos siempre con la orden cl que VS2010 ha aadido al
instalarse.
Con cd te puedes desplazar a la carpeta en que estn los archivos con el

cdigo C++ que deseas compilar. Y dir te servir para ver los nombres de esos
archivos. Pero los archivos los crears y editars ms cmodamente con una
aplicacin Windows con todas sus facilidades. Y las operaciones de
mantenimiento de los archivos, con el Explorador de Windows.
Antes de compilar nuestro primer programa C++ vamos a organizarnos un

poco. Vamos a crear una carpeta en la que ir colocando los distintos programas
que iremos desarrollando a lo largo del curso. Llammosla FP.
La crearemos en la raz del disco, para que nos cueste poco llegar a ella en la
ventana de consola. Ejecuta en la consola la orden cd .. hasta que ya no
produzca ningn cambio. (Por cierto, puedes volver a ejecutar rdenes
anteriores usando las teclas de flecha arriba y abajo para ir recorriendo el
historial de rdenes; para quitar la que haya basta con que pulses la tecla Esc.)
Estars ahora en la carpeta raz del disco. El indicativo slo muestra la letra de
la unidad de disco, dos puntos y una barra invertida (aparte del >):

Puedes crear las carpetas utilizando el Explorador de Windows, o ejecutar en la

consola las instrucciones siguientes. Para crear la carpeta FP, ejecuta mkdir
FP. mkdir es la orden que permite crear una subcarpeta. Cambia a esa nueva
carpeta ejecutando cd FP.
Como vamos a desarrollar muchos programas a lo largo del curso,

organicemos un poco ms creando subcarpetas para las distintas unidades (y
prcticas).
Asegrate de que ests en la carpeta FP (mira el indicativo actual). Ejecuta

mkdir Unidad02 (o mkdir Tema2, lo que prefieras). Y pasa esa nueva carpeta
con cd Unidad02 (o cd Tema2).
Ya ests en la carpeta donde queremos compilar. Compilar qu? Como

acabamos de crear la carpeta, no hay nada en ella (ejecuta dir):

. Representa la propia carpeta actual y .. la carpeta madre. Esos dos elementos

siempre estn. Pero no hay nada ms, ningn programa en C++. (Si quieres
borrar el contenido de la consola usa la orden cls.)
Pongamos el programa Hola Mundo! para una primera prueba de compilacin.

Pulsa el siguiente vnculo que aparece a continuacin. Te abrir una nueva
ficha (o ventana) con el texto del programa.
Programa Hola Mundo!
Usa los mens del navegador para guardar el documento abierto. Asegrate de
que se guarde como archivo de texto (*.txt) y que tenga el nombre hola.cpp.
Una vez hecho, vuelve a la ventana de consola y ejecuta dir:
Ya debe aparecer el archivo hola.cpp. Si, por cualquier motivo, el archivo

tuviera un nombre diferente, usa la orden ren (renombrar) para que tenga el
deseado. Por ejemplo, si el archivo se llama hola_cpp.txt, ejecuta la orden ren
hola_cpp.txt hola.cpp.
Ahora que ya tenemos un programa en la carpeta, podemos compilarlo para

que se genere el correspondiente archivo ejecutable. Como ya sabemos,
usaremos la orden cl. La sintaxis bsica para compilar un programa es la
siguiente:
cl /Feejecutable programa.cpp
Donde ejecutable es el nombre que queremos para el archivo ejecutable

resultante (si todo va bien) y programa es el nombre del programa (siempre con
extensin .cpp). En este caso, programa es hola y como archivo ejecutable

podemos elegir hola.exe (si no ponemos extensin, aadir .exe

automticamente). As, en nuestro caso la orden ser:
cl /Fehola.exe hola.cpp
Bsicamente lo que le decimos a al compilador de VS2010 es que compile una

serie de archivos de cdigo (aqu slo hay uno, pero podramos poner varios
.cpp, separados por un espacio). Adems, podemos incluir opciones de
compilacin. Las opciones empiezan por un guin (/) y cada una tiene una o
varias letras que la identifica. Por ejemplo /Fe es la opcin de compilacin que
permite dar un nombre a la salida (output) de la compilacin (la salida es el
programa ejecutable). Hay muchas opciones de compilacin, pero de momento
nos basta con /Fe. Aprenders alguna otra a lo largo del curso, pero si tienes
curiosidad puedes consultar las opciones disponibles y una breve descripcin
de las mismas ejecutando cl /?.
Escribe y ejecuta la orden anterior en la consola:
Como vemos, se genera un aviso (warning) relacionado con el controlador de

excepciones que en estos momentos no es importante.
Si cl no muestra ningn mensaje de error (mensajes marcados como Error),

entonces es que no ha habido ningn error de compilacin. Se habr generado
el ejecutable y se podr ejecutar. Ejecuta dir y vers cmo ya tienes un archivo
hola.exe.
Los archivos ejecutables se identifican como tales al tener la extensin .exe.

Basta ejecutar su nombre (sin la extensin) para que pongan en marcha.
Ejecuta hola:

Enhorabuena! Ya has conseguido compilar y ejecutar tu primer programa en

C++.
Pero es importante que sepas qu ocurre cuando no todo va bien, cuando

cometemos errores de programacin. Para comprobar qu hace el compilador
de VS2010 cuando encuentra errores, edita el programa (hola.cpp) y:
Quita la directiva inicial (#include using std;)

Quita las comillas de cierre de la cadena.
Deletrea mal return (por ejemplo, retrun).
Quita un punto y coma.
Quita { o }.
Deletrea mal Mundo (por ejemplo, "Hola Mondo!").
Para cada caso, compila y vuelve a dejar el programa como estaba tras
comprobar el efecto del cambio.
Qu ocurre en el primer caso, por ejemplo? Pues que no se entiende los que
son los identificadores cout y endl:

Bastante lgico, al estar definidos esos identificadores en la biblioteca

iostream. Aparecen dos errores de compilacin que hay que solucionar
(volviendo a aadir la cabecera en este caso).
Disear y programar un formulario.

Definir el diseo del formulario de elemento de trabajo.
Cuando disea un formulario de elemento de trabajo, desea colocar los

campos en el formulario para que admitan la entrada de datos y los procesos
de flujo de trabajo que los miembros del equipo seguirn. Si simplemente est
agregando algunos campos a un formulario existente, debe determinar en qu
parte del formulario desea agregarlos. Si est agregando varios campos para
que admitan una nueva coleccin de datos cuyo seguimiento se va a llevar a
cabo, tal vez simplemente desee agregar una nueva pestaa para estos
campos. Para minimizar la necesidad de desplazarse por el formulario, puede
agrupar los campos en varias columnas al principio del formulario o en una
pestaa.
Si est agregando un nuevo tipo de elemento de trabajo, tal vez desee copiar
un tipo existente y modificarlo para mostrar los campos y el proceso de flujo de
trabajo compatible con ese nuevo tipo.
Cuando defina el diseo, tenga en cuenta las siguientes sugerencias para

obtener los mejores resultados:
Aquellos campos que los miembros necesiten actualizar o a los que tengan
que hacer referencia con frecuencia sitelos al comienzo del formulario.
Aquellos campos que los miembros del equipo tengan que actualizar o a los
que tengan que hacer referencia de forma espordica sitelos en una
pestaa. Por ejemplo, los controles que vinculan elementos de trabajo o
adjuntan archivos normalmente se sitan en pestaas independientes.
Agrupe los campos en columnas para maximizar la presentacin de los
campos de datos. Puede usar columnas en la parte superior del formulario o
en una pestaa. Tambin puede mostrar las pestaas en un formato con
varias columnas.
Use uno o varios controles de vinculacin en pestaas independientes o en
la misma pestaa para restringir los tipos de vnculos que se pueden crear
entre los campos de tipos de elemento de trabajo.
Segmentar el formulario en reas.
Puede usar los elementos de diseo para segmentar su formulario de elemento

de trabajo en reas diferentes, agrupar campos relacionados y asignar espacio
en el formulario segn los requisitos de entrada de datos. En la tabla siguiente

se describen los elementos que se usan para segmentar el formulario en
diferentes reas.
Elemento Descripcin
Contiene los elementos Layout que determinan la presentacin de los campos y
FORM
los controles del tipo de elemento de trabajo.
Contiene todos los elementos que determinan la presentacin de los campos y los
controles de un determinado destino. Puede especificar diseos diferentes para
Layout los distintos destinos, como Visual Studio o Team Web Access. Los elementos
secundarios que puede especificar en un elemento Layout son, entre otros, los
elementos Control, Group, TabGroup y Splitter.
Agrupa los elementos secundarios del formulario. Un borde y una etiqueta
opcional separan visualmente un grupo. Los grupos que se definen en una
Group posicin adyacente en la pila XML se dividen en vertical en el formulario
mostrado. Puede especificar el elemento Column como un elemento secundario
de un elemento Group.
Mantiene todos los elementos secundarios en una columna vertical o divide un
formulario verticalmente. Las columnas deben aparecer en un Group. Los
elementos Group de Column pueden utilizarse para crear reas anidadas. De
forma predeterminada, las columnas dividen un Group uniformemente. Puede
Column especificar un atributo de ancho opcional de tipo porcentual para asignar ms
espacio a una o varias columnas.
Los elementos secundarios que puede especificar en un elemento Column son,

entre otros, los elementos Control, Group, TabGroup y Splitter.
Permite a los usuarios cambiar el tamao del ancho asignado a dos columnas de
Splitter
un formulario.
Agrega pestaas diferentes a un formulario para admitir la presentacin de
campos y controles adicionales. Los elementos secundarios que puede
Tab
especificar en un elemento Tab son, entre otros, los elementos Control, Group,
TabGroup y Splitter.
Contiene un grupo de elementos TAB. En general, puede agregar las pestaas en
TabGroup un nico grupo de pestaas. Sin embargo, podra apilar dos o ms grupos de
pestaas en un formulario.
En la siguiente ilustracin puede ver un formulario en cuya rea superior se

muestran ocho campos organizados en dos columnas. En la parte inferior se
muestran dos conjuntos de tres pestaas organizados en un diseo de dos
columnas.
Formulario personalizado con tres pestaas en un diseo de dos columnas

Parte superior del formulario.
El siguiente cdigo define la parte superior del formulario. Puede incorporar

tantas columnas como sea necesario. Como se muestra en este ejemplo, la
primera columna, cuyo tamao es un 70 por ciento del ancho del formulario,
contiene dos grupos de campos. El diseo del segundo grupo de campos, que
contiene los campos PU (Use Area Path) y Priority, se establece en dos
columnas. La segunda columna abarca el 30 por ciento restante del ancho del
formulario. Cuando se cambia el tamao del formulario, las reas que estn
asignadas a las columnas varan proporcionalmente.
<FORM>
<Layout>
<Group>
<Column PercentWidth="70">
<Group>
<Control FieldName="System.Title" Type="FieldControl" Label="Title"
LabelPosition="Left" />
<Control FieldName="System.AreaPath"
Type="WorkItemClassificationControl" Label="Area Path" LabelPosition="Left" />
<Control FieldName="System.IterationPath"
Type="WorkItemClassificationControl" Label="&Iteration Path:"
<Group>
<Control FieldName="Microsoft.VSTS.Common.ProductUnit"
Type="FieldControl" Label="PU (Use Area Path)" LabelPosition="Left" />
</Column>

<Control FieldName="Microsoft.VSTS.Common.Priority"
Type="FieldControl" Label="Priority" LabelPosition="Left" />
</Column>
</Group>
</Column>
</Group>
</Column>
<Group Label="Status">
<Control FieldName="System.Id" Type="FieldControl" Label="Id"
<Control FieldName="System.State" Type="FieldControl" Label="State"
<Control FieldName="System.AssignedTo" Type="FieldControl"
Label="Assigned To" LabelPosition="Left" />
</Column>
</Group>
</Column>
</Group>
<Group Label="">
...
</Layout>
</FORM>
Trabajar con pestaas.
Puede usar pestaas para reunir un grupo de campos o para admitir uno o
varios controles especiales, como los controles que vinculan elementos de
trabajo, vinculan el historial de elementos de trabajo o adjuntan archivos.
Algunas definiciones de tipos de elemento de trabajo de las plantillas de
procesos de Microsoft Solutions Framework (MSF) usan diversas pestaas
para controlar los tipos de vnculos que se pueden crear, en funcin del tipo de
vnculo. Para obtener ms informacin, vea Tipos y flujo de trabajo de
elementos de trabajo de la plantilla de proceso para Agile o Tipos y flujo de
trabajo de elementos de trabajo de la plantilla de proceso para CMMI.
Para obtener ms informacin sobre el uso de controles especiales, vea los

temas siguientes:
- Proporcionar texto de ayuda, hipervnculos o contenido web en un formulario

de elemento de trabajo.
- Agregar el control de datos adjuntos.
- Definir controles de vnculos para restringir las relaciones de los vnculos.

Si se usan los atributos que se describen en la tabla siguiente, puede etiquetar

la pestaa y especificar el relleno y los mrgenes que controlan el nmero de
pxeles del interior y exterior del borde del control de pestaa.
Atributo Descripcin
Label Requerido. Texto que especifica el nombre de la ficha.
Margin Opcional. Especifica la cantidad de espacio (en pxeles) que debe haber en torno a
la pestaa.
Padding Opcional. Especifica, en pxeles, la cantidad de espacio que debe haber en torno al
borde interior y exterior de la pestaa.
Seis pestaas organizadas en un diseo en paralelo.
En el cdigo siguiente se muestra la sintaxis que se utiliza para crear el diseo

que se representa en la ilustracin anterior.
<FORM>
<Layout>
...
<TabGroup>
<Tab Label="Planning">
<Group Label="Status" Padding="(0,0,0,3)">
<Control FieldName="Microsoft.DevDiv.Importance" Type="FieldControl"
Label="Importance" LabelPosition="Left" />
<Control FieldName="Microsoft.DevDiv.Commitment" Type="FieldControl"
Label="Commitment / Confidence" LabelPosition="Left" />
...
</Column>
<Column PercentWidth="50" />
</Group>
<Group>
<Control FieldName="Microsoft.DevDiv.Story" Type="HtmlFieldControl"
Label="Story Board" LabelPosition="Top" />
</Column>
</Group>
<Group>

<Control FieldName="System.Description" Type="HtmlFieldControl"

Label="Value Proposition Description" LabelPosition="Top" />
</Column>
</Group>
</Tab>
<Tab Label="Marketing">
<Group>
<Control FieldName="Microsoft.DevDiv.MarketingOwner"
Type="FieldControl" Label="Marketing Owner" LabelPosition="Top" />
<Control FieldName="Microsoft.DevDiv.MarketingDescription"
Type="HtmlFieldControl" Label="Marketing Description" LabelPosition="Top" />
</Column>
</Group>
</Tab>
<Tab Label="Relationships">
<Control Type="LinksControl" Label="Pillars" LabelPosition="Top"
Name="Pillars">
...
</Control>
<Control Type="LinksControl" Label="Experiences - Feature Groups"
LabelPosition="Top" Name="Experiences">
...
</Control>
<Control Type="LinksControl" Label="Flags / Associations"
LabelPosition="Top" Name="Flags">
...
</Control>
</Tab>
</TabGroup>
</Column>
<TabGroup>
<Tab Label="History">
<Control FieldName="System.History" Type="WorkItemLogControl"
Label="Detailed Description and History" LabelPosition="Top" Dock="Fill" />
</Tab>
<Tab Label="Links">
<Control Type="LinksControl" LabelPosition="Top" >
...
</Control>
</Tab>
<Tab Label="File Attachments">
<Control Type="AttachmentsControl" LabelPosition="Top" />
</Tab>
</TabGroup>
</Column>
</Group>

</Layout>
</FORM>
Agrupar campos.
Puede usar el elemento Group para agrupar elementos visualmente, como el

control GroupBox de Windows. Si se usan los atributos que se describen en la
tabla siguiente, puede etiquetar cada grupo y especificar el relleno y los
mrgenes que controlan el nmero de pxeles del interior y exterior del borde
del rea de grupo. El elemento Group debe ir seguido siempre de un elemento
Column, aunque el grupo tenga solo una columna.
Debe utilizar el elemento Group como contenedor de los campos de una

columna y como contenedor de las columnas de un rea segmentada del
formulario. El elemento Column solo puede especificarse como elemento
secundario de un elemento Group.
Puede controlar el espaciado y el tamao del diseo general del formulario

especificando los atributos que se describen en la tabla siguiente.
Atributo Descripcin
Label Opcional. Texto que especifica el nombre del grupo.
Margin Opcional. Especifica la cantidad de espacio (en pxeles) que debe haber alrededor
del grupo y entre el control y sus elementos colindantes. Se puede variar la cantidad
de espacio en cada lado.
Padding Opcional. Especifica la cantidad de espacio (en pxeles) que debe haber alrededor
del borde exterior del grupo. Se puede variar la cantidad de espacio en cada lado.
Grupo de campos organizados en una pestaa.
En el cdigo siguiente se muestra la sintaxis que se utiliza para crear el grupo

de campos que se muestra en la ilustracin anterior. Para obtener ms
informacin acerca de cmo se especifican los campos utilizando el elemento
Control, vea Controlar cmo se muestran los campos de elementos de trabajo.

<TabGroup>
<Tab Label="Planning">
<Group Label="Status" Padding="(0,0,0,3)">
<Control FieldName="Microsoft.DevDiv.Importance" Type="FieldControl"
Label="Importance" LabelPosition="Left" />
<Control FieldName="Microsoft.DevDiv.Commitment" Type="FieldControl"
Label="Commitment / Confidence" LabelPosition="Left" />
<Control FieldName="Microsoft.DevDiv.VisionDoc" Type="FieldControl"
Label="Vision Doc" LabelPosition="Left" />
<Control FieldName="Microsoft.DeveloperDivision.Features.EstimatedCost"
Type="FieldControl" Label="Estimated Cost" LabelPosition="Left" />
<Control FieldName="Microsoft.DevDiv.BusinessUnit" Type="FieldControl"
Label="BU (Use Area Path)" LabelPosition="Left" />
<Control FieldName="Microsoft.DevDiv.Website" Type="FieldControl"
Label="Website" LabelPosition="Left" />
</Column>
</Group>
...
</Tab>
</TabGroup>
Trabajar con columnas.
Puede disear un rea en un formulario que tenga dos o ms columnas. Puede

especificar un ancho de columna fijo o porcentual, en relacin con el ancho del
elemento que lo contiene usando los atributos FixedWidth o PercentWidth,
respectivamente. Estos dos atributos Column son mutuamente excluyentes.
Para permitir a un usuario cambiar el tamao de la columna, puede especificar
un control Splitter, tal y como se describe en Usar un divisor para admitir
tamaos de columna variables.
Diseo de tres columnas:
El siguiente cdigo genera el diseo de campos en tres columnas mostrado

anteriormente. Cuando organice grupos de campos en columnas, utilice el

elemento Group para que incluya cada columna de campos. Si lo desea,

tambin puede etiquetar los grupos de campos.
<FORM>
<Layout>
<Group>
<Group>
<Control FieldName="System.Title" Type="FieldControl" Label="Title"
<Control FieldName="System.AreaPath"
Type="WorkItemClassificationControl" Label="Area" LabelPosition="Left" />
<Control FieldName="Microsoft.VSTS.Common.ProductUnit"
Type="FieldControl" Label="Product Unit" LabelPosition="Left" />
<Control FieldName="Microsoft.DevDiv.BusinessUnit"
Type="FieldControl" Label="Business Unit" LabelPosition="Left" />
</Group>
</Column>
<Group>
<Control FieldName="Microsoft.DevDiv.SubTitle" Type="FieldControl"
Label="Sub Title" LabelPosition="Left" />
<Control FieldName="System.IterationPath"
Type="WorkItemClassificationControl" Label="Iteration" LabelPosition="Left" />
<Control FieldName="Microsoft.DevDiv.Other" Type="FieldControl"
Label="Other" LabelPosition="Left" />
</Group>
</Column>
<Group>
<Control FieldName="Microsoft.DevDiv.Type" Type="FieldControl"
Label="Type" LabelPosition="Left" />
<Control FieldName="System.AssignedTo" Type="FieldControl"
Label="Assigned To" LabelPosition="Left" />
<Control FieldName="System.State" Type="FieldControl" Label="State"
</Group>
</Column>
</Group>
...
</Layout>
</FORM>

Usar un divisor para admitir tamaos de columna variables.
Puede usar el elemento Splitter si desea que el visor del formulario pueda
cambiar el tamao de las columnas dinmicamente. El divisor aparece como
una lnea de puntos en el formulario, tal y como se muestra en la siguiente
ilustracin. No puede especificar ningn elemento secundario en el elemento
Splitter.
iseo de dos columnas con un divisor:
Un elemento Group que contiene elementos Column y Splitter debe

especificar exactamente tres elementos Column en la secuencia siguiente:
1. Un elemento Column a la izquierda del divisor.

2. Un elemento Column que contiene nicamente el elemento Splitter.
3. Un elemento Column a la derecha del divisor.
Vea el ejemplo siguiente para obtener ms informacin.
<Group>
<Group Label="First Group Left ">
<Control FieldName="Microsoft.VSTS.Common.Priority"
Type="FieldControl" Name="Pri2" Label="Priority:" />
<Control FieldName="Microsoft.VSTS.Common.Rank"
Type="FieldControl" Label="Stack Rank:" />
<Control FieldName="Microsoft.VSTS.Scheduling.BaselineWork"
Type="FieldControl" Label="Original Estimate:" />
<Control FieldName="Microsoft.VSTS.Scheduling.RemainingWork"
Type="FieldControl" Label="Remaining:" />

</Column>
<Column>
<Splitter>
</Column>
<Group Label="Second Group Right">
<Control Type="DateTimeControl"
FieldName="ABC_Company.Project.Manual.ChangeDate" Label="Change
Date" Format="Short" LabelPosition="Right" />
FieldName="ABC_Company.Project.Manual.EstimateStartDate"
Label="Estimated Start Date" Format="Short" LabelPosition="Right" />
FieldName="ABC_Company.Project.Manual.ActualStartDate" Label="Actual
Start Date" Format="Short" LabelPosition="Right" />
FieldName="ABC_Company.Project.Manual.FinishDate" Label="Finish Date"
Format="Short" LabelPosition="Right" />
</Group>
</Column>
</Group>
Controlar el tamao del formulario y sus elementos.
Puede especificar el tamao horizontal y vertical mnimo de cada diseo de

formulario utilizando el atributo MinimumSize. Sin embargo, el formulario
cambia de tamao en funcin de las dimensiones combinadas cuando el
tamao horizontal y el tamao vertical combinados de los controles de campo y
los diseos definidos en cada formulario son mayores que las dimensiones
mnimas especificadas. Adems, el tamao vertical de todas las pestaas se
ajusta a la dimensin necesaria para establecer el tamao de la pestaa con el
diseo vertical mximo. El tamao del ltimo control de campo de cada pestaa
se puede modificar como corresponda para rellenar la dimensin vertical.

Las barras de desplazamiento aparecen cuando el contenedor que est

mostrando el diseo del formulario es menor que el tamao mnimo horizontal o
vertical del formulario. En este caso, podra producirse un problema de doble
desplazamiento. Con el doble desplazamiento, los usuarios pueden tener que
desplazar tanto el propio formulario como el control de campo para localizar la
informacin que desean ver. Para evitar el problema de doble desplazamiento,
quizs desee situar controles de campo, como campos HTML y campos de
historial, que estn sujetos al desplazamiento de su propia pestaa.
Controlar el tamao del diseo.
Puede controlar el espaciado y el tamao del diseo general del formulario

especificando los atributos que se describen en la tabla siguiente.
Ejemplo de
Atributo Descripcin un valor de
modelo
Opcional. Cadena con el formato (Ancho, Alto). Este valor
especifica el tamao mnimo para el propio formulario.
Cuando el contenedor en el que se muestra el diseo del
formulario es menor que este tamao, aparecen barras de
MinimumSize (100,100)
desplazamiento horizontal y vertical. Cuando el tamao
combinado de los controles de campo del formulario de
diseo es mayor que el tamao definido por el atributo
MinimumSize, se omite el atributo.
Opcional. Cadena con el formato (Izquierda, Superior,
Derecha, Inferior) que especifica, en pxeles, la cantidad de
Margin (2,0,2,0)
espacio que debe haber alrededor del diseo. Se puede
variar la cantidad de espacio en cada lado.
Opcional. Cadena con el formato ((Izquierda, Superior,
Derecha, Inferior) que especifica, en pxeles, la cantidad de
Padding espacio que debe haber entre el borde exterior del diseo y (2,0,2,0)
el borde interior. Se puede variar la cantidad de espacio en
cada lado.
Opcional. Especifica el espaciado vertical entre los controles
ControlSpacing N/D
del formulario. Integer.
Controlar el tamao de los elementos del formulario.
Puede usar el atributo MinimumSize del elemento Control para especificar el

tamao y el alto mnimos que cada elemento del formulario debe ocupar. Si no
tiene espacio vertical suficiente, aparecer una barra de desplazamiento para
mantener el tamao mnimo. Sin este atributo, los controles se dibujan con sus
tamaos predeterminados, a menos que haya controles en otras pestaas que
ocupen ms espacio y que aumenten el tamao de la pestaa. Puede utilizar
otros atributos, como Dock, Margin y Padding, para alinear o ajustar el control y

definir el tamao del borde que rodea al control. Para obtener ms informacin,
vea los temas siguientes:
Especificar diseos diferentes para los distintos destinos.
Puede especificar diseos distintos para los diferentes destinos utilizando el

atributo Target del elemento Layout. Si el destino es Visual Studio o Team
Explorer Everywhere, puede especificar WinForms, y si el destino es Team
Web Access, puede especificar Web.
<FORM>
<Layout Target="WinForms" >
...
</Layout>
<Layout Target="Web" >
...
</Layout >
</FORM>
1. Ingrese por consola un numero, calcule y visualice:

a) El cuadrado del nmero ingresado.
b) La tercera parte del nmero ingresado.
El cubo del nmero ingresado
2. Ingrese por consola un numero de 3 cifras, calcule y visualice:

a) La resta de sus cifras
b) Promedio de las cifras restando la pimera cifra

03
III. PROGRAMAR ESTRUCTURAS CONDICIONALES.

Identificar los tipos de datos que existen en visual net.
capacidad.
Acceso a internet.
Orden de Ejecucin:
Identificar los tipos de datos que existen en visual net.

3.1. TRABAJAR CON CONSTANTES Y VARIABLES.
Variable.
Una variable representa un valor numrico o de cadena o un objeto de una

clase. El valor que la variable almacena puede cambiar, pero el nombre sigue
siendo el mismo. Una variable es un tipo de campo. El cdigo siguiente es un
ejemplo sencillo de cmo declarar una variable de entero, asignarle un valor y,
a continuacin, asignarle un nuevo valor.
C#
int x = 1; // x holds the value 1
x = 2; // now x holds the value 2
En C#, las variables se declaran con un tipo de datos y una etiqueta concretos.
Si hasta ahora slo ha utilizado lenguajes con tipos definidos de forma
imprecisa como JScript, estar acostumbrado a emplear el mismo tipo "var"
para todas las variables, pero en C# tiene que especificar si la variable es de
tipo int, float, byte, short u otro cualquiera entre ms de 20 tipos de datos
diferentes. El tipo especifica, entre otras cosas, la cantidad de memoria exacta
que se debe asignar para almacenar el valor cuando la aplicacin se ejecuta. El
lenguaje C# fuerza ciertas reglas al convertir una variable de un tipo en otro.
Para obtener ms informacin, vea Tipos de datos integrados (Visual C#
Express).
C#
int answer = 42;
string greeting = "Hello, World!";
double bigNumber = 1e100;
System.Console.WriteLine("{0} {1} {2}", answer, greeting, bigNumber);
Constantes.
Una constante es otro tipo de campo. Contiene un valor que se asigna cuando
se compila el programa y nunca cambia despus. Las constantes se declaran
con la palabra clave const; son tiles para que el cdigo sea ms legible.
C#
const int speedLimit = 55;
const double pi = 3.14159265358979323846264338327950;
Una variable readonly es como una constante pero su valor se asigna al iniciar
el programa. Esto le permite establecer el valor basndose en alguna otra

condicin que no conoce hasta que se ejecuta el programa. Pero despus de

esa primera asignacin, el valor no puede cambiar de nuevo mientras el
programa se est ejecutando.
3.2. IDENTIFICAR LOS TIPOS DE DATOS QUE EXISTEN EN VISUAL NET.

C# es un lenguaje con establecimiento inflexible de tipos. Antes de que un valor
se pueda almacenar en una variable, se debe especificar el tipo de la variable,
como en los ejemplos siguientes:
int a = 1;
string s = "Hello";
XmlDocument tempDocument = new XmlDocument();
Observe que el tipo se debe especificar igualmente para los tipos simples
integrados como int y para los tipos complejos o personalizados como
XmlDocument.
C# es compatible con los siguientes tipos de datos integrados:
Tipo de datos Intervalo

byte 0 .. 255
sbyte -128 .. 127
short -32,768 .. 32,767
ushort 0 .. 65,535
int -2,147,483,648 .. 2,147,483,647
uint 0 .. 4,294,967,295
long -9,223,372,036,854,775,808 .. 9,223,372,036,854,775,807
ulong 0 .. 18,446,744,073,709,551,615
float -3.402823e38 .. 3.402823e38
double -1.79769313486232e308 .. 1.79769313486232e308
decimal -79228162514264337593543950335 .. 79228162514264337593543950335
char Un carcter Unicode.
string Una cadena de caracteres Unicode.
bool True o False.
object Un objeto.
Estos nombres de tipo de datos son los alias para los tipos predefinidos en el
espacio de nombres System. Estos se muestran en la seccin Tabla de tipos
integrados (Referencia de C#). Todos estos tipos, salvo el objeto y la cadena,
son tipos de valores. Para obtener ms informacin, vea Tipos de referencia y
de valor (Visual C# Express).
Utilizar los tipos de datos integrados.
Los tipos de datos integrados se utilizan dentro de un programa C# de

diferentes maneras.

Como variables:
C#
int answer = 42;
Como constantes:
C#
const int speedLimit = 55;
const double pi = 3.14159265358979323846264338327950;
Como valores devueltos y parmetros:
C#
long CalculateSum(int a, int b)
{
long result = a + b;
return result;
}
Para definir sus propios tipos de datos, utilice Clases (Visual C# Express),
Enumeraciones (Visual C# Express) o Estructuras (Visual C# Express).
Convertir tipos de datos.
Los tipos de datos se pueden convertir implcitamente, en cuyo caso el

compilador hace automticamente la conversin, o explcitamente utilizando un
operador de conversin explcita, donde el programador fuerza la conversin y
asume el riesgo de perder informacin.
Por ejemplo:
C#
int i = 0;
double d = 0;
i = 10;
d = i; // An implicit conversion
d = 3.5;
i = (int) d; // An explicit conversion, or "cast"
3.3. ANALIZAR LA IMPORTANCIA DE UNA ESTRUCTURA CONDICIONAL.

Los mtodos condicionales permiten a los programadores crear mtodos cuyas

llamadas se pueden colocar en el cdigo y, despus, incluirlos u omitirlos
durante la compilacin segn un smbolo de preprocesamiento.
Suponga que desea habilitar cierto cdigo de asercin en las versiones

generadas para depuracin, y omitirlo en las versiones comerciales. En C++,
existe ms de un modo de implementar esta funcionalidad en el cdigo, por
ejemplo:
Mediante #ifdef se definen ambas versiones, de depuracin y lanzamiento, de

una macro. La versin de depuracin llama al cdigo de seguimiento, mientras
que la versin de lanzamiento no hace nada. Como C# no admite macros, este
mtodo no funciona.
Tener dos implementaciones del cdigo al que se llama. Es decir, en la versin

de depuracin, tener funcionalidad completa y, en la versin comercial, cdigo
auxiliar vaco para los mtodos. Los usuarios eligen cul desean incluir cuando
vinculan el proyecto. El problema de este enfoque es que las versiones
comerciales contienen llamadas a mtodos vacos, y esta configuracin resulta
ms compleja.
Los mtodos condicionales de C# proporcionan una solucin simple a este

problema, similar al primer enfoque indicado anteriormente. Existen dos
mecanismos bsicos para hacerlo:
Definir, mediante #define, el identificador de preprocesamiento directamente en

el cdigo fuente. Vea un ejemplo de este enfoque en Conditional.
Definir el identificador de preprocesamiento en la lnea de comandos de C#

mediante la opcin /define (/d). Este mtodo se utiliza en el siguiente ejemplo.
Los mtodos condicionales se utilizan en la plataforma .NET Framework. El

espacio de nombres System.Diagnostics contiene una serie de clases que
permiten el seguimiento y la depuracin de aplicaciones. Utilice las clases
System.Diagnostics.Trace y System.Diagnostics.Debug para agregar
sofisticadas capacidades de seguimiento y depuracin a una aplicacin (esta
funcionalidad se puede obtener de las versiones comerciales mediante el uso
de mtodos condicionales).
El ejemplo siguiente muestra cmo implementar un mecanismo de seguimiento

muy simple mediante mtodos condicionales. System.Diagnostics.Trace
proporciona mecanismos de seguimiento mucho ms sofisticados, pero utiliza
el mecanismo fundamental que se indica a continuacin para ofrecer esta
funcionalidad.

Ejemplo
Este ejemplo consta de dos archivos de cdigo fuente: el primero es la

biblioteca que proporciona un mecanismo de seguimiento, mientras que el
segundo es el programa cliente que utiliza esta biblioteca.
Archivo #1: crear mtodos condicionales
El cdigo siguiente muestra una simple biblioteca que proporciona un

mecanismo de seguimiento que muestra mensajes en la consola del sistema.
Los clientes pueden incrustar llamadas de seguimiento en el cdigo y, despus,
ser capaces de controlar cundo se utilizan, mediante la definicin de smbolos
en su propia fase de compilacin.
// CondMethod.cs
// compile with: /target:library /d:DEBUG
using System;
using System.Diagnostics;
namespace TraceFunctions
{
public class Trace
{
[Conditional("DEBUG")]
public static void Message(string traceMessage)
{
Console.WriteLine("[TRACE] - " + traceMessage);
}
}
}
Descripcin del cdigo
La siguiente lnea:
[Conditional("DEBUG")]
marca el mtodo Message como condicional (por medio del atributo

Conditional). El atributo Conditional recibe un parmetro: el identificador de
preprocesamiento que controla si se incluye la llamada al mtodo cuando se
compilan los clientes. Si el identificador de preprocesamiento est definido, se
realiza una llamada al mtodo; en caso contrario, la llamada no se inserta en el
cdigo del cliente.
Existen algunas restricciones sobre qu mtodos se pueden marcar como

condicionales; para obtener ms informacin, vea 17.4.2 El atributo Conditional
en Especificacin del lenguaje C#.

Archivo #2: utilizar el mtodo condicional
El siguiente programa cliente utiliza la clase Trace, definida en el archivo #1,

para realizar un seguimiento sencillo.
// TraceTest.cs
// compile with: /reference:CondMethod.dll
// arguments: A B C
using System;
using TraceFunctions;
public class TraceClient

{
public static void Main(string[] args)
{
Trace.Message("Main Starting");
if (args.Length == 0)
{
Console.WriteLine("No arguments have been passed");
}
else
{
for( int i=0; i < args.Length; i++)
{
Console.WriteLine("Arg[{0}] is [{1}]",i,args[i]);
}
}
Trace.Message("Main Ending");
}
}
Descripcin del cdigo
El cdigo condicional se incluye en el cdigo del cliente dependiendo de si el

identificador de preprocesamiento est definido cuando se compila el cdigo
del cliente.
Compilar con el cdigo del cliente y el indicador /d:DEBUG significa que el

compilador inserta la llamada en el mtodo Trace. Si el smbolo no est
definido, la llamada no se realiza.
Ejecucin de ejemplo

El comando:
tracetest A B C
produce el siguiente resultado:
[TRACE] - Main Starting

Arg[0] is [A]
Arg[1] is [B]
Arg[2] is [C]
[TRACE] - Main Ending
El comando:
tracetest
produce el siguiente resultado:
[TRACE] - Main Starting

No arguments have been passed
[TRACE] - Main Ending
Estructuras condicionales simples y compuestas.
La estructura do while es otra estructura repetitiva, la cual ejecuta al menos una

vez su bloque repetitivo, a diferencia del while o del for que podan no ejecutar
el bloque.
Esta estructura repetitiva se utiliza cuando conocemos de antemano que por lo

menos una vez se ejecutar el bloque repetitivo.
La condicin de la estructura est abajo del bloque a repetir, a diferencia del

while o del for que est en la parte superior.
Representacin grfica:

El bloque de operaciones se repite MIENTRAS que la condicin sea

Verdadera.
Si la condicin retorna Falso el ciclo se detiene. En C#, todos los ciclos repiten
por verdadero y cortan por falso.
Es importante analizar y ver que las operaciones se ejecutan como mnimo una
vez.
Problema 1:
Escribir un programa que solicite la carga de un nmero entre 0 y 999, y nos

muestre un mensaje de cuntos dgitos tiene el mismo. Finalizar el programa
cuando se cargue el valor 0.
Diagrama de flujo:

No hay que confundir los rombos de las estructuras condicionales con los de
las estructuras repetitivas do while.
En este problema por lo menos se carga un valor. Si se carga un valor mayor o

igual a 100 se trata de un nmero de tres cifras, si es mayor o igual a 10 se
trata de un valor de dos dgitos, en caso contrario se trata de un valor de un
dgito.
Este bloque se repite hasta que se ingresa en la variable valor el nmero 0 con
lo que la condicin de la estructura do while retorna falso y sale del bloque
repetitivo finalizando el programa.
Ejemplo 1:
Un hombre desea saber cuanto dinero se genera por concepto de intereses

sobre la cantidad que tiene en inversin en el banco.
El decidir reinvertir los intereses siempre y cuando estos excedan a S/.7000, y

en ese caso desea saber cuanto dinero tendr finalmente en su cuenta.
using System;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ejercicio01
{
class Hombre
{
private string nombre;
private float dinero;
public void Inicio()
{
Console.WriteLine("---------BANCO COMOPROGRAMAR.ORG--------");
Console.WriteLine("-----------------------------");
Console.WriteLine("INGRESE SU NOMBRE: ");
nombre = Console.ReadLine();
Console.WriteLine("INGRESE SU MONTO DINERO; ");
dinero = float.Parse(Console.ReadLine());
Console.Clear();
}
public void Imprimir()

{
Console.WriteLine("---------BANCO COMOPROGRAMAR.ORG--------");
Console.WriteLine("-----------------------------");
Console.WriteLine("NOMBRE: " + nombre);
if (dinero > 7000)

{
Console.WriteLine("USTED NO PUEDE EXCEDER EL MONTO DE
S/ 7000");
}
else
{
Console.WriteLine("INVERSION: " + dinero);
}
Console.ReadLine();
}
{
Hombre per = new Hombre();

per.Inicio();
per.Imprimir();
}
}
}
Ejemplo 2:
En un almacn se hace un 20% de descuento a los clientes cuya compra

supere los S/.1000 Cual ser la cantidad que pagara una persona por su
compra?
using System;
using System.Linq;
using System.Text;
namespace ejercicios02
{

class Cliente
{
private float descuento;
private float precio;
public void Inicio()
{
Console.WriteLine("INGRESE PRECIO: ");
precio = float.Parse(Console.ReadLine());
Console.Clear();
}
public void Descuento()
{
if (precio > 1000)
{
float res = (precio * 20) / 100;
descuento = precio - res;
Console.WriteLine("--------TIENDA KEDINN -------");
Console.WriteLine("DESCUENTO DEL 20% POR SUPERAR
S/1000");
Console.WriteLine("PRECIO ES: " + descuento);
Console.ReadLine();
}
else
{
Console.WriteLine("PRECIO ES: " + precio);

Console.ReadLine();
}
Console.ReadKey();
}
{
Cliente clie = new Cliente();
clie.Inicio();
clie.Descuento();
}
}
}

Ejemplo 3:
Un obrero necesita calcular su salario semanal, el cual se obtiene de la

siguiente manera:
- Si trabaja 40 horas o menos se le paga S/.16 por hora
- Si trabaja mas de 40 horas se le paga S/.16 por cada una de las primeras 40
horas y S/.20 por cada hora extra.
using System;
using System.Linq;
using System.Text;
{
class Camisas
{
int camisas;
float precio;
public void Ingresar()
{
Console.WriteLine("INGRESE NUMERO DE CAMISAS");
camisas = int.Parse(Console.ReadLine());
Console.WriteLine("INGRESE PRECIO DE LAS CAMISAS");
}
public void Trabajo()
{
if (camisas >= 3)
{
float a = (precio * 20) / 100;
float b = precio - a;
Console.WriteLine("DESCUENTO 20% PRECIO ES: "+ b);
}
else
{
float a = (precio * 01) / 100;
float b = precio - a;
Console.WriteLine("DESCUENTO 20% PRECIO ES: " + b);
}
Console.ReadKey();
}


{
Camisas sem = new Camisas();
sem.Ingresar();
sem.Trabajo();
}
}
}
Ejemplo 4:
Hacer un algoritmo que calcule el total a pagar por la compra de camisas.
Si se compran tres camisas o mas se aplica un descuento del 20% sobre el

total de la compra y si son menos de tres camisas un descuento del 10%
using System;
using System.Linq;
using System.Text;
{
class Camisas
{
float precio;
public void Ingresar()
{
Console.WriteLine("-----EMPRESA FAEMAS-----");
Console.WriteLine("INGRESE PRECIO DE LAS CAMISAS");

}
public void Trabajo()
{
Console.WriteLine("-----EMPRESA FAEMAS-----");
if (precio >= 500000)
{

Console.WriteLine("la empresa tendr la capacidad de invertir de su propio

dinero un 55% del monto de la compra, pedir prestado al banco un 30% y el
resto lo pagara solicitando un crdito al fabricante ");
}
else
{
Console.WriteLine("la empresa tendr capacidad de invertir de su propio dinero

un 70% y el restante 30% lo pagar solicitando crdito al fabricante. " );
}
Console.ReadKey();
}
{
Camisas sem = new Camisas();
sem.Ingresar();
sem.Trabajo();
}
}
}

FUNDAMENTO TERICO.

Identificadores
Dan nombre a variables, constantes y mtodos.
Constan de caracteres alfanumricos y _
C# es Sensible a maysculas y minsculas.
Han de comenzar con letra o _
No pueden ser una palabra reservada
Abstract, as, base, bool, break, byte, case, catch, char, checked, class,
const, continue, decimal,default, delegate, do, doubl, else, enum, event,
explicit, extern, falce, finally, fixed, float, for, foreach, goto, if, implicit, in,
int, interface, internal, lock, is, long, namespace, new, null, object,
operator, out, override, params, private, protected, public, readonly, ref,
return, sbyte, sealed, short, sizeof, stackaalloc, static, string, struct,
switch, this, throw, true, try, typeof, uint, ulong, unchecked, unsafe,
ushort, using, virtual, void, while.
...si no se usa el carcter @ como prefijo:
Object @this; //@ previene el conflicto con "this"
Constantes
Las clases y las estructuras pueden declarar las constantes como miembros.
Las constantes son valores que se conocen en tiempo de compilacin y no
cambian. (Para crear un valor constante que se inicializa en el tiempo de
ejecucin, utilice la palabra clave readonly.) Las constantes se declaran como
campo utilizando la palabra clave const antes del tipo del campo. Las
constantes se deben inicializar tal como se declaran. Por ejemplo:
C#
class Calendar1
{
public const int months = 12;
}
En este ejemplo, la constante months siempre ser 12 y no se puede cambiar,

ni siquiera puede hacerlo la propia clase. Las constantes tienen que ser de un
tipo integral (sbyte, byte, short, ushort, int, uint, long, ulong, char, float,
double, decimal, bool o string), una enumeracin o una referencia a null.

Se pueden declarar varias constantes del mismo tipo al mismo tiempo, por
ejemplo:
C#
class Calendar2
{
const int months = 12, weeks = 52, days = 365;
}
La expresin utilizada para inicializar una constante puede hacer referencia a

otra constante siempre que no cree una referencia circular. Por ejemplo:
C#
class Calendar3
{
const int months = 12;
const int weeks = 52;
const int days = 365;
const double daysPerWeek = days / weeks;

const double daysPerMonth = days / months;
}
Las constantes se pueden marcar como public, private, protected, internal o

protectedinternal. Estos modificadores de acceso definen cmo los usuarios
de la clase pueden tener acceso a la constante. Para obtener ms informacin,
vea Modificadores de acceso (Gua de programacin de C#).
Es posible tener acceso a las constantes como si fueran campos estticos,

aunque no pueden utilizar la palabra clave static. Las expresiones que no
estn contenidas dentro de la clase que define la constante deben usar el
nombre de la clase, un punto y el nombre de la constante para tener acceso a
la constante. Por ejemplo:
C#
int birthstones = Calendar.months;
C#
int x = 1; // x holds the value 1
x = 2; // now x holds the value 2

El modificador const permite definir variables constantes:

Una constante no cambia nunca su valor.
Son implcitamente static.
Class Class1 {
private const int min = 1;
private const int max = 100;
public const int rango = max min;
static void Main()

{
Console.WriteLine({0}-{1}-{2},
Class1.max,Class1.min,Class1.rango);
// o tambin :
Console.WriteLine({0}-{1}-{2},max, min, rango);
}
}
Variable.
- Una variable representa la localizacin en memoria donde una instancia
de un tipo es guardada.
- Declaracin: <tipodedato> <identificador>;
- Recordar la distincin entre tipos de valor y tipos de referencia
i. Tipos de valor son tipos simples como int, long y char
ii. Los objetos, strings y arrays son ejemplos de tipos de referencia
- Los tipos de valor se derivan de System.ValueType.
- Comparacin entre variables de tipo valor y variables tipo referencia:
I. Variables de tipo valor:
Contienen sus datos directamente.
Cada una tiene su propia copia de datos.
Las operaciones sobre una no afectan a otra.
II. Variables de tipo referencia:
Almacenan referencias a sus datos (conocidos como objetos).
Dos variables de referencia pueden apuntar al mismo objeto.
Las operaciones sobre una pueden afectar a otra.
Una variable representa un valor numrico o de cadena o un objeto de una

clase. El valor que la variable almacena puede cambiar, pero el nombre sigue
siendo el mismo. Una variable es un tipo de campo. El cdigo siguiente es un
ejemplo sencillo de cmo declarar una variable de entero, asignarle un valor y,
a continuacin, asignarle un nuevo valor.

Inicializacin de variables en la declaracin:

bool bln = true;
byte byt1 = 22;
char ch1=x, ch2=\u0061; // Unicode para a
decimal dec1 = 1.23M;
double dbl1=1.23, dbl2=1.23D;
short sh = 22;
int i = 22;
long lng1=22, lng2=22L; // L long
sbyte sb=22;
float f=1.23F;
ushort us1=22;
uint ui1=22, ui2=22U; // U unsigned
ulong ul1=22, ul2=22U, ul3=22L, ul4=2UL;
Los valores de referencia son creados con la palabra

reservada new:
object o = new System.Object();
Una variable String se puede inicializar directamente:
string s = "Hola";
C# soporta secuencias de escape como en C:
string s1 = "Hola\n"; // salto de lnea
string s2 = "Hola\tque\ttal"; // tabulador
Como las sentencias de escape comienzan con \,
para escribir este carcter hay que doblarlo, o usar
@:
string s3 = "c:\\WINNT";
string s4 = @"C:\WINNT";
mbito y Visibilidad:
mbito: lugar donde se declara una variable. Determina su

accesibilidad.
La visibilidad de una variable fuera de su mbito se puede modificar
anteponiendo public o private en su declaracin.
using System;
namespace ConsoleAppVisibilitat
{
class Simple
{
public int Var1=10;

private int Var2=20; //local

public int Var3=30;
}
class Class1
{
{
Simple s = new Simple();
Console.WriteLine("Simple:");
Console.WriteLine("Var1={0},
Var3={1}",s.Var1, s.Var3);
Console.ReadLine();
}
}
}
static: Variable esttica, existe durante toda la ejecucin del programa.

o S lo e xis te una s ola copia de la m is m a s in ne ce s ida d de cre a r obje to
alguno.
o Ha y que re fe rirs e a e lla us a ndo e l nom bre com ple to de l tipo a l que
pertenece.
o No a fe cta a s uvis ibilida d
using System;
namespace ConsoleAppVisibilitatSTAT {
class Simple {
public static int Var3=30; // pblica
// esttica
static int Var4=40; //privada i esttica
public void mostraVar4()
{
Console.WriteLine("Var4={0}", ++Var4);
}
}
class Class1 {
static void Main(string[] args) {
Simple s = new Simple();
Simple k = new Simple();
Console.WriteLine("Simple:");
Console.WriteLine("Var3={0}",Simple.Var3++);
Console.WriteLine("Var3={0}",Simple.Var3);
s.mostraVar4();
k.mostraVar4();
Console.ReadLine();

}
}
}
Conversin entre tipos de datos.

int intValor = 123;
long longValor = intValor; // implcita de int a long
intvalor = (int) longValor; // explcita de long a int con cast
int x = 123456;
long y = x; // implcita
short z = (short)x; // explcita
double d = 1.2345678901234;
float f = (float)d; // explcita
long l = (long)d; // explcita
//uso de la classe Convert:
int c=154;
Console.WriteLine(Convert.ToString(c));
Conversin implcita.
Ocurre de forma automtica.
Siempre tiene xito.
Nunca se pierde informacin
en la conversin.
Conversin explcita.
Requiere la realizacin del cast o
el comando Convert.Toxxx(var)
Puede no tener xito.
Puede perderse informacin en la conversin.
Tabla de conversin implcita segura

Tipo Se convierte de forma segura a:
Byte short, ushort, int, uint, long, ulong, float, double, decimal
Sbyte short, int, long, float, double, decimal
Short int, long, float, double, decimal
Ushort int, uint, long, ulong, float, double, decimal
Int long, float, double, decimal
Uint long, ulong, float, double, decimal
Long float, double, decimal
Ulong float, double, decimal
Float double
Char ushort, int, uint, long, ulong, float, double,decimal

Tipos definidos por el usuario: Enumeraciones

o La s e num e ra cione s s e cre a n cua ndo s e ne ce s ita que una va ria ble
tome valores de una lista limitada no predefinida.
o Tienen por tipo base nmeros enteros.
o P or de fe cto e m pie za la num e ra cin por 0.
o Definicin de una enumeracin: enum
Color { Rojo=1, Verde=2, Azul=3 }
o Uso de una enumeracin:
Color colorPaleta = Color.Rojo; o colorPaleta = (Color)1; // Tipo int a tipo
Color
o Visualizacin de una variable de enumeracin:
Console.WriteLine({0}, colorPaleta.ToString());
// Muestra Rojo
o Usando enumeraciones el cdigo queda ms claro y fcil
de mantener.
Tipos definidos por el usuario: Estructuras

o Definicin:
struct Empleado {
public string nombre;
public int edad;
public int Sueldo = 1200; // error, no permitido!
public Empleado(string nom, int edad )
}
o Uso:
Empleado empresaEmpleado, otroEmpleado;
empresaEmpleado.Nombre = "Juan";
empresaEmpleado.edad = 23;
otroEmpleado = empresaEmpleado; //asignacin directa
o Todos los miembros se se inician por defecto a null

o El mtodo booleano Equals() permite comparar dos structs.
otroEmpleado.Equals(empresaEmpleado)
En C#, las variables se declaran con un tipo de datos y una etiqueta concretos.
Si hasta ahora slo ha utilizado lenguajes con tipos definidos de forma
imprecisa como JScript, estar acostumbrado a emplear el mismo tipo "var"
para todas las variables, pero en C# tiene que especificar si la variable es de
tipo int, float, byte, short u otro cualquiera entre ms de 20 tipos de datos
diferentes. El tipo especifica, entre otras cosas, la cantidad de memoria exacta
que se debe asignar para almacenar el valor cuando la aplicacin se ejecuta. El
lenguaje C# fuerza ciertas reglas al convertir una variable de un tipo en otro.
Para obtener ms informacin, vea Tipos de datos integrados (Visual C#
Express).

C#
int answer = 42;
double bigNumber = 1e100;
System.Console.WriteLine("{0} {1} {2}", answer, greeting, bigNumber);
Arrays
o Los arrays son tipos de referencia derivados de System.Array
o Sus ndices comienzan en 0
Ejemplo: string[] a; // array de cadenas
o El tipo de datos array viene dado por string[]
o El nombre del array es una referencia al array
o Para crear espacio para los elementos usar:
string[] a = new string[100];
Los arrays se pueden inicializar directamente:
string[] animales = {"gato", "perro", "caballo"};
int[] a2 = {1, 2, 3};
Arrays multidimensionales:
string[,] ar = {{"perro","conejo"}, {"gato","caballo"}};
double[,] tempAnual = new double[12,31];
El rango de los elementos del array es dinmico:
i. Si se crea un nuevo array sobre el mismo se libera la memoria que
ocupaba y se pierde toda la informacin que contenia.
Informacin sobre un array:
i. Dimensiones: .Rank
ii. Nmero total de elementos del array: .Length
iii. Nmero de elementos de la dimensin d: .GetLength(d)
5. ndice superior einferior: .
GetLowerBound(d);
.GetUpperBound(d);
(d=dimensin, desde 0 hasta Rank-1) Saber si es un array: if (a is Array)
Recorrido de los elementos de un array sin conocer sus ndices
foreach (string a in animales)
Console.WriteLine(a);
Operaciones de la clase Array: Copy( ); Sort( ); ...
Manipulacin de cadenas
o Los tipos char y string permiten manipular caracteres.
o Una variable char puede contener cualquier carcter Unicode
o Manipulacion de caracteres:
char.IsDigit();char.IsLetter();char.IsPunctuation();char.ToUpper(
);char.ToLower(),char.ToString();..., etc.

o Una variable tipo string es una referencia al lugar donde se guarda la

cadena.
o Cada vez que se modifica el valor de la cadena se asigna un nuevo
bloque de memoria y se libera el anterior.
o Concatenacin: Nuevo operador + (no existe en C, C++) o se puede
usar tambin el mtodo: String.Concat()
string a, b;
a="Programaci ";
b=amb C#";
Console.WriteLine(Usant operador + en {0}", a+b);
Console.WriteLine(" Usant concat en {0}",
string.Concat(a, b));
IDENTIFICAR LOS TIPOS DE DATOS QUE EXISTEN EN VISUAL NET:
En este tema se describen algunas de las similitudes y diferencias principales

en cmo se representan y asignan los datos, y se recolectan los elementos no
utilizados en Java y en C#.
Tipos de datos compuestos.
El concepto de clase como tipo de datos compuesto de campos, mtodos y

eventos es similar en Java y C#. (La herencia de clases se describe
independientemente en el tema titulado Herencia y clases derivadas (C# y
Java).) C# introduce el concepto de estructura como tipo de datos compuesto
asignado por pila que no admite la herencia. En la mayora de los otros
aspectos, las estructuras son muy similares a las clases. Las estructuras
proporcionan una manera ligera de agrupar campos y mtodos relacionados
para el uso en los bucles de pequeas dimensiones y otros escenarios donde
el rendimiento es crucial.
C# permite crear un mtodo de destructor al que se llama antes de que se

destruyan las instancias de una clase. En Java, se puede utilizar un mtodo
finalize para contener cdigo que limpia los recursos antes de que se
recolecten los elementos no utilizados del objeto. En C#, el que realiza esta
funcin es el destructor de clase. El destructor se parece a un constructor sin
los argumentos y con un carcter de tilde delante (~).
Tipos de datos integrados.
C# proporciona todos los tipos de datos que estn disponibles en Java y

agrega compatibilidad para los nmeros sin signo y un nuevo tipo de punto
flotante de 128 bits de alta precisin.

Para cada tipo de datos primitivo en Java, la biblioteca de clases principal

proporciona una clase contenedora, que lo representa como un objeto de Java.
Por ejemplo, la clase Int32 contiene el tipo de datos int y la clase Double
contiene el tipo de datos double.
Por otro lado, todos los tipos de datos primitivos en C# son objetos en el
espacio de nombres System. Para cada tipo de datos, se proporciona un
nombre corto o alias. Por ejemplo, int es el nombre corto correspondiente a
System.Int32 y double es la forma abreviada de System.Double.
En la tabla siguiente se proporciona la lista de tipos de datos de C# y sus alias.

Como puede ver, los primeros ocho de estos tipos corresponden a los tipos
primitivos disponibles en Java. Sin embargo, tenga en cuenta que el tipo
boolean de Java se denomina bool en C#.
Nombre Clase
Tipo Ancho Intervalo (bits)
corto .NET
byte Byte Entero sin signo 8 0 a 255
sbyte SByte Entero con signo 8 -128 a 127
-2.147.483.648 a
int Int32 Entero con signo 32
2.147.483.647
uint UInt32 Entero sin signo 32 0 a 4294967295
short Int16 Entero con signo 16 -32.768 a 32.767
ushort UInt16 Entero sin signo 16 0 a 65535
-922337203685477508 a
long Int64 Entero con signo 64
922337203685477507
ulong UInt64 Entero sin signo 64 0 a 18446744073709551615
Tipo de punto flotante de
float Single 32 -3,402823e38 a 3,402823e38
precisin simple
Tipo de punto flotante de -1,79769313486232e308 a
double Double 64
precisin doble 1,79769313486232e308
Smbolos Unicode utilizados
char Char Un carcter Unicode 16
en el texto
bool Boolean Tipo Boolean lgico 8 True o false
Tipo base de todos los otros
object Object
tipos
string String Una secuencia de caracteres
Tipo preciso fraccionario o
integral, que puede
1.0 10e28 a
decimal Decimal representar nmeros 128
7.9 10e28
decimales con 29 dgitos
significativos

Dado que C# representa todos los tipos de datos primitivos como objetos, es
posible llamar a un mtodo de objeto de un tipo de datos primitivo. Por ejemplo:
C#
static void Main()
int i = 10;
object o = i;
System.Console.WriteLine(o.ToString());
Esto se logra con la ayuda de las conversiones automticas boxing y unboxing.

Para obtener ms informacin, vea Conversin boxing y unboxing (Gua de
programacin de C#).
Constantes.
Java y C# proporcionan la capacidad para declarar una variable cuyo valor se

especifica en tiempo de compilacin y no se puede cambiar en tiempo de
ejecucin. Java utiliza el modificador de campo final para declarar este tipo de
variable, mientras que C# utiliza la palabra clave const. Adems de const, C#
proporciona la palabra clave readonly para declarar variables a las que se
puede asignar un valor una vez en tiempo de ejecucin, ya sea en la
instruccin de declaracin o en otra parte del constructor. Despus de la
inicializacin, el valor de una variable readonly no puede cambiar. Un escenario
en el que las variables readonly son tiles es cuando los mdulos que se han
compilado independientemente tienen que compartir datos como un nmero de
versin. Si el mdulo A se actualiza y se vuelve a compilar con un nuevo
nmero de versin, el mdulo B se puede inicializar con ese nuevo valor
constante sin tener que volver a compilarlo.
Enumeraciones.
Las enumeraciones se utilizan para agrupar constantes con nombres en forma

similar a la forma en que se utilizan en C y C++; no estn disponibles en Java.
En el ejemplo siguiente se define una enumeracin Color sencilla.
C#
public enum Color

{
Green, //defaults to 0
Orange, //defaults to 1
Red, //defaults to 2
Blue //defaults to 3
}
Tambin se pueden asignar valores integrales a las enumeraciones, tal como

se muestra en la siguiente declaracin de enumeracin:
C#
public enum Color2
{
Green = 10,
Orange = 20,
Red = 30,
Blue = 40
}
En el siguiente ejemplo de cdigo se llama al mtodo GetNames del tipo Enum

para mostrar las constantes disponibles para una enumeracin. Luego, asigna
un valor a una enumeracin y muestra el valor.
C#
class TestEnums
{
static void Main()
{
System.Console.WriteLine("Possible color choices: ");
//Enum.GetNames returns a string array of named constants for the enum.

foreach(string s in System.Enum.GetNames(typeof(Color)))
{
System.Console.WriteLine(s);
}
Color favorite = Color.Blue;
System.Console.WriteLine("Favorite Color is {0}", favorite);

System.Console.WriteLine("Favorite Color value is {0}", (int) favorite);
}

Resultado.
Possible color choices:
Green
Orange
Red
Blue
Favorite Color is Blue
Favorite Color value is 3
Cadenas.
Los tipos de cadena en Java y C# denotan un comportamiento similar con
leves diferencias. Ambos tipos de cadena son inmutables, lo que significa que
los valores de las cadenas no se pueden cambiar una vez que se han creado
las cadenas. En ambos casos, los mtodos que parecen modificar el contenido
real de una cadena crean en realidad una nueva cadena que se devolver
como resultado, dejando la cadena original sin cambios. El proceso de
comparacin de los valores de cadena es diferente en C# y Java. Para
comparar los valores de cadena en Java, los desarrolladores deben llamar al
mtodo equals de un tipo string, mientras que el operador == compara los tipos
de referencia de forma predeterminada. En C#, los desarrolladores pueden
utilizar los operadores == o != para comparar directamente valores de cadena.
Aunque una cadena es un tipo de referencia en C#, los operadores == y !=
compararn, en forma predeterminada, los valores de las cadenas en lugar de
las referencias.
Como en Java, los desarrolladores de C# no deben usar el tipo string para

concatenar cadenas con el fin de evitar la sobrecarga de crear nuevas clases
de cadenas cada vez que se concatene la cadena. En su lugar, los
desarrolladores pueden utilizar la clase StringBuilder, que es funcionalmente
equivalente a la clase StringBuffer de Java.
Literales de cadena.
C# proporciona la posibilidad de evitar el uso de secuencias de escape como

"\t" para la ficha o "\" para los caracteres de barra diagonal inversa dentro de
las constantes de cadena. Para ello, simplemente declare la cadena textual
mediante el smbolo @ para preceder la asignacin del valor de cadena. Los
siguientes ejemplos muestran cmo utilizar los caracteres de escape y cmo
asignar literales de cadena:
C#
static void Main()
{
//Using escaped characters:
string path1 = "\\\\FileShare\\Directory\\file.txt";
System.Console.WriteLine(path1);
//Using String Literals:

string path2 = @"\\FileShare\Directory\file.txt";
System.Console.WriteLine(path2);
}
Conversin y conversin de tipos.
Java y C# siguen reglas similares para la conversin automtica y la

conversin de tipos de datos.
Al igual que Java, C# admite conversiones de tipo implcitas y explcitas. En el

caso de conversiones de ampliacin, las conversiones son implcitas. Por
ejemplo, la siguiente conversin de int a long es implcita, como en Java:
C#
int int1 = 5;
long long1 = int1; //implicit conversion
La siguiente es una lista de conversiones implcitas entre los tipos de datos de

.NET Framework:
Tipo de origen Tipo de destino

Byte short, ushort, int, uint, long, ulong, float, double o decimal
Sbyte short, int, long, float, double o decimal
Int long, float, double o decimal
Uint long, ulong, float, double o decimal
Short int, long, float, double o decimal
Ushort int, uint, long, ulong, float, double o decimal
Long float, double o decimal
Ulong float, double o decimal
Float double
Char ushort, int, uint, long, ulong, float, double o decimal
Puede convertir el tipo de expresiones que desee convertir explcitamente

usando la misma sintaxis que en Java:
C#

long long2 = 5483;
int int2 = (int)long2; //explicit conversion
La tabla siguiente muestra las conversiones explcitas.
Tipo de origen Tipo de destino

Byte sbyte o char
Sbyte byte, ushort, uint, ulong o char
Int sbyte, byte, short, ushort, uint, ulong o char
Uint sbyte, byte, short, ushort, int o char
Short sbyte, byte, ushort, uint, ulong o char
Ushort sbyte, byte, short o char
Long sbyte, byte, short, ushort, int, uint, ulong o char
Ulong sbyte, byte, short, ushort, int, uint, ulong o char
Float sbyte, byte, short, ushort, int, uint, long, ulong, char o decimal
Double sbyte, byte, short, ushort, int, uint, long, ulong, char o decimal
Char sbyte, byte o short
Decimal sbyte, byte, short, ushort, int, uint, long, ulong, char, float o double
Tipos de referencia y valor.
C# admite dos tipos de variables:
Tipos de valor.
Estos son los tipos de datos primitivos integrados, como char, int y float, as
como tambin los tipos definidos por el usuario declarado con la estructura.
Tipos de referencia.
Clases y otros tipos de datos complejos que se construyen a partir de los tipos
primitivos. Las variables de estos tipos no contienen una instancia del tipo, sino
slo una referencia a una instancia.
Si se crean dos variables del tipo de valor, i y j, como se muestra a

continuacin, i y j son completamente independientes entre s:
C#
int i = 10;
int j = 20;
Tienen ubicaciones de memoria independiente:

Si cambia el valor de una de estas variables, la otra no se ver afectada de

forma natural. Por ejemplo, si tiene una expresin como la siguiente, an no
existe ninguna conexin entre las variables:
C#
int k = i;
Es decir, si cambia el valor de i, k permanecer con el valor que tena i en el
momento de la asignacin.
C#
i = 30;
System.Console.WriteLine(i.ToString()); // 30
System.Console.WriteLine(k.ToString()); // 10
Sin embargo, los tipos de referencia actan de forma diferente. Por ejemplo,
podra declarar dos variables de la siguiente forma:
C#
Employee ee1 = new Employee();
Employee ee2 = ee1;
Ahora, puesto que las clases son tipos de referencia de C#, ee1 se conoce
como referencia a Employee. La primera de las dos lneas anteriores crea una
instancia de Employee en memoria y define ee1 para que haga referencia a
ella. As, cuando se establece ee2 para que sea igual a ee1, el primero
contiene un duplicado de la referencia a la clase de la memoria. Si ahora
cambia las propiedades de ee2, las propiedades de ee1 reflejan estos cambios,
ya que ambas apuntan al mismo objeto de la memoria, tal como aparece a
continuacin:

Conversiones boxing y unboxing
El proceso de convertir el tipo de un valor en el tipo de una referencia se

denomina conversin boxing. El proceso inverso, convertir el tipo de una
referencia en el tipo de un valor, se denomina conversin unboxing. Esto queda
reflejado en el ejemplo de cdigo siguiente:
C#
int i = 123; // a value type
object o = i; // boxing
int j = (int)o; // unboxing
Java requiere que esas conversiones se realicen manualmente. Los tipos de

datos primitivos se pueden convertir en objetos de clases contenedoras
construyendo esos objetos o aplicando la conversin boxing.
De igual manera, los valores de los tipos de datos primitivos se pueden extraer
de los objetos de las clases contenedoras llamando a un mtodo adecuado de
estos objetos, o realizar una conversin unboxing. Para obtener ms
informacin acerca de las conversiones boxing y unboxing, vea Conversin
boxing y unboxing (Gua de programacin de C#).

ANALIZAR LA IMPORTANCIA DE UNA ESTRUCTURA CONDICIONAL.

Que es una estructura?
es la
SINTAXIS
*(Bnf + ebnf + diagramas de sintaxis)
Sumado a la
SEMNTICA
*Operacional (aproximacion utulizada aqui)
*Formal (a traves de mecanismos rigurosos y exactos)
*Semantica operacional: se describe el significado de cada construccion del
lenguaje en terminos de las operaciones correspondientes en un proceso
abstracto.
Sintxis de los lenguajes de programacin.

La sintaxis de un lenguaje de programacin es la estructura en que se
organizan los distintos elementos sintcticos, como espacios, identificadores,
operadores, etc. Es decir el orden que tienen unos con respecto a otros.
Una sintaxis se evala segn varios criterios: que sea fcil de leer, de escribir,
de verificar (chequear en busca de errores), fcil de traducir y que carezca de
ambigedad. Esta ltima significa que un mismo cdigo puede tener 2 o ms
interpretaciones o traducciones posibles, en cuyo caso no se puede decidir que
alternativa elegir.
Los elementos de la sintxis son: alfabeto, identificadores (nombres de

variables, constantes, etc.), smbolos de operadores (+,-,etc.), espacios en
blanco, delimitadores y corchetes, palabras pregonadas (palabras que se
pueden omitir sin alterar el significado), palabras clave y reservadas (propias
del lenguaje), comentarios y expresiones.
El principal problema de una sintxis es cmo se la define. Para esto existen

metalenguajes que permiten definir la manera en que se combinan los
smbolos y elementos. Estos metalenguajes o notaciones formales son un
conjunto de reglas que especifican el modelo de construccin de las cadenas
aceptadas por el lenguaje. Es decir que un metalenguaje es un lenguaje que
define a un lenguaje de programacin. Sus elementos son smbolo distinguido,
metasmbolos y metavariables.
Smbolo distinguido: Punto de partida para la generacin de todas las cadenas.

Metasmbolos: ( | (o), ::= (es), ).Metavariables: Pueden ser terminales o no

terminales.
- Terminales: Son palabras que forman los smbolos no terminales.

- No terminales: Son identificadores que tienen un definicin hecha con ms
metavariables, de manera que es posible reemplazarlas por sus definiciones.
Otra manera de llamarlo a este tipo de gramticas es "gramticas BNF"

(Backus Naur Form), que son un metalenguaje que define las reglas de
formacin de las cadenas aceptadas por un lenguaje de programacin. Fueron
inventadas por Backus Naur para el desarrollo del lenguaje de programacin
Algol 60.
Ejemplo: ::= {}+ |
{}+
Existe una representacin visual de una gramtica BNF, que son los grafos
sintcticos. Esots usan flechas, crculos y rectngulos. Sus ventajas son que
son ms fciles de entender para el ojo humano.
Una vez que tenemos definada la sintxis de nuestro lenguaje, el compilador

deber determinar si las cadenas de texto ingresadas por los usuarios son
vlidas de acuerdo a esta sintxis. Para esto se utilizan rboles de anlisis
sintctico y algoritmos de parsing.
Semntica.
La semntica de un lenguaje de programacin se refiere al significado que

adoptan las distintas sentencias, expresiones y enunciados de un programa. La
semntica engloba aspectos sensibles al contexto, a diferencia de la sintaxis
que considera aspectos libres de contexto.
Los principales elementos de la semntica son:
Variables: se refieren a locaciones de memoria ligadas a un nombre y a un tipo.
Valores y referencias: los valores son el estado de determinada celda o grupo

de celdas de la memoria, mientras que las referencias indican la posicin de
esa celda en memoria. Estos 2 conceptos estn muy involucrados con los
punteros. La mayora de los lenguajes los soportan, aunque son una conocida
fuente de errores de programacin.

Expresiones: Son construcciones sintcticas que permiten combinar valores

con operadores y producir nuevos valores. Son los elementos de los que se
componen los enunciados. Las expresiones pueden ser aritmticas (a +b*c),
relacionales (a a), lgicas (a && b || c)
o condicionales (if (a*b > 2)...). Cada una de estas tiene una semntica
especifica que la define. Por ejemplo en una expresin aritmtica el tipo
esperado es numrico (esto es int, long, etc.), los operadores deben ser +,-,*, /;
y las funciones utilizadas dentro de sta deben retornar valores numricos.
Semntica esttica. Gramtica de atributos: Las gramticas de atributos son

ms poderosas que las BNF porque permiten formalizar aspectos sensibles al
contexto.
Por ejemplo, el chequeo de tipos depende del contexto porque debemos saber
el tipo esperado y el actual y determinar si son compatibles. El tipo esperado lo
obtenemos del contexto analizando la definicin de la variable. Si la variable
num1 est definida de tipo String, y ms adelante le queremos asignar el valor
1000, se producir un error de tipo.
La gramtica de atributos de compone de:
Atributos: o heredados: son los que se obtienen de un elemento ms general.

Esquema de arriba hacia abajo. Por ejemplo, number y float. En este caso float
heredar los atributos de number e incorporar nuevos atributos propios de su
tipo.
Sintetizados: se conocen a partir de los subelementos, como ser un subrango.

Esquema de abajo hacia arriba, opuesto a los atributos heredados.
Intrnsecos: Estos atributos se obtienen de tablas externas, fuera del rbol de

derivacin.
Condiciones: Son hechos que se evalan si suceden o no.
Por ejemplo, if(num>=20) ...
Reglas: A partir de un conjunto de condiciones se forman las reglas.
Por ejemplo:

Teorema del programa estructurado
El teorema del programa estructurado es un resultado en la teora de

lenguajes de programacin. Establece que toda funcin computable puede ser
implementada en un lenguaje de programacin que combine slo tres
estructuras lgicas. Esas tres formas (tambin llamadas estructuras de control)
especficamente son:
1. Secuencia: ejecucin de una instruccin tras otra.

2. Seleccin: ejecucin de una de dos instrucciones (o conjuntos), segn el
valor de una variable booleana.
3. Iteracin: ejecucin de una instruccin (o conjunto) mientras una variable
booleana sea 'verdadera'. Esta estructura lgica tambin se conoce como
ciclo o bucle.
Este teorema demuestra que la instruccin GOTO no es estrictamente

necesaria y que para todo programa que la utilice existe otro equivalente que
no hace uso de dicha instruccin.
Los cientficos de la computacin usualmente acreditan el teorema a un artculo

de 1966 escrito por Corrado Bhm y Giuseppe Jacopini. Sin embargo, David
Harel rastre sus orgenes hasta la descripcin de 1946 de la arquitectura de
von Neumann y el teorema de la forma normal de Kleene.
La demostracin de Bhm-Jacopini describe cmo construir diagramas de flujo

estructurados a partir de cualquier digrama de flujo, usando los bits de una
variable entera extra para dar seguimiento a la informacin que el programa
original representa mediante puntos de entrada en el cdigo. Esta construccin
estuvo basada en el lenguaje de programacin P de Bhm. La demostracin
de Bhm-Jacopini no esclareci la cuestin sobre cundo convendra usar
programacin estructurada para el desarrollo de software, en parte porque la
construccin ofuscaba el cdigo del programa en lugar de mejorarlo. Por otro
lado, fue el punto de partida para iniciar el debate. Edsger Dijkstra escribi una
importante carta titulada "La sentencia Go To considerada daina" en el ao
1968. Posteriores estudios agregaron aproximaciones ms prcticas a la

demostracin de Bhm-Jacopini, que mantenan o mejoraban la claridad del

programa original.
Ventajas de la programacin estructurada
Ventajas de la programacin estructurada comparada con el modelo anterior

(hoy llamado despectivamente cdigo espagueti).
Los programas son ms fciles de entender, pueden ser ledos de forma

secuencial y no hay necesidad de hacer engorrosos seguimientos en saltos
de lneas (GOTO) dentro de los bloques de cdigo para intentar entender la
lgica.
La estructura de los programas es clara, puesto que las instrucciones estn
ms ligadas o relacionadas entre s.
Reduccin del esfuerzo en las pruebas y depuracin. El seguimiento de los
fallos o errores del programa ("debugging") se facilita debido a su estructura
ms sencilla y comprensible, por lo que los errores se pueden detectar y
corregir ms fcilmente.
Reduccin de los costos de mantenimiento. Anlogamente a la depuracin,
durante la fase de mantenimiento, modificar o extender los programas
resulta ms fcil.
Los programas son ms sencillos y ms rpidos de confeccionar.
Se incrementa el rendimiento de los programadores, comparado con la
forma anterior que utiliza GOTO.
Programacin estructurada de bajo nivel.
En un bajo nivel, los programas estructurados con frecuencia estn

compuestos de simples estructuras de flujo de programa jerrquicas. Estas son
secuencia, seleccin y repeticin:
"Secuencia" se refiere a una ejecucin ordenada de instrucciones.

En "seleccin", una de una serie de sentencias es ejecutada dependiendo
del estado del programa. Esto es usualmente expresado con palabras clave
como if..then..else..endif, switch, o case. En algunos lenguajes las palabras
clave no se puede escribir textualmente, pero debe ser delimitada
(stropped).
En la "repeticin" se ejecuta una sentencia hasta que el programa alcance
un estado determinado, o las operaciones han sido aplicadas a cada
elemento de una coleccin. Esto es usualmente expresado con palabras
clave como while, repeat, for o do..until. A menudo se recomienda que cada
bucle slo debe tener un punto de entrada (y en la programacin estructural
original, tambin slo un punto de salida, y pocos lenguajes refuerzan esto).

Representaciones grficas de los tres patrones bsicos. Los diagramas de caja

(azules) fueron inventados para la nueva teora, y aqu se pueden ver sus
equivalentes en los ms usados diagramas de flujo de control
Un lenguaje es descrito como estructurado en bloque cuando tiene una sintaxis

para encerrar estructuras entre palabras clave tipo corchete, como una
sentencia if..fi en ALGOL 68, o una seccin de cdigo entre corchetes
BEGIN..END, como en PL/I - o la de llaves {...} de C y muchos otros lenguajes
posteriores.
Estructuras estticas
Tipos primitivos:
Tipos numricos:
Enteros: se representan en memoria como una secuencia de bits que de

acuerdo a su posicin y valor (0 o 1) simbolizan el valor.
Flotantes: existen 2 implementaciones bsicas, flotantes de 32 y 64 bits. Se

valor se representa por 3 partes que son el signo, el exponente y la mantisa. En
los de 32 bits, el exponente ocupa 8 bits y el resto la mantisa y el signo. En los
de 64 bits el exponente ocupa 11 bits.
Carcteres: Cada secuencia de bits tiene un smbolo asociado. Originalmente

ocupan 8 bits como representacin ASCII. Luego la representacin se extendi
a 16 bits como Unicode para almacenar ms cantidad de smbolos (de otros
idiomas). Esta representacin facilita la internacionalizacin.
Booleanos: son un tipo relativamente nuevo. Se desperdicia espacio de

almacenamiento porque los valores verdadero y falso se pueden representar
con un solo bit, pero el mnimo permitido en los sistemas actuales son 8 bits.
Posibilidad de empaquetamiento para vectores de booleanos. Permiten
operaciones lgicas. Aportan mayor legibilidad al cdigo y ms confiabilidad
(menos posibilidad de confusiones).
Tipos definidos por el usuario:

Tipos enumerados: se pueden representar internamente con valores numricos

secuenciales, aunque las enumeraciones sean palabras u otros datos.
sub-intervalos: al ser menos cantidad de valores, necesitan menos espacio de

almacenamiento. Posibilidad de empaquetarlos.
Tipos estructurados:
Arreglos: almacenan tipos iguales. El acceso a sus elementos es, en general,

por posicin. Los arreglos pueden ser estticos o dinmicos, y
redimensionables o no. Los arreglos se almacenan de manera continua en
memoria, salvo que sean redimensionables.
Registros: Pueden almacenar distintos campos dentro de s, incluidos ms

registros y arreglos. Son muy tiles para mejorar la legibilidad y facilidad de
escritura. En Pascal y en Ada tambin existen los registros variantes. En C se
usa la palabra reservada "struct" para definirlos.
Unin: es una locacin de memoria asociada a muchos tipos de datos, o sea

que puede ser interpretada de distintas maneras. La provee el lenguaje C.
Conjunto: es una estructura de datos con muchos elementos distintos, es decir

que no los hay repetidos. Los conjuntos permiten hacer operaciones de unin,
interseccin y diferencia entre ellos.
Estructuras dinmicas: son ideales para modelar situaciones de la vida real,

con capacidades excepcionales de flexibilidad.
Listas: almacenan elementos de distinto tipo. Son redimensionables e ideales

para insertar y eliminar elementos. Pueden ser simple o doblemente enlazadas.
Se implementan con una referencia al siguiente elemento, que puede estar en
cualquier locacin de memoria. Con 2 referencias, una direcciona al elemento
anterior y otra al siguiente. ptimas para recorrerlas de arriba hacia abajo y
viceversa.
rboles: cada nodo almacena 2 o ms apuntadores a sus nodos hijos.

Tenemos muchos tipos de rboles, como rboles binarios, B+, B*, etc. Adems
pueden tener una referencia al nodo padre (uno solo) y esto permite recorrer el
rbol de abajo hacia arriba.
Grafos: cada nodo almacena una o varias referencias a los nodos con los que
est conectado. Si el grafo es dirigido (con direccin de lectura) hay que
proyectar almacenar esta informacin. Los grafos son tiles en aplicaciones
que usan mapas de ciudades, sistemas operativos, videojuegos, etc. Requieren

algoritmos especiales para recorrerlos ya que es una de las estructuras

dinmicas ms complejas.
Chequeo esttico y dinmico de tipos: Los chequeos estticos comprueban la

consistencia de tipos en tiempo de compilacin, es decir, estticamente. Es
ms seguro porque no genera el ejecutable hasta que no haya ningn error de
tipo. Es menos flexible que el dinmico. Los lenguajes con chequeo esttico
son fuertemente tipados, esto es que el chequeo se realiza de una manera
exhaustiva.
El chequeo dinmico, por su parte, es ms flexible pero mucho menos seguro y

confiable que el esttico. Aumenta la sobrecarga durante la ejecucin. El
chequeo se realiza en tiempo de ejecucin.
Abstraccin de datos: La abstraccin de datos permite dividir un gran problema

en problemas menores para simplificar, definir interfaces de acceso para la
manipulacin del dato, y oscurecer la implementacin de forma de hacerla
transparente para el usuario.
Una manera de lograr cierto nivel de abstraccin son los "tipos genricos". Son
abstracciones de datos que permiten ser usados en distintos contextos y usar
una misma implementacin para distintos tipos y estructuras de datos. Ej: En
Java estn implementados con el uso de la clase Object, Number, Container,
etc. Ahorra trabajo y esfuerzo al programador, a la vez que simplifican la
implementacin.
Los "tipos parametrizados" son otra manera de generar abstraccin.. Se

construyen en base a parmetros.
Polimorfismo: El polimorfismo est basado en el concepto de la manipulacin

de entidades de distinto tipo. Un lenguaje polimrfico es aquel que sus
entidades pueden estar ligadas a ms de un tipo. Una funcin es polimrfica si
acepta operandos de distintos tipos. Y un tipo es polimrfico si sus operaciones
son polimrficas.
Coercin, conversin y compatibilidad: La coercin es la conversin automtica

de un tipo a otro. Ocurre cuando el tipo en cuestin es un subtipo de otro (o
una subclase en el paradigma orientado a objetos). El principio que gobierna
las coerciones es no perder informacin. Las conversiones son
transformaciones del tipo de una entidad a otro. Por ejemplo, en muchos
lenguajes las asignaciones de enteros de 32 bits a enteros de 16 bits requieren
la accin del programador porque se puede perder informacin (no hay manera
de representar el rango de 32 bits con slo 16).

Inferencia de tipos: en algunos lenguajes como ML es posible la inferencia de

tipos. Al no especificarse el tipo de un dato, es inferido a partir del uso que se
hace de l. Es decir, de las funciones que lo manipulan. Ejemplo en ML: fun
resto(n) = n mod 2.
En esta funcin el tipo del parmetro no est indicado, pero como la funcin
mod se aplica nicamente a tipos enteros se infiere este tipo para "n". En
algunos casos es muy difcil hacer la inferencia debido al alto polimorfismo de
la funcin usada (a la cantidad de tipos que acepta). Por ejemplo en fun (a,b) =
a+b; es difcil determinarlo porque "+" puede sumar nmeros o concatenar
cadenas de texto.
Instrucciones.
Generalmente disponemos de 2 tipos de instrucciones, asignacin y de control.
La asignacin puede ser simple, mltiple o condicional. Se puede realizar en

las declaraciones. Algunos lenguajes permiten asignacin mltiple, mientras
que otros slo admiten la simple. Por su parte, as como disponemos de
estructuras para controlar la evaluacin de las expresiones y la ejecucin de las
unidades, tambin las tenemos para controlar instrucciones. Estructuras de
control a nivel instruccin:
Secuencia:: Es la ejecucin en orden, una sentencia despus de la anterior. Se

puede modificar con saltos incondicionales como el GOTO, aunque el uso
excesivo de este altera demasiado la secuencialidad del cdigo y lo hace
ilegible.
Seleccin:: Probablemente es una de las primeras estructuras usadas.

Permiten bifurcar o seleccionar el cdigo a ejecutar de acuerdo al valor lgico
que resulta de evaluar una condicin. Generalmente se implementa con la
palabra reservada "if...else...".
Iteracin:: La iteracin evita repeticiones de cdigo innecesarias. Disponemos

de iteraciones condicionales e incondicionales. Las primeras consumen ms
tiempo que las segundas debido a que se debe evaluar la condicin en cada
ciclo. Por su parte, las incondicionales se usan para recorrer vectores,
matrices, etc.
Unidades.
Los subprogramas se dividen en dos categoras, procedimientos y funciones.

La diferencia entre estos es que los procedimientos no retornan valores, sino
que realizan una accin. Por ejemplo, procesarArreglo(int[ ] ...). Las funciones

devuelven un valor que puede ser un tipo primitivo, y en algunos en lenguajes

modernos pueden ser tambin objetos.
Un subprograma tiene 3 partes bsicas, a saber: inicio, suspensin y control. El

inicio puede producirse por una llamada desde el programa principal o desde
otro subprograma. La suspensin se produce con la invocacin de un
subprograma. Cuando un programa o subprograma la hace, se suspende
temporalmente mientras se ejecuta el subprograma invocado. Esto pasa
porque generalmente es necesario procesar un conjunto de datos antes de
hacer otro proceso, y no se puede comenzar el segundo sin la totalidad de los
primeros datos procesados. Por otra parte, hay distintas maneras de controlar
un subprograma, que pueden ser implcitas (excepciones) o explcitas (relacin
jerrquica, simtrica o paralela).
ESTRUCTURAS SECUENCIALES.
La estructura secuencial es aquella en la que una accin (instruccin) sigue a

otra en secuencia. Las tareas se suceden de tal modo que la salida de una es
la entrada de la siguiente y as sucesivamente hasta el fin del proceso.
En Pseudocdigo una Estructura Secuencial se representa de la siguiente

forma:
PSEUDOCODIGO Nombre
VARIABLES
Nombre: Tipo De Dato
CONSTANTES
Nombre = Valor
INICIO
accion
accion1
accion2
.
.
.
accionN
FIN
En Diagrama de Flujo:

Ejemplo 1: Escriba un algoritmo que pregunte por dos nmeros y muestre

como resultado la suma de estos. Use Pseudocdigo y diagrama de flujos.
PSEUDOCODIGO SUMAR
VARIABLES
Num1,Num2,Suma: Entero
INICIO
Escribir ('introduzca dos numeros')
leer (Num1, Num2)
Suma=Num1 + Num2
escribir ('La suma es:' , Suma)
FIN
Ejemplo 2:
Escriba un algoritmo que permita conocer el rea de un tringulo a partir de la
base y la altura. Exprese el algoritmo usando Pseudocdigo y diagrama de
flujos.

PSEUDOCODIGO AREA
VARIABLES
Base, Altura: Entero
INICIO
Escribir ('ingrse la base')
Leer (Base)
Escribir ('Ingrese Altura')
Leer (Altura)
Escribir('el areadel triangulo es:' , (Base*Altura)/2
FIN
Expreciones lgicas.
Sirven para plantear condiciones o comparaciones y dan como resultado un
valor booleano verdadero o falso, es decir, se cumple o no se cumple la
condicin. Se pueden clasificar en simples y complejas. Las simples son las
que usan operadores relacionales y las complejas las que usan operadores
lgicos.
Ejemplos:
Un ejemplo en el cual usamos el operador lgico AND sera:
Una escuela aplica dos exmenes a sus aspirantes, por lo que cada uno de
ellos obtiene dos calificaciones denotadas como C1 y C2. El aspirante que
obtenga calificaciones mayores que 80 en ambos exmenes es aceptado; en
caso contrario es rechazado.

En este ejemplo se dan las condiciones siguientes:
Si (C1 >= 80) y (C2 >= 80) entonces

Escribir ("aceptado")
Sino
Escribir ("rechazado")
Fin_si
Note que tambin usa operadores relacionales. Por lo general cuando hay
operadores lgicos, stos van acompaados de operadores relacionales. Un
ejemplo usando el operador lgico OR sera:
Una escuela aplica dos exmenes a sus aspirantes, por lo que cada uno de
ellos obtiene dos calificaciones denotadas como C1 y C2. El aspirante que
obtenga una calificacin mayor que 90 en cualquiera de los exmenes es
aceptado; en caso contrario es rechazado.
En este caso se dan las condiciones siguientes:
Si (C1 >=90) or (C2 >=90) entonces

Escribir ("aceptado")
Sino
Escribir ("rechazado")
Fin_si
La instruccin equivale a OR ya que nos dice que puede ser en cualquiera de

los exmenes no necesariamente en los dos. En el ejemplo 1 la palabra ambos
equivala a seleccionar la instruccin AND. Si la instruccin nos dijera que
obtenga una nota en cualquiera de los exmenes pero no en ambos, nos
estara indicando una instruccin XOR que es un tipo de OR pero exclusivo. Es
decir, no puede considerarse el caso en que tenga la misma nota en los dos
exmenes, solo en uno de los dos.
Estructuras condicional.
Estructura condicional simple.
Cuando se presenta la eleccin tenemos la opcin de realizar una actividad o

no realizar ninguna.

Podemos observar: El rombo representa la condicin. Hay dos opciones que se

pueden tomar. Si la condicin da verdadera se sigue el camino del verdadero, o
sea el de la derecha, si la condicin da falsa se sigue el camino de la izquierda.
Se trata de una estructura CONDICIONAL SIMPLE porque por el camino del
verdadero hay actividades y por el camino del falso no hay actividades.
Por el camino del verdadero pueden existir varias operaciones, entradas y
salidas, inclusive ya veremos que puede haber otras estructuras condicionales.
Estructura condicional compuesta.
Cuando se presenta la eleccin tenemos la opcin de realizar una actividad u

otra. Es decir tenemos actividades por el verdadero y por el falso de la
condicin. Lo ms importante que hay que tener en cuenta que se realizan las
actividades de la rama del verdadero o las del falso, NUNCA se realizan las
actividades de las dos ramas.
En una estructura condicional compuesta tenemos entradas, salidas,

operaciones, tanto por la rama del verdadero como por la rama del falso.
Habitualmente en la vida nosotros tomamos decisiones tan simples como un si

o un no. En informtica no puede ser la excepcin as que aqu tenemos a las
Estructuras Secuenciales; esta estructura se encarga del Flujo del Programa,
veamos un ejemplo:

Jos debe de viajar a la ciudad de Huancavelica desde la ciudad de lima tiene

a las empresas de Transportes Ticllas y Expreso Molina. En E.T. Ticllas el
Costo de Pasaje es de S/. 45.00 Nuevos Soles y en Expreso Molina S/. 50.00
Nuevos Soles; Jos espera el Giro de S/. 50.00 que su mam le mando por el
Banco de Crdito para poder hacer su viaje.
Se que es un problema casi comn, pues iremos donde nuestra economa nos
permita iremos, pero veamos bien Jos viajara por una de las opciones que
tiene y como lo har Tomando una Decisin; bien Viaja por la Empresa
Ticllas o Expreso Molina, veamos esto en un cdigo de C#:
1: if (jose == ticllas)
2: {
3: System.Console.WriteLine("Viajo en Ticllas");
4: }
5: if (jose == exp_Molina)
6: {
7: System.Console.WriteLine("Viajo en Expreso Molina");
8: }
Lo que se hace es Seleccionar una de las opciones pero ahora pongamos un

concepto ms tcnico:
Una estructura selectiva se encarga de decidir bajo que condiciones se

permite, o no se permite, la ejecucin de una o varias sentencias de un
algoritmo. De ah que suele llamarse estructura de decisin o alternativa.
Si notamos en el Ejemplo anterior se podra dar que Jos viaje en los dos
servicios pero eso no debera de pasar a poco no?
Entonces como solucionar:
1: if (jose == ticllas)
2: {
3: System.Console.WriteLine("Viajo en Ticllas");
4: }
5: else
6: {
7: System.Console.WriteLine("Viajo en Expreso Molina");
8: }
Sentencia If Else(Si De lo contrario)

En este tipo de sentencia se valida la primera opcin y si no se cumple

directamente se pasa a el cdigo de contenido en else, viendo el ejemplo
entonces si no viaja en Ticllas viajar en Expreso Molina.
Bueno ahora veamos un ejercicio un poco mas real:
Desarrolle una aplicacin que imprima un mensaje si la persona es mayor de

edad. (En Per mayor de edad es a los 18 aos)
Solucin Bsica.
1: namespace Ejemplos_MVA
2: {
3: class Program
4: {
5: static void Main(string[] args)
6: {
7: int edad = 0;
8: System.Console.WriteLine("Ingrese la edad: ");
9: edad = System.Convert.ToInt32(System.Console.ReadLine());
10: if (edad >= 18)
11: {
12: System.Console.WriteLine("Es Mayor de Edad");
13: }
14: else
15: {
16: System.Console.WriteLine("No es mayor de edad");
17: }
18: }
19: }
20:
21: }
Solucin ptima.
2: {
3: class Program
4: {
6: {
7: int edad = 0;
10: if (edad >= 18)
11: {
12: System.Console.WriteLine("Es Mayor de Edad");
13: }
14: else if (edad < 0)
15: {
16: System.Console.WriteLine("No existe esa edad");
17: }
18: else
19: {
20: System.Console.WriteLine("No es mayor de edad");
21: }
22: }
23: }
24: }
Ahora veamos otro ejemplo:
Desarrolle una aplicacin que nos permita saber lo siguiente, segn la edad
que se haya ingresado:
De 0 a 5 aos > Niez

De 6 a 12 aos > Infancia
De 13 a 18 aos > Adolescencia
De 19 a 28 aos > Juventud
De 29 a 65 aos -> Adultez
De 66 a ms > Adulto Mayor
2: {
3: class Program
4: {
6: {
7: int edad = 0;
10: if (edad >= 0 && edad<=5)
11: {
12: System.Console.WriteLine("Infancia");

13: }
14: else if (edad >= 6 && edad<=12)
15: {
16: System.Console.WriteLine("Niez");
17: }
18: else if (edad >= 13 && edad <= 18)
19: {
20: System.Console.WriteLine("Adolescencia");
21: }
22: else if (edad >= 19 && edad <= 28)
23: {
24: System.Console.WriteLine("Juventud");
25: }
26: else if (edad >= 29 && edad <= 65)
27: {
28: System.Console.WriteLine("Adultez");
29: }
30: else if (edad >= 66)
31: {
32: System.Console.WriteLine("Adulto Mayor");
33: }
34: System.Console.Read();
35: }
36: }
37: }
Bien ahora hablemos de otro tipo de sentencia:
Switch Case.
La instruccin switch es una instruccin de control que controla mltiples

selecciones y enumeraciones pasando el control a una de las
instrucciones case de su cuerpo, como se muestra en el ejemplo
siguiente:
1: int caseSwitch = 1;
2: switch (caseSwitch)
3: {
4: case 1:
5: Console.WriteLine("Caso 1");
6: break;
7: case 2:
8: Console.WriteLine("Caso 2");
9: break;

10: default:
11: Console.WriteLine("Caso por Defecto");
12: break;
13: }
Ahora veamos un ejemplo de este tipo de seleccin:
Desarrolle una aplicacin que al ingresar un numero del 1 al 12, muestre

su equivalente en los meses del ao.
2: {
3: class Program
4: {
6: {
7: int mes = 0;
8: System.Console.WriteLine("Ingrese el Mes: ");
9: mes = System.Convert.ToInt32(System.Console.ReadLine());
10: switch (mes)
11: {
12: case 1:
13: System.Console.WriteLine("Enero");
14: break;
15: case 2:
16: System.Console.WriteLine("Febrero");
17: break;
18: case 3:
19: System.Console.WriteLine("Marzo");
20: break;
21: case 4:
22: System.Console.WriteLine("Abril");
23: break;
24: case 5:
25: System.Console.WriteLine("Mayo");
26: break;
27: case 6:
28: System.Console.WriteLine("Junio");
29: break;
30: case 7:
31: System.Console.WriteLine("Julio");
32: break;
33: case 8:
34: System.Console.WriteLine("Agosto");

35: break;
36: case 9:
37: System.Console.WriteLine("Septiembre");
38: break;
39: case 10:
40: System.Console.WriteLine("Octubre");
41: break;
42: case 11:
43: System.Console.WriteLine("Noviembre");
44: break;
45: case 12:
46: System.Console.WriteLine("Diciembre");
47: break;
48: default:
49: System.Console.WriteLine("No haz ingresado un
numero valido");
50: break;
51: }
52: System.Console.Read();
53: }
54: }
55: }
Como se dan cuenta en dentro de cada uno de los CASE hay una
sentencia break, esta es la encargada de indicarle al momento de la
consulta que ya no busque mas; es decir finalizar el Switch.
Por otro lado la sentencia DEFAULT es la encargada de realizar

acciones cuando el dato ingresado no corresponda a ninguna de las
opciones marcadas con el CASE.
Ms Ejemplos de if-else.
Ejemplo 1
En este ejemplo, se escribe un carcter desde el teclado y el programa
comprueba si se trata de un carcter alfabtico.
En ese caso, comprueba si es minscula o mayscula. En cada caso, se
muestra el mensaje apropiado.
// Sentencias_if_else.cs
// if-else ejemplo
using System;

class IfTest
{
static void Main()
{
Console.Write("Entre un caracter: ");
char c = (char)Console.Read();
if (Char.IsLetter(c))
{
if (Char.IsLower(c))
{
Console.WriteLine("El caracter esta en minuscula.");
}
else
{
Console.WriteLine("El caracter esta en mayuscula.");
}
}
else
{
Console.WriteLine("No es un caracter del alfabeto.");
}
}
}
Resultado.
2
Resultados del ejemplo
Entre un caracter: 2
El caracter no es alfabtico.
A continuacin se ofrece otro ejemplo:
Ejecucin N 2:
Entre un caracter: A
El caracter est en mayscula.
Ejecucin N 3:
Entre un caracter: h
El carcter esta en minscula.
Tambin es posible extender la instruccin if de modo que puedan controlarse

varias condiciones, mediante la construccin else-if siguiente:
if (Condicion_1)
{

// Sentencia_1;
}
else if (Condicion_2)
{
// Sentencia_2;
}
else if (Condicion_3)
{
// Sentencia_3;
}
else
{
// Sentencia_n;
}
Ejemplo 2.
Este ejemplo comprueba si el carcter especificado es una letra minscula,
mayscula o un nmero. En cualquier otro caso, se tratar de un carcter no
alfanumrico. El programa utiliza la anterior estructura else-if en escalera.
// Sentencias_if_else2.cs
// else-if
using System;
public class IfTest
{
static void Main()
{
Console.Write("Entre un caracter: ");
char c = (char)Console.Read();
if (Char.IsUpper(c))
{
Console.WriteLine("El caracter est en mayscula.");
}
else if (Char.IsLower(c))
{
Console.WriteLine("El caracter est en minscula.");
}
else if (Char.IsDigit(c))
{
Console.WriteLine("El caracter es un numero.");
}
else

{
Console.WriteLine("El caracter no es alfanumerico.");
}
}
}
Resultado
E
Resultados del ejemplo
Entre un caracter: E
El caracter esta en mayscula.
A continuacin se ofrecen otros ejemplos de ejecuciones:
Ejecucin N 2:
Entre un caracter: e
El caracter est en minscula.
Ejecucin N 3:
Entre un caracter: 4
El caracter es un nmero.
Ejecucin N 4:
Entre un caracter: $
El caracter no es alfanumerico.
1. Realizar un programa que lea por teclado dos nmeros, si el primero es

mayor al segundo informar su suma y diferencia, en caso contrario informar
el producto y la divisin del primero respecto al segundo.
2. Se ingresan tres notas de un alumno, si el promedio es mayor o igual a siete
mostrar un mensaje "Promocionado".
3. Se ingresa por teclado un nmero positivo de uno o dos dgitos (1..99)
mostrar un mensaje indicando si el nmero tiene uno o dos dgitos.
(Tener en cuenta que condicin debe cumplirse para tener dos dgitos, un
nmero entero)

04
IV. PROGRAMAR ESTRUCTURAS REPETITIVAS.
Definir una estructura repetitiva.

Tipos de estructuras repetitivas en visual net.
Elaborar casos prcticos utilizando estructuras repetitivas.

capacidad.
Acceso a internet.
Orden de Ejecucin:
Definir una estructura repetitiva.
Tipos de estructuras repetitivas en visual net.
Elaborar casos prcticos utilizando estructuras repetitivas.

4.1. DEFINIR UNA ESTRUCTURA REPETITIVA:
Las estructuras de bucles de Visual Basic permiten ejecutar una o ms lneas

de cdigo de forma repetitiva. Puede repetir las instrucciones de una estructura
de bucles hasta que una condicin sea True, una condicin sea False, un
nmero de veces especificado o una vez para cada objeto de una coleccin.
En el siguiente ejemplo se muestra una estructura de bucle que ejecuta un

conjunto de instrucciones hasta que una condicin se convierta en verdadera.
Ejecutar un conjunto de instrucciones hasta que una condicin se convierta en

verdadera
4.2. TIPOS DE ESTRUCTURAS REPETITIVAS EN VISUAL NET.
Bucles While
La construccin While...End While ejecuta un conjunto de instrucciones

mientras la condicin especificada en la instruccin While sea True.
Bucles Do
La construccin Do...Loop le permite probar una condicin al comienzo o al

final de una estructura de bucle. Tambin puede especificar si repite el bucle
mientras la condicin sigue siendo True o hasta que se convierta en True.
Bucles For
La construccin For...Next ejecuta el bucle un nmero fijo de veces. Utiliza una

variable de control de bucle, tambin denominada contador para realizar el
seguimiento de las repeticiones. Especifica los valores de inicio y fin de este

contador, y puede especificar opcionalmente la cantidad en la que se

incrementa de una repeticin a la siguiente.
Bucles For Each
La construccin For Each...Next ejecuta un conjunto de instrucciones una vez

para cada elemento de una coleccin. Especifica la variable de control de bucle
pero no tiene que determinar los valores de inicio y fin para ella.
4.3. ELABORAR CASOS PRCTICOS UTILIZANDO ESTRUCTURAS

REPETITIVAS.
Usando while.
Escribir un programa que solicite la carga de un valor positivo y nos muestre

desde 1 hasta el valor ingresado de uno en uno.
Ejemplo: Si ingresamos 30 se debe mostrar en pantalla los nmeros del 1 al
30.
Es de FUNDAMENTAL importancia analizar los diagramas de flujo y la

posterior codificacin en C# de los siguientes problemas, en varios problemas
se presentan otras situaciones no vistas en el ejercicio anterior.
Diagrama de flujo:
Podemos observar que se ingresa por teclado la variable n. El operador puede

cargar cualquier valor.

Si el operador carga 10 el bloque repetitivo se ejecutar 10 veces, ya que la

condicin es Mientras x<=n , es decir mientras x sea menor o igual a 10;
pues x comienza en uno y se incrementa en uno cada vez que se ejecuta el
bloque repetitivo.
A la prueba del diagrama la podemos realizar dndole valores a las variables;

por ejemplo, si ingresamos 5 el seguimiento es el siguiente:
n x
5 1 (Se imprime el contenido de x)
2 " "
3 " "
4 " "
5 " "
6 (Sale del while porque 6 no es menor o igual a 5)
Programa:
using System;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaWhile2
{
class Program
{
{
int n,x;
string linea;
Console.Write("Ingrese el valor final:");
linea=Console.ReadLine();
n=int.Parse(linea);
x=1;
while (x<=n)
{
Console.Write(x);
Console.Write(" - ");
x = x + 1;
}
Console.ReadKey();
}
}
}

Los nombres de las variables n y x pueden ser palabras o letras (como en este
caso)
La variable x recibe el nombre de CONTADOR. Un contador es un tipo especial

de variable que se incrementa o decrementa con valores constantes durante la
ejecucin del programa.
El contador x nos indica en cada momento la cantidad de valores impresos en

pantalla.
Ejemplo 1:
El usuario introduce nmeros y el ordenador cuenta cuantos son positivos.
class Program
{
{
int positivos = 0; int conta = 0; int numero;
Console.WriteLine("Introduce nmero ");
numero = Int32.Parse(Console.ReadLine());
while (numero != 999)
{
conta = conta + 1;
if (numero > 0) positivos = positivos + 1;
Console.WriteLine("Introduce nmero ");
numero = Int32.Parse(Console.ReadLine());
}
Console.WriteLine("Has introducido un total de {0}", conta);
Console.WriteLine("y son positivos {0}", positivos);
} //fin Main
}
Ejemplo 2:
Programa para poner notas: suspendido, aprobado, bien .. con la nota numrica.
class Program
{
{
double nota=0;
string c_nota = "no asignada";
bool repetir = true;
while (repetir == true)

{
try
{
Console.WriteLine("Introduce nota");
nota = Double.Parse(Console.ReadLine());
repetir = false;
}
catch (FormatException)
{
Console.Clear();
Console.WriteLine("Introducir slo valores numricos");
repetir = true;
}
}
if (nota >0 && nota<10)
{
if (nota>=5)
{
if (nota>=6)
{
if (nota >= 7)
{
if (nota >= 9) c_nota = "sobresaliente";
else c_nota = "notable";
}
else c_nota = "bien";
}
else c_nota="aprobado";
}
else c_nota ="suspendido";
}
if (c_nota != "no asignada")
{
Console.WriteLine("La nota es de {0}", c_nota);
}
else Console.WriteLine("Nota no valida");
Console.WriteLine("Final del programa");
} // fi Main
} // fin Class

Usando do while.
Ejemplo 01.
Escribir un programa que solicite la carga de un nmero entre 0 y 999, y nos

muestre un mensaje de cuntos dgitos tiene el mismo. Finalizar el programa
cuando se cargue el valor 0.
Diagrama de flujo:
No hay que confundir los rombos de las estructuras condicionales con los de
las estructuras repetitivas do while.
En este problema por lo menos se carga un valor. Si se carga un valor mayor o

igual a 100 se trata de un nmero de tres cifras, si es mayor o igual a 10 se
trata de un valor de dos dgitos, en caso contrario se trata de un valor de un
dgito. Este bloque se repite hasta que se ingresa en la variable valor el nmero
0 con lo que la condicin de la estructura do while retorna falso y sale del
bloque repetitivo finalizando el programa.
Programa:

using System;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaDoWhile1
class Program
int valor;
string linea;
do {
Console.Write("Ingrese un valor entre 0 y 999 (0 finaliza):");
linea = Console.ReadLine();
valor=int.Parse(linea);
if (valor>=100)
Console.WriteLine("Tiene 3 dgitos.");
else

if (valor>=10)
Console.WriteLine("Tiene 2 dgitos.");
else
Console.WriteLine("Tiene 1 dgito.");
} while (valor!=0);
Ejemplo 2:
Realizar un programa que pida una serie de nmeros y al finalizar que saque el
promedio de dichos nmeros (0 para finalizar)
using System;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaDoWhile
{
class Program
{
{
int suma, cant, valor, promedio;
string linea;
suma = 0;
cant = 0;
do
{
Console.Write("Ingrese un nimero (0 para finalizar):");
valor = int.Parse(linea);
if (valor != 0)
{
suma = suma + valor;
cant++;
}
} while (valor != 0);
if (cant != 0)
{
promedio = suma / cant;
Console.Write("El promedio de los valores ingresados es:");
Console.Write(promedio);
}
else
{
Console.Write("No se ingresaron valores ");
}
Console.ReadLine();
}
}
}
Al ejecutar el cdigo muestra el siguiente resultado
Ejemplo 3:
En un banco se procesan datos de las cuentas corrientes de sus clientes. De

cada cuenta corriente se conoce: nmero de cuenta y saldo actual. El ingreso
de datos debe finalizar al ingresar un valor negativo en el nmero de cuenta.

Se pide realizar un programa que lea los datos de las cuentas corrientes e
informe:
a) De cada cuenta: nmero de cuenta y estado de la cuenta segn su saldo,

sabiendo que:
Estado de la cuenta'Acreedor' si el saldo es >0.
'Deudor' si el saldo es <0.
'Nulo' si el saldo es =0.
b) La suma total de los saldos acreedores.
using System;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaDoWhile
{
class Program
{
{
int cuenta;
float saldo, suma;
string linea;
suma = 0;
do
{
Console.Write("Ingrese nmero de cuenta:");
cuenta = int.Parse(linea);
if (cuenta >= 0)
{
Console.Write("Ingrese saldo:");
saldo = float.Parse(linea);
if (saldo > 0)
{
Console.WriteLine("Saldo Acreedor.");
suma = suma + saldo;
}
else
{
if (saldo < 0)
{

Console.WriteLine("Saldo Deudor.");
}
else
{
Console.WriteLine("Saldo Nulo.");
}
}
}
} while (cuenta >= 0);
Console.Write("Total de saldos Acreedores:");
Console.Write(suma);
Console.ReadKey();
}
}
}
Al ejecutar el cdigo muestra el siguiente resultado
Usando for:
Ejemplo 1:
Realizar un programa que imprima en pantalla los nmeros del 1 al 100.
Diagrama de flujo:

Podemos observar y comparar con el problema realizado con el while. Con la

estructura while el CONTADOR x sirve para contar las vueltas. Con el for el
CONTADOR f cumple dicha funcin.
Inicialmente f vale 1 y como no es superior a 100 se ejecuta el bloque,

imprimimos el contenido de f, al finalizar el bloque repetitivo se incrementa la
variable f en 1, como 2 no es superior a 100 se repite el bloque de
instrucciones.
Cuando la variable del for llega a 101 sale de la estructura repetitiva y contina
la ejecucin del algoritmo que se indica despus del crculo.
La variable f (o como sea que se decida llamarla) debe estar definida como una
variable ms.
Programa:
using System;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaFor1
class Program
int f;
for(f=1;f<=100;f++)
Console.Write(f);
Console.Write("-");

Console.ReadKey();
Ejemplo 2:
Programa en el que el ordenador lanza 50 veces un dado y cuenta cuantas

veces sale el n 1.
int contador =0; int dado=0;
Random numero = new Random();
Console.Clear();
for (int t = 0; t<=50; t=t + 1)
dado = numero.Next(1, 7);
if (dado == 1)
contador = contador + 1;
Console.ForegroundColor = ConsoleColor.Red;
else Console.ForegroundColor = ConsoleColor.Gray;
Console.Write(" {0}", dado);

Console.WriteLine("-");
Console.WriteLine("Ha salido el nmero1 {0} veces",contador);
Ejemplo 3:
Programa que dibuja un Triangulo issceles
Console.Clear();
// dibujo de cada linea (bucle externo)
for (int fila=1; fila <= 7; fila ++)
//dibuja espacios en blanco (1er bucle interno)
for (int espacios = 7 - fila; espacios > 0; espacios--)
Console.Write(" ");// espai en blanc
// dibuja estrellas (2 bucle interno)
for (int conta = 1; conta < (2 * fila); conta++)
Console.Write("*");
Console.WriteLine(" ");
Ejemplo 4:
Programa que muestra el da que ser maana. Ex: 31/12/08 -> 01/01/09
#include <iostream>

using namespace std;
int funcion_divisor(int numero, int divisor);
void main()
int d,max,m,a,resto;
printf("Introduce el dia: ");
scanf("%d",&d);
printf("\nIntroduce el mes: ");
scanf("%d",&m);
printf("\Introduce el anyo: ");
scanf("%d",&a);
printf("\nHoy es dia %d de %d del %d",d,m,a);
if (m==4 || m==6 || m==9 || m==11) max=30;
if (m==1 || m==3 || m==5 || m==7 || m==8 || m==10 || m==12) max=31;
if (m==2)
resto = funcion_divisor(a,4);
if (resto==0) max=29;
else max=28;
d++;
if (d>max)

d=1;
m++;
if (m>12) { m=1; a++; }
printf("\n\ny maana ser %d de %d del %d",d,m,a);
printf("\n\n");
int funcion_divisor(int numero, int divisor)
int resto = numero % divisor;
return (resto);
Ejemplo 5:
Programa para calcular Potencias, Tensiones e Intensidades. P = V * I
using System;
using System.Text;
class Ejercicio_2_6
string n_resultado="";
double resultado=0;

string teclado ="null";
while (teclado != "4")
Console.WriteLine("-");
Console.WriteLine("1-Potncia 2-Tensin 3-Intensidad 4-Sortir");
teclado = Console.ReadLine();
switch (teclado)
case "1":
n_resultado = "Potencia";
resultado = fcalcul(n_resultado,"Tension","Intensitat"); break;
case "2":
n_resultado = "Tension";
resultado = fcalcul(n_resultado, "Potencia", "Intens."); break;
case "3":
n_resultado = "Intensidad";
resultado = fcalcul(n_resultado, "Potencia", "Tension"); break;
case "4":
break;
default: Console.WriteLine("Tecla equivocada") ; break;
Console.WriteLine("El resultado {0} es {1}", n_resultado, resultado);

} // fi Main
public static double fcalcul(string n_calculo, string nom1, string nom2)
Console.WriteLine("Introduce {0}",nom1);
string temp1 = Console.ReadLine();
int var1 = Int32.Parse(temp1);
Console.WriteLine("Introduce {0}", nom2);
string temp2 = Console.ReadLine();
int var2 = Int32.Parse(temp2);
if (n_calculo=="Potencia") return (var1 * var2);
else return (var1 / var2);
} //fi class Exercici6
FUNDAMENTO TERICO.
TIPOS DE ESTRUCTURAS REPETITIVAS EN VISUAL NET.
DEFINIR UNA ESTRUCTURA REPETITIVA.
Sabemos hacer que el programa tome una serie de decisiones, en funcin del
estado del programa. Y es hora de pasar al siguiente punto.
Un ordenador, como cualquier otro tipo de maquinaria, se basa en una

repeticin de instrucciones. Desde que el ordenador se enciende hasta que se
apaga, estamos constantemente repitiendo instrucciones, con la nica
excepcin de los datos que nosotros introducimos, los cuales cambian el
resultado del proceso (variables).
Que un programa repita bloques de cdigo es algo bsico en cualquier

programa. Pues no siempre vamos a hacer un programa lineal que cumpla

una rutina y salga. A veces nos interesar que, al finalizar, vuelva a comenzar.
Y eso es exctamente lo que vamos a aprender a hacer hoy.
Para empezar, con lo poco que sabemos, podemos hacer repeticiones bsicas
haciendo llamadas de funciones, dentro de funciones. Por ejemplo:
class Program
static int x = 0;
static void Programa()
x++;
Console.WriteLine("Repeticin " + x.ToString() + "\n");
Console.ReadKey();
Programa();
Programa();
En ste ejemplo, al finalizar la funcin Programa, la ltima lnea hace una

llamada a la msma funcin Programa en la que se encuentra. A sto se le
llama Recursividad, y sirve para crear bucles bsicos.
sta forma de repetir cdigo en C#, ni es la nica, ni es la ms eficiente. As

que, ademas de la recursividad, tenemos en nuestro repertorio una serie de
clausulas que nos permitirn hacer bucles y repeticiones de cdigo de forma
ms eficiente. La primera de ellas, es la clausula do.

En sta clausula, repetiremos un fragmento de cdigo, mientras se cumpla una

condicin. En el momento que no se cumpla, el bucle se rompe. Ejemplo
prctico:
int x = 0;
do
Console.WriteLine(x.ToString() + "\n");
Console.ReadKey();
x++;
} while (x < 10);
Console.ReadKey();
En ste ejemplo, el cdigo se repite siempre que se cumpla la condicin de que

X sea menor que 10. Es decir, cuenta de 0 a 9, y por ltimo finaliza. La clausula
do, viene siempre acompaada de un while al final, que indica la condicin a
cumplir.
Si en un momento dado queremos romper un bucle (lo cual se traduce, en salir

de l y volver al cdigo principal), podemos usar la palabra reservada break
para ello.
do
Console.ReadKey();
x++;

if (x == 8) { break; }
} while (x < 10);
En ste caso, el programa slo cuenta hasta 7, pues al llegar a 8 el bucle se

rompe. La forma ms eficiente sera indicar en While que slo queremos contar
hasta 8, pero es un ejemplo para ver su uso. Adiccionalmente, podemos usar la
clausula while sin el do.
while (x < 10)
x++;
Console.ReadKey();
En caso de que lo que queramos, es saltarnos una repeticin, podemos usar la

palabra continue para ello. Ejemplo:
do
x++;
if (x == 8) { continue; }
Console.ReadKey();
} while (x < 10);
En ste caso, cuenta del 1 al 9, pero se salta el 8.
Otra forma de repetir cdigo, es usando la clausula for. Generalmente usamos

la clausula for para realizar una repeticin durante un nmero determinado de
repeticiones. Ejemplo:

for (int x = 0; x < 10; x++)
Console.ReadKey();
ste ejemplo realiza la msma funcin que el caso anterior, cuenta hasta 9 y,
finalmente, el programa finaliza. Tambin podemos usar la palabra break para
finalizar el bucle en un punto dado. En ste caso, en la clausula for podemos
declarar una variable (generalmente numrica), indicarle el lmite, y la funcin
que queremos realizar con dicha variable. Por ejemplo, podemos contar hacia
adelante (x++), o hacer una cuenta regresiva (x), o por qu no, contar de 2 en
2 (x+=2), o de 3 en 3 de forma regresiva (x-=3). En otras palabras, podemos
indicarle cualquier funcin matemtica que deseemos, incluso dividirlo (x=x/2).
La cuestin es que el bucle no finalizar hasta que se cumpla la condicin (en
nuestro caso, que x sea menor que 10, x<10), o lo especifiquemos nosotros
mediante un break.
Dentro del grupo de repeticiones, an me queda una clausula, que es foreach.

Pero sta clausula est destinada a ser usada con matrces, y an no he
explicado nada sobre ello, as que lo dejar para cuando lo haga.
Ahora bien. Las repeticiones son bsicas y esenciales en cualquier programa,

pero hay que tener mucho, mucho cuidado con su uso. Como ya he explicado,
slo finalizan cuando se cumpla una condicin o se especifique con break.
Pero, Que pasara si, por accidente, nuestra condicin siempre fuese
verdadera?
while (true)
Console.WriteLine("El programa est bloqueado");

En efecto, el programa se queda en un estado vulgarmente conocido como

bloqueado, pillado, colgado, etc. En otras palabras, que no responde, pues
se ha quedado procesando una instruccin constantemente y no puede salir
del bucle.
En caso de que nuestro programa se bloquee por accidente (generalmente por

un error en el programa), siempre podemos salr de l pulsando Ctrl+C (en el
caso de la aplicacin de consola).
Si estamos depurando, podemos tambin pulsar el botn Detener depuracin

(O Maysculas + F5) en nuestro entorno de desarrollo. En ltima instancia
podemos usar el administrador de tareas (Alt+Ctrl+Supr), y cerrar el proceso
manualmente.
Hay que tener mucho cuidado con sto, sobre todo en programas muy
complejos en los que se usen muchos bucles.
Es ideal disear el programa de forma que sea lo ms simple posible, y su

ejecucin lo ms lmpia posible, y no llenarlo de bucles innecesarios, ya que
puede surgir sto, o incluso errores de desbordamiento en la pila de llamada
(stack overflow). Pero en algunas ocasiones, s nos interesa que el programa
se repita indefinidamente.
Por ejemplo, para hacer un men en un programa de consola, y que al

introducir una opcin y finalizar dicha tarea, vuelva al principio, mostrando el
men, hasta que el usuario introduzca la opcin de salir, en cuyo caso
usaremos un break para salir del bucle.

Hasta ahora hemos empleado estructuras SECUENCIALES y

CONDICIONALES. Existe otro tipo de estructuras tan importantes como las
anteriores que son las estructuras REPETITIVAS.
Una estructura repetitiva permite ejecutar una instruccin o un conjunto de

instrucciones varias veces.
Una ejecucin repetitiva de sentencias se caracteriza por:

- La o las sentencias que se repiten.
- El test o prueba de condicin antes de cada repeticin, que motivar que se

repitan o no las sentencias.
Estructura repetitiva while.
Representacin grfica de la estructura while:
No debemos confundir la representacin grfica de la estructura repetitiva while

(Mientras) con la estructura condicional if (Si)
Funcionamiento: En primer lugar se verifica la condicin, si la misma resulta

verdadera se ejecutan las operaciones que indicamos por la rama del
Verdadero.
A la rama del verdadero la graficamos en la parte inferior de la condicin. Una
lnea al final del bloque de repeticin la conecta con la parte superior de la
estructura repetitiva.
En caso que la condicin sea Falsa contina por la rama del Falso y sale de la
estructura repetitiva para continuar con la ejecucin del algoritmo.
El bloque se repite MIENTRAS la condicin sea Verdadera.

Importante: Si la condicin siempre retorna verdadero estamos en presencia

de un ciclo repetitivo infinito. Dicha situacin es un error de programacin,
nunca finalizar el programa.
Estructura repetitiva do while.
La estructura do while es otra estructura repetitiva, la cual ejecuta al menos una

vez su bloque repetitivo, a diferencia del while o del for que podan no ejecutar
el bloque.
Esta estructura repetitiva se utiliza cuando conocemos de antemano que por lo

menos una vez se ejecutar el bloque repetitivo.
La condicin de la estructura est abajo del bloque a repetir, a diferencia del

while o del for que est en la parte superior.
El bloque de operaciones se repite MIENTRAS que la condicin sea

Verdadera.
Si la condicin retorna Falso el ciclo se detiene. En C#, todos los ciclos repiten
por verdadero y cortan por falso.
Es importante analizar y ver que las operaciones se ejecutan como mnimo una
vez.
Estructura repetitiva For.
Cualquier problema que requiera una estructura repetitiva se puede resolver

empleando la estructura while. Pero hay otra estructura repetitiva cuyo planteo
es ms sencillo en ciertas situaciones.

En general, la estructura for se usa en aquellas situaciones en las cuales

CONOCEMOS la cantidad de veces que queremos que se ejecute el bloque de
instrucciones. Ejemplo: cargar 10 nmeros, ingresar 5 notas de alumnos, etc.
Conocemos de antemano la cantidad de veces que queremos que el bloque se
repita. Veremos, sin embargo, que en el lenguaje C# la estructura for puede
usarse en cualquier situacin repetitiva, porque en ltima instancia no es otra
cosa que una estructura while generalizada.
En su forma ms tpica y bsica, esta estructura requiere una variable entera

que cumple la funcin de un CONTADOR de vueltas. En la seccin indicada
como "inicializacin contador", se suele colocar el nombre de la variable que
har de contador, asignndole a dicha variable un valor inicial. En la seccin de
"condicin" se coloca la condicin que deber ser verdadera para que el ciclo
contine (en caso de un falso, el ciclo se detendr). Y finalmente, en la seccin
de "incremento contador" se coloca una instruccin que permite modificar el
valor de la variable que hace de contador (para permitir que alguna vez la
condicin sea falsa)
Cuando el ciclo comienza, antes de dar la primera vuelta, la variable del for
toma el valor indicado en la seccin de de "inicializacin contador".
Inmediatamente se verifica, en forma automtica, si la condicin es verdadera.
En caso de serlo se ejecuta el bloque de operaciones del ciclo, y al finalizar el
mismo se ejecuta la instruccin que se haya colocado en la tercer seccin.
Seguidamente, se vuelve a controlar el valor de la condicin, y as prosigue
hasta que dicha condicin entregue un falso.
Si conocemos la cantidad de veces que se repite el bloque es muy sencillo

emplear un for, por ejemplo si queremo que se repita 50 veces el bloque de
instrucciones puede hacerse as:

La variable del for puede tener cualquier nombre. En este ejemplo se la ha

definido con el nombre f.
Analicemos el ejemplo:
La variable f toma inicialmente el valor 1.

Se controla automticamente el valor de la condicin: como f vale 1 y esto es
menor que 50, la condicin da verdadero.
Como la condicin fue verdadera, se ejecutan la/s operacin/es.
Al finalizar de ejecutarlas, se retorna a la instruccin f++, por lo que la
variable f se incrementa en uno.
Se vuelve a controlar (automticamente) si f es menor o igual a 50.
Como ahora su valor es 2, se ejecuta nuevamente el bloque de instrucciones
e incrementa nuevamente la variable del for al terminar el mismo.
El proceso se repetir hasta que la variable f sea incrementada al valor 51.
En este momento la condicin ser falsa, y el ciclo se detendr.
La variable f PUEDE ser modificada dentro del bloque de operaciones del for,
aunque esto podra causar problemas de lgica si el programador es inexperto.
La variable f puede ser inicializada en cualquier valor y finalizar en cualquier
valor. Adems, no es obligatorio que la instruccin de modificacin sea un
incremento del tipo contador (f++).
Cualquier instruccin que modifique el valor de la variable es vlida. Si por

ejemplo se escribe f=f+2 en lugar de f++, el valor de f ser incrementado de a 2
en cada vuelta, y no de a 1. En este caso, esto significar que el ciclo no
efectuar las 50 vueltas sino slo 25.

Estructura repetitiva Foreach.
La estructura foreach es en realidad azcar sintctica para trabajar con

enumeraciones. Aunque no es objetivo de esta entrada hablar sobre las
enumeraciones, recordaremos que una interfaz IEnumerable (que implementa
cualquier coleccin, array, etc.) tiene un mtodo: GetEnumerator, que nos
regresa una interfaz IEnumerator.
Esta ltima interfaz tiene dos mtodos y una propiedad: Current, que
representa el objeto al que apunta el iterador, Reset, que mueve el apuntador
del iterador al inicio de la coleccin, y MoveNext, que avanza en uno el
apuntador del iterador. As, para recorrer una coleccin, podramos hacerlo con
un bucle for, como vimos en la pregunta pasada:
string[] strs = GetStringArray();

IEnumerable enumerable = strs;
IEnumerator e = enumberable.GetEnumerator();
for (e.Reset(); e.MoveNext(); )

{
string str = e.Current as string;
Console.WriteLine(str);
}
Sin embargo, esto es un poco complejo, y C# pone a nuestra disposicin los

bucles foreach. Estos bucles se convierten en bucles for como el anterior, pero
ocultan la complejidad. Por tanto, el bucle foreach slo funcionar con
colecciones que implementen IEnumerable. Bsicamente declaramos una
variable (equivalente al Current) y declaramos sobre qu coleccin se iterar.
Internamente, el bucle foreach se har cargo de llamar a Reset y MoveNext
para saber dnde acaba la coleccin.
foreach (Tipo variable in coleccin)

{
}
El ejemplo anterior podramos dejarlo como:
string[] strs = GetStringArray();
foreach (string str in strs)

{
Console.WriteLine(str);
}
Mucho ms fcil, no?

Por supuesto, el foreach se adhiere a las reglas de IEnumerator. En particular,

mientras se est iterando de esta forma, la coleccin no puede ser modificada.
Si se modifica, tendremos una bonita excepcin InvalidOperationException en
nuestras manos.
List<string> strs = GetStringList();
foreach (string str in strs)

{
strs.Remove(str); // InvalidOperationException
}
ELABORAR CASOS PRCTICOS UTILIZANDO ESTRUCTURAS

REPETITIVAS.
Estructura repetitiva while.
Ejemplo 1:
Desarrollar un programa que permita

la carga de 10 valores por teclado y
nos muestre posteriormente la suma
de los valores ingresados y su
promedio.
Diagrama de flujo:
En este problema, a semejanza de los

anteriores, llevamos un CONTADOR
llamado x que nos sirve para contar
las vueltas que debe repetir el while.
Tambin aparece el concepto de
ACUMULADOR (un acumulador es un
tipo especial de variable que se
incrementa o decrementa con valores
variables durante la ejecucin del
programa)
Hemos dado el nombre de suma a nuestro acumulador. Cada ciclo que se

repita la estructura repetitiva, la variable suma se incrementa con el contenido
ingresado en la variable valor.
La prueba del diagrama se realiza dndole valores a las variables:

valor suma x promedio

0 0
(Antes de entrar a la estructura repetitiva estos son los valores).
5 5 1
16 21 2
7 28 3
10 38 4
2 40 5
20 60 6
5 65 7
5 70 8
10 80 9
2 82 10
8 90 11
Este es un seguimiento del diagrama planteado. Los nmeros que toma la

variable valor depender de qu cifras cargue el operador durante la ejecucin
del programa.
El promedio se calcula al salir de la estructura repetitiva (es decir primero

sumamos los 10 valores ingresados y luego los dividimos por 10)
Hay que tener en cuenta que cuando en la variable valor se carga el primer
valor (en este ejemplo 5) al cargarse el segundo valor (16) el valor anterior 5 se
pierde, por ello la necesidad de ir almacenando en la variable suma los valores
ingresados.
Programa:
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int x,suma,valor,promedio;
string linea;
x=1;
suma=0;

while (x<=10)
{
Console.Write("Ingrese un valor:");
suma=suma+valor;
x=x+1;
}
promedio=suma/10;
Console.Write("La suma de los 10 valores es:");
Console.WriteLine(suma);
Console.Write("El promedio es:");
Console.ReadKey();
}
}
}
Ejemplo 2:
Una planta que fabrica perfiles de hierro posee un lote de n piezas.
Confeccionar un programa que pida ingresar por teclado la cantidad de piezas
a procesar y luego ingrese la longitud de cada perfil; sabiendo que la pieza
cuya longitud est comprendida en el rango de 1,20 y 1,30 son aptas. Imprimir
por pantalla la cantidad de piezas aptas que hay en el lote.
Diagrama de flujo:

Podemos observar que dentro de una estructura repetitiva puede haber

estructuras condicionales (inclusive puede haber otras estructuras repetitivas
que veremos ms adelante)
En este problema hay que cargar inicialmente la cantidad de piezas a ingresar (

n ), seguidamente se cargan n valores de largos de piezas.
Cada vez que ingresamos un largo de pieza (largo) verificamos si es una
medida correcta (debe estar entre 1.20 y 1.30 el largo para que sea correcta),
en caso de ser correcta la CONTAMOS (incrementamos la variable cantidad en
1)
Al contador cantidad lo inicializamos en cero porque inicialmente no se ha

cargado ningn largo de medida.
Cuando salimos de la estructura repetitiva porque se han cargado n largos de

piezas mostramos por pantalla el contador cantidad (que representa la cantidad
de piezas aptas)
En este problema tenemos dos CONTADORES:
x (Cuenta la cantidad de piezas cargadas hasta el momento)

cantidad (Cuenta los perfiles de hierro aptos)
Programa:
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int x,cantidad,n;
float largo;
string linea;
x=1;
cantidad=0;
Console.Write("Cuantas piezar procesar:");
n=int.Parse(linea);

while (x<=n)
{
Console.Write("Ingrese la medida de la pieza:");
largo=float.Parse(linea);
if (largo>=1.20 && largo<=1.30)
{
cantidad = cantidad +1;
}
x=x + 1;
}
Console.Write("La cantidad de piezas aptas son:");
Console.Write(cantidad);
Console.ReadKey();
}
}
}
Ejemplo 3:
Realizar un programa que imprima en pantalla los nmeros del 1 al 100.
Sin conocer las estructuras repetitivas podemos resolver el problema
empleando una estructura secuencial. Inicializamos una variable con el valor 1,
luego imprimimos la variable, incrementamos nuevamente la variable y as
sucesivamente.
Diagrama de flujo:

Si continuamos con el diagrama no nos alcanzaran las prximas 5 pginas

para finalizarlo. Emplear una estructura secuencial para resolver este problema
produce un diagrama de flujo y un programa en C# muy largo.
Ahora veamos la solucin empleando una estructura repetitiva while:
Es muy importante analizar este diagrama:

La primera operacin inicializa la variable x en 1, seguidamente comienza la
estructura repetitiva while y disponemos la siguiente condicin ( x <= 100), se
lee MIENTRAS la variable x sea menor o igual a 100.
Al ejecutarse la condicin retorna VERDADERO porque el contenido de x (1)

es menor o igual a 100. Al ser la condicin verdadera se ejecuta el bloque de
instrucciones que contiene la estructura while. El bloque de instrucciones
contiene una salida y una operacin.
Se imprime el contenido de x, y seguidamente se incrementa la variable x en

uno.
La operacin x=x + 1 se lee como "en la variable x se guarda el contenido de x

ms 1". Es decir, si x contiene 1 luego de ejecutarse esta operacin se
almacenar en x un 2.
Al finalizar el bloque de instrucciones que contiene la estructura repetitiva se

verifica nuevamente la condicin de la estructura repetitiva y se repite el
proceso explicado anteriormente.

Mientras la condicin retorne verdadero se ejecuta el bloque de instrucciones;

al retornar falso la verificacin de la condicin se sale de la estructura repetitiva
y continua el algoritmo, en este caso finaliza el programa.
Lo ms difcil es la definicin de la condicin de la estructura while y qu bloque

de instrucciones se van a repetir. Observar que si, por ejemplo, disponemos la
condicin x >=100 ( si x es mayor o igual a 100) no provoca ningn error
sintctico pero estamos en presencia de un error lgico porque al evaluarse por
primera vez la condicin retorna falso y no se ejecuta el bloque de
instrucciones que queramos repetir 100 veces.
No existe una RECETA para definir una condicin de una estructura repetitiva,
sino que se logra con una prctica continua solucionando problemas.
Una vez planteado el diagrama debemos verificar si el mismo es una solucin

vlida al problema (en este caso se debe imprimir los nmeros del 1 al 100 en
pantalla), para ello podemos hacer un seguimiento del flujo del diagrama y los
valores que toman las variables a lo largo de la ejecucin:
x
1
2
3
4
.
.
100
101 Cuando x vale 101 la condicin de la estructura repetitiva retorna
falso, en este caso finaliza el diagrama.
Importante: Podemos observar que el bloque repetitivo puede no ejecutarse

ninguna vez si la condicin retorna falso la primera vez.
La variable x debe estar inicializada con algn valor antes que se ejecute la
operacin x=x + 1 en caso de no estar inicializada aparece un error de
compilacin.
Programa:
using System;
using System.Linq;
using System.Text;
{
class Program
{


{
int x;
x = 1;
while (x <= 100)
{
Console.Write(x);
Console.Write(" - ");
x = x + 1;
}
Console.ReadKey();
}
}
}
Recordemos que un problema no estar 100% solucionado si no hacemos el

programa en C# que muestre los resultados buscados.
Probemos algunas modificaciones de este programa y veamos que cambios se

deberan hacer para:
1 - Imprimir los nmeros del 1 al 500.
2 - Imprimir los nmeros del 50 al 100.
3 - Imprimir los nmeros del -50 al 0.
Respuestas:
1 - Debemos cambiar la condicin del while con x<=500.
2 - Debemos inicializar x con el valor 50.
3 - Inicializar x con el valor -50 y fijar la condicin x<=0.
Estructura repetitiva do while.
Ejemplo 01:
Escribir un programa que solicite la carga de nmeros por teclado, obtener su

promedio. Finalizar la carga de valores cuando se cargue el valor 0.
Cuando la finalizacin depende de algn valor ingresado por el operador

conviene el empleo de la estructura do while, por lo menos se cargar un valor
(en el caso ms extremo se carga 0, que indica la finalizacin de la carga de
valores)

Diagrama de flujo:
Es importante analizar este diagrama de flujo.

Definimos un contador cant que cuenta la cantidad de valores ingresados por el
operador (no lo incrementa si ingresamos 0)
El valor 0 no es parte de la serie de valores que se deben sumar.
Definimos el acumulador suma que almacena todos los valores ingresados por
teclado.
La estructura repetitiva do while se repite hasta que ingresamos el valor 0. Con
dicho valor la condicin del ciclo retorna falso y contina con el flujo del
diagrama.
Disponemos por ltimo una estructura condicional para el caso que el operador
cargue nicamente un 0 y por lo tanto no podemos calcular el promedio ya que
no existe la divisin por 0.
En caso que el contador cant tenga un valor distinto a 0 el promedio se obtiene
dividiendo el acumulador suma por el contador cant que tiene la cantidad de
valores ingresados antes de introducir el 0.

Programa:
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int suma,cant,valor,promedio;
string linea;
suma=0;
cant=0;
do {
Console.Write("Ingrese un valor (0 para finalizar):");
if (valor!=0) {
suma=suma+valor;
cant++;
}
} while (valor!=0);
if (cant!=0) {
promedio=suma/cant;
Console.Write("El promedio de los valores ingresados es:");
} else {
Console.Write("No se ingresaron valores.");
}
Console.ReadLine();
}
}
}
El contador cant DEBE inicializarse antes del ciclo, lo mismo que el acumulador
suma. El promedio se calcula siempre y cuando el contador cant sea distinto a
0.
Ejemplo 2:
Realizar un programa que permita ingresar el peso (en kilogramos) de piezas.

El proceso termina cuando ingresamos el valor 0. Se debe informar:

a) Cuntas piezas tienen un peso entre 9.8 Kg. y 10.2 Kg.?, cuntas con ms
de 10.2 Kg.? y cuntas con menos de 9.8 Kg.?
b) La cantidad total de piezas procesadas.
Diagrama de flujo:
Los tres contadores cont1, cont2, y cont3 se inicializan en 0 antes de entrar a la

A la variable suma no se la inicializa en 0 porque no es un acumulador, sino

que guarda la suma del contenido de las variables cont1, cont2 y cont3.
La estructura se repite hasta que se ingresa el valor 0 en la variable peso. Este
valor no se lo considera un peso menor a 9.8 Kg., sino que indica que ha
finalizado la carga de valores por teclado.
Programa:

using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int cant1,cant2,cant3,suma;
float peso;
string linea;
cant1=0;
cant2=0;
cant3=0;
do {
Console.Write("Ingrese el peso de la pieza (0 pera finalizar):");
peso=float.Parse(linea);
if (peso>10.2)
{
cant1++;
}
else
{
if (peso>=9.8)
{
cant2++;
}
else
{
if (peso>0)
{
cant3++;
}
}
}
} while(peso!=0);
suma=cant1+cant2+cant3;
Console.Write("Piezas aptas:");
Console.WriteLine(cant2);
Console.Write("Piezas con un peso superior a 10.2:");

Console.Write("Piezas con un peso inferior a 9.8:");
Console.ReadLine();
}
}
}
Estructura repetitiva For.
Ejemplo 01:
Desarrollar un programa que permita la carga de 10 valores por teclado y nos
muestre posteriormente la suma de los valores ingresados y su promedio. Este
problema ya lo desarrollamos, lo resolveremos empleando la estructura for.
Diagrama de flujo:
En este caso, a la variable del for (f) slo se la requiere para que se repita el
bloque de instrucciones 10 veces.
Programa:
using System;

using System.Linq;
using System.Text;
{
class Program
{
{
int suma,f,valor,promedio;
string linea;
suma=0;
for(f=1;f<=10;f++)
{
Console.Write("Ingrese valor:");
linea=Console.ReadLine();
suma=suma+valor;
}
Console.Write("La suma es:");
Console.WriteLine(suma);
promedio=suma/10;
Console.Write("El promedio es:");
Console.ReadKey();
}
}
}
El problema requiere que se carguen 10 valores y se sumen los mismos.
Tener en cuenta encerrar entre llaves bloque de instrucciones a repetir dentro
del for.
El promedio se calcula fuera del for luego de haber cargado los 10 valores.
Ejemplo 2:
Escribir un programa que lea 10 notas de alumnos y nos informe cuntos
tienen notas mayores o iguales a 7 y cuntos menores.
Para resolver este problema se requieren tres contadores:
Aprobados (Cuenta la cantidad de alumnos aprobados)
Reprobados (Cuenta la cantidad de reprobados)
f (es el contador del for)
Dentro de la estructura repetitiva debemos hacer la carga de la variable nota y
verificar con una estructura condicional si el contenido de la variable nota es

mayor o igual a 7 para incrementar el contador aprobados, en caso de que la

condicin retorne falso debemos incrementar la variable reprobados.
Diagrama de flujo:
Los contadores aprobados y reprobados deben imprimirse FUERA de la

Es fundamental inicializar los contadores aprobados y reprobados en cero

antes de entrar a la estructura for.
Importante: Un error comn es inicializar los contadores dentro de la

estructura repetitiva. En caso de hacer esto los contadores se fijan en cero en
cada ciclo del for, por lo que al finalizar el for como mximo el contador puede
tener el valor 1.
Programa:
using System;
using System.Linq;
using System.Text;
{

class Program
{
{
int aprobados,reprobados,f,nota;
string linea;
aprobados=0;
reprobados=0;
for(f=1;f<=10;f++)
{
Console.Write("Ingrese la nota:");
nota=int.Parse(linea);
if (nota>=7)
{
aprobados=aprobados+1;
}
else
{
reprobados=reprobados+1;
}
}
Console.Write("Cantidad de aprobados:");
Console.WriteLine(aprobados);
Console.Write("Cantidad de reprobados:");
Console.Write(reprobados);
Console.ReadKey();
}
}
}
Ejemplo 3:
Escribir un programa que lea 10 nmeros enteros y luego muestre cuntos

valores ingresados fueron mltiplos de 3 y cuntos de 5. Debemos tener en
cuenta que hay nmeros que son mltiplos de 3 y de 5 a la vez.
Diagrama de flujo:

Tengamos en cuenta que el operador matemtico % retorna el resto de dividir

un valor por otro, en este caso: valor%3 retorna el resto de dividir el valor que
ingresamos por teclado, por tres.
Veamos: si ingresamos 6 el resto de dividirlo por 3 es 0, si ingresamos 12 el

resto de dividirlo por 3 es 0. Generalizando: cuando el resto de dividir por 3 al
valor que ingresamos por teclado es cero, se trata de un mltiplo de dicho
valor.
Ahora bien por qu no hemos dispuesto una estructura if anidada? Porque
hay valores que son mltiplos de 3 y de 5 a la vez. Por lo tanto con if anidados
no podramos analizar los dos casos.

Es importante darse cuenta cuando conviene emplear if anidados y cuando no

debe emplearse.
Programa:
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int mul3,mul5,valor,f;
string linea;
mul3=0;
mul5=0;
for(f=1;f<=10;f++)
{
Console.Write("Ingrese un valor:");
if (valor%3==0)
{
mul3=mul3+1;
}
if (valor%5==0)
{
mul5=mul5+1;
}
}
Console.Write("Cantidad de valores ingresados mltiplos de 3:");
Console.WriteLine(mul3);
Console.Write("Cantidad de valores ingresados mltiplos de 5:");
Console.Write(mul5);
Console.ReadKey();
}
}
}

Ejemplo 4:
Escribir un programa que lea n nmeros enteros y calcule la cantidad de

valores mayores o iguales a 1000.
Este tipo de problemas tambin se puede resolver empleando la estructura

repetitiva for. Lo primero que se hace es cargar una variable que indique la
cantidad de valores a ingresar. Dicha variable se carga antes de entrar a la
estructura repetitiva for.
La estructura for permite que el valor inicial o final dependa de una variable
cargada previamente por teclado.
Diagrama de flujo:
Tenemos un contador llamado cantidad y f que es el contador del for.

La variable entera n se carga previa al inicio del for, por lo que podemos fijar el
valor final del for con la variable n.
Por ejemplo si el operador carga 5 en n la estructura repetitiva for se ejecutar
5 veces.
La variable valor se ingresa dentro de la estructura repetitiva, y se verifica si el
valor de la misma es mayor o igual a 1000, en dicho caso se incrementa en uno
el contador cantidad.

Fuera de la estructura repetitiva imprimimos el contador cantidad que tiene

almacenado la cantidad de valores ingresados mayores o iguales a 1000.
Programa:
using System;
using System.Linq;
using System.Text;
{
class Program
{
{
int cantidad,n,f,valor;
string linea;
cantidad=0;
Console.Write("Cuantos valores ingresar:");
n=int.Parse(linea);
for(f=1;f<=n;f++)
{
Console.Write("Ingrese el valor:");
valor = int.Parse(linea);
if (valor>=1000)
{
cantidad=cantidad+1;
}
}
Console.Write("La cantidad de valores ingresados mayores o iguales a
1000 son:");
Console.Write(cantidad);
Console.ReadKey();
}
}
}

1. Usando while o do while realizar los siguientes programas:
a) Realizar un programa que acumule (sume) valores ingresados por teclado

hasta ingresar el 9999 (no sumar dicho valor, indica que ha finalizado la
carga). Imprimir el valor acumulado e informar si dicho valor es cero, mayor
a cero o menor a cero.
b) En un banco se procesan datos de las cuentas corrientes de sus clientes. De
cada cuenta corriente se conoce: nmero de cuenta y saldo actual. El
ingreso de datos debe finalizar al ingresar un valor negativo en el nmero de
cuenta.
Se pide confeccionar un programa que lea los datos de las cuentas
corrientes e informe:
- De cada cuenta: nmero de cuenta y estado de la cuenta segn su saldo,
sabiendo que:
Estado de la cuenta 'Acreedor' si el saldo es >0.

'Deudor' si el saldo es <0.
'Nulo' si el saldo es =0.
- La suma total de los saldos acreedores.
2. Usando for realizar los siguien programas

a) Desarrollar un programa que solicite la carga de 10 nmeros e imprima la
suma de los ltimos 5 valores ingresados.
b) Desarrollar un programa que muestre la tabla de multiplicar del 5 (del 5 al
50).
c) Confeccionar un programa que permita ingresar un valor del 1 al 10 y nos
muestre la tabla de multiplicar del mismo (los primeros 12 trminos)
Ejemplo: Si ingreso 3 deber aparecer en pantalla los valores 3, 6, 9, hasta
el 36.
d) Realizar un programa que lea los lados de n tringulos, e informar:
- De cada uno de ellos, qu tipo de tringulo es: equiltero (tres lados
iguales), issceles (dos lados iguales), o escaleno (ningn lado igual).
- Cantidad de tringulos de cada tipo.
- Tipo de tringulo que posee menor cantidad.

05
V. PROGRAMAR ESTRUCTURAS ANIDADAS SIMPLES Y
COMPLEJAS.

Definir la importancia de anidar correctamente dos o ms estructuras.
Desarrollar estructuras anidadas para la solucin de problemas.

capacidad.
Acceso a internet.
Orden de Ejecucin:
Desarrollar estructuras anidadas para la solucin de problemas.

5.1. DEFINIR LA IMPORTANCIA DE ANIDAR CORRECTAMENTE DOS O

MS ESTRUCTURAS.
Un ciclo anidado es un ciclo que contiene otro ciclo. En C tenemos 3 ciclos

diferentes el ciclo while, do_while y for, estos ciclos se pueden anidar uno en
otro ya sea el mismo ciclo o uno diferente. C permite 15 niveles de anidacin,
cuando se anida un ciclo dentro de otro siempre se terminan de realizar
primero el ciclo que esta ms anidado, por ejemplo en caso de que anidramos
dentro de un ciclo do while a un ciclo for, el ciclo for se terminara primero.
Este programa lee las temperaturas de los 365 das del ao cada hora
#include <conio.h>
#include <stdio.h>
void main(void)
{ float temp;
int dias=1, horas;
clrscr();
while(dias<=365)
for( horas=1;horas<=24;horas++)
printf(Da la temperatura del da %d en la hora %d ,dias,horas);
scanf(%f,&temp);
dias=dias+1;

En este caso se pudieran utilizar 2 ciclos for, o 2 ciclos while, o 2 do_while, o la

combinacin de cualquiera de ellos, usted elige de acuerdo a lo que necesite
que ciclos le conviene ms utilizar.
Por ejemplo, tal vez para este programa usted hubiera elegido 2 ciclos for por
ser ms prcticos al estar controlados por contador.
#include <conio.h>
#include <stdio.h>
void main(void)
{ float temp;
int dias, horas;
clrscr();
for(dias=1;dias<=365;dias++)
for( horas=1;horas<=24;horas++)
printf(Da la temperatura del da %d en la hora %d ,dias,horas);
scanf(%f,&temp);
5.2. DESARROLLAR ESTRUCTURAS ANIDADAS PARA LA SOLUCIN DE

PROBLEMAS.
Confeccionar un programa que pida por teclado tres notas de un alumno,

calcule el promedio e imprima alguno de estos mensajes:
Si el promedio es >=7 mostrar "Promocionado".
Si el promedio es >=4 y <7 mostrar "Regular".
Si el promedio es <4 mostrar "Reprobado".
Diagrama de flujo:

Analicemos el siguiente diagrama. Se ingresan tres valores por teclado que

representan las notas de un alumno, se obtiene el promedio sumando los tres
valores y dividiendo por 3 dicho resultado (Tener en cuenta que si el resultado
es un valor real solo se almacena la parte entera).
Primeramente preguntamos si el promedio es superior o igual a 7, en caso

afirmativo va por la rama del verdadero de la estructura condicional mostramos
un mensaje que indica "Promocionado" (con comillas indicamos un texto que
debe imprimirse en pantalla).
En caso que la condicin nos de falso, por la rama del falso aparece otra
estructura condicional, porque todava debemos averiguar si el promedio del
alumno es superior o igual a cuatro o inferior a cuatro.
Estamos en presencia de dos estructuras condicionales compuestas.
Programa:
import java.util.Scanner;
public class EstructuraCondicionalAnidada1 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int nota1,nota2,nota3;
System.out.print("Ingrese primer nota:");
nota1=teclado.nextInt();

System.out.print("Ingrese segunda nota:");

System.out.print("Ingrese tercer nota:");
int promedio=(nota1 + nota2 + nota3) / 3;
if (promedio>=7) {
System.out.print("Promocionado");
} else {
if (promedio>=4) {
System.out.print("Regular");
} else {
System.out.print("Reprobado");
}
}
}
}
Codifiquemos y ejecutemos este programa. Al correr el programa deber

solicitar por teclado la carga de tres notas y mostrarnos un mensaje segn el
promedio de las mismas.
Podemos definir un conjunto de variables del mismo tipo en una misma lnea:
int nota1,nota2,nota3;
Esto no es obligatorio pero a veces, por estar relacionadas, conviene.
A la codificacin del if anidado podemos observarla por el else del primer if.
Para no tener problemas (olvidarnos) con las llaves de apertura y cerrado

podemos ver la siguiente regla:
Cada vrtice representa una llave de apertura y una de cierre:

FUNDAMENTO TERICO:
El anidamiento (llamado nesting en ingls) es la prctica de incorporar

llamadas (calls) a funciones o procedimientos (unas) dentro de otras, mediante
la inclusin de diversos niveles de parntesis.
Debido a que la potencial acumulacin de stos ltimos suele hacer que la

edicin y la deteccin de errores se vuelva un proceso engorroso, los entornos
de programacin modernos -as como los programas de planilla de clculo-
resaltan en negrita el par correspondiente a la posicin que est editando el
programador o usuario en cada momento. El control (automtico) del balance o
equilibrio entre los parntesis de apertura y de cierre se suele conocer como
brace match checking en ingls.
Naturalmente, para la resolucin matemtica de estas complejas formulas

encadenadas, las expresiones deben ser evaluadas desde adentro hacia
afuera, ya que los resultados de las ms internas sirven, temporalmente, de
datos de entrada de las exteriores.
En las planillas de clculo.
En las hojas de clculo, se suelen anidar o agrupar funciones unas dentro de

otras, derivando en frmulas relativamente complejas. El programa
OpenOffice.org Calc permite, mediante su asistente de funciones (function
wizard), navegar a travs de los varios o mltiples niveles de anidamiento,
permitiendo editar (y eventualmente corregir) cada una de ellas por separado.
Tal vez de manera sorprendente, su rival Microsoft Excel no posee esa
caracterstica, eventualmente deseable cuando se trabaja en algunas grandes
planillas.
En programacin.
En los lenguajes de programacin estructurada, el anidamiento est

relacionado a la inclusin de estructuras de control dentro de otras, usualmente
indicado mediante la inclusin de distintos niveles de sangra (llamada
indentation en ingls) dentro del cdigo fuente, como se muestra en el sencillo
cdigo BASIC siguiente:
function BuscarCodigo(cod as string) as integer
dim linea, ruta as string
dim valor_a_devolver as integer

ruta="C:\Probar.csv"
if FileExists(ruta) then
open "C:\Probar.csv" for input as #1
do while not EOF(1)
line input #1, linea
if left(linea, 3)=cod then
'Realizar una accin o varias acciones
End if
loop
close #1
BuscarCodigo=valor_a_devolver
end function
En este simple ejemplo, la estructura condicional if... then... end if ("si...

entonces... fin si") est anidada dentro de otra que la contiene, el ciclo do
while... loop ("repetir... mientras", literalmente "hacer mientras... bucle").
El anidamiento
Cualquier instruccin puede ser sustituida por una estructura de control. El
siguiente ejemplo muestra el pseudocdigo del ordenamiento de burbuja, que
tiene varias estructuras anidadas. Este algoritmo ordena de menor a mayor los
elementos de una lista .
En general, las estructuras anidadas se muestran indentadas, para hacer ms

sencilla su identificacin a simple vista. En el ejemplo, adems de la
indentacin, se ha conectado con flechas los pares de delimitadores de cada
nivel de anidamiento.

DESARROLLAR ESTRUCTURAS ANIDADAS PARA LA SOLUCIN DE

PROBLEMAS.
Puede colocar instrucciones de control dentro de otras instrucciones de control,

por ejemplo un bloque If...Then...Else dentro de un bucle For...Next. Cuando
una instruccin de control se coloca dentro de otra, se dice que est anidada.
Niveles de anidamiento.
En Visual Basic, las instrucciones de control pueden anidarse en tantos niveles

como se desee. A fin de que las estructuras anidadas sean ms fciles de leer,
es prctica habitual aplicar sangra al cuerpo de cada una. El editor del entorno
de desarrollo integrado (IDE) lo hace automticamente.
En el siguiente ejemplo, el procedimiento sumRows suma los elementos

positivos de cada fila de la matriz.
Public Sub sumRows(ByVal a(,) As Double, ByRef r() As Double)

Dim i, j As Integer
For i = 0 To UBound(a, 1)
r(i) = 0
For j = 0 To UBound(a, 2)
If a(i, j) > 0 Then
r(i) = r(i) + a(i, j)
End If
Next j
Next i
End Sub
En el ejemplo anterior, la primera instruccin Next cierra el bucle For interno y

la ltima instruccin Next cierra el bucle For externo.
Del mismo modo, en las instrucciones If anidadas, las instrucciones End If se

aplican automticamente a la instruccin If anterior ms prxima. Los bucles
Do anidados funcionan de forma similar; la instruccin Loop ms interna est
emparejada con la instruccin Do ms interna.
Anidar diferentes tipos de estructuras de control.
Puede anidar un tipo de estructura de control dentro de otro tipo. El ejemplo

siguiente utiliza un bloque With dentro de un bucle For Each y bloques If
anidados dentro del bloque With.
For Each ctl As System.Windows.Forms.Control In Me.Controls

With ctl

.BackColor = System.Drawing.Color.Yellow
.ForeColor = System.Drawing.Color.Black
If .CanFocus Then
.Text = "Colors changed"
If Not .Focus() Then
' Insert code to process failed focus.
End If
End If
End With
Next ctl
Superposicin de estructuras de control.
No puede superponer estructuras de control. Esto significa que cualquier

estructura anidada debe estar completamente incluida dentro de la siguiente
estructura ms profunda. Por ejemplo, la organizacin siguiente no es vlida
porque el bucle For finaliza antes de que termine el bloque With interno.
Anidamiento no vlido de estructuras For y With

1. Crea una aplicacin que dibuje una escalera de asteriscos. Nosotros le

pasamos la altura de la escalera por teclado. Este es un ejemplo si
insertaras un 5 de altura:
2. Crea una aplicacin que dibuje una pirmide volteada de asteriscos.

Nosotros le pasamos la altura de la pirmide por teclado. Este es un
ejemplo, si introducimos 5 de altura:
3. Crea una aplicacin que dibuje una escalera de nmeros, siendo cada
linea nmeros empezando en uno y acabando en el numero de la linea.
Este es un ejemplo, si introducimos un 5 como altura:

06
VI. ELABORAR PROCEDIMIENTOS PARA RESOLVER CASOS

PRCTICOS.

Identificar la importancia de un procedimiento.
Programar procedimientos para resolver casos prcticos.
capacidad.
Acceso a internet.
Orden de Ejecucin:
Programar procedimientos para resolver casos prcticos.

6.1. IDENTIFICAR LA IMPORTANCIA DE UN PROCEDIMIENTO.
(procedure). En programacin, un tipo de subrutina.

Porcin de cdigo dentro de un programa ms grande, que realiza una tarea
especfica y es relativamente independiente del resto del cdigo. La mayora de
los lenguajes de programacin incluyen soporte para la creacin de
procedimientos (u otros tipos de subrutinas, como funciones o mdulos).
Los procedimientos suelen utilizarse para reducir la duplicacin de cdigos en

un programa, permitir reusar los cdigos, descomponer problemas complejos
en piezas simples (mejorando la mantenibilidad y facilidad de extensin del
cdigo), mejora la lectura del cdigo de un programa, oculta o regula parte de
un programa, etc.
Los procedimientos son ejecutados cuando son llamados desde otros

procedimientos, funciones o mdulos. Los procedimientos pueden recibir
parmetros, pero no necesitan devolver un valor como las funciones.
Cada lenguaje de programacin tiene su propia implementacin de

procedimientos (si es que posee procedimientos).
Ejemplo
A modo de ejemplo, si queremos mostrar el anterior, el posterior y un propio

nmero de una lista (vector), un pseudocdigo por procedimientos o funciones
(a alto nivel) sera:
funcion a_p( numero ) {

out(numero-1);
out(numero);
out(numero+1);
}
for( i = 0; i < tamao(lista); i++){

a_p( lista[i] );
}
O si queremos dividir al nmero por 2,3,4,5,6,7,8,9 y 10 en otro pseudocdigo:
funcion div(numero) {
out(numero/2);
out(numero/3);

out(numero/4);
out(numero/5);
out(numero/6);
out(numero/7);
out(numero/8);
out(numero/9);
out(numero/10);
}
for( i = 0; i < tamao(lista); i++){

div( lista[i] );
}
Utilizar este tipo de programacin puede resultar muy til a la hora de

programar grandes proyectos, ya que se crea una inmensa biblioteca de
funciones especiales para procedimientos utilizados con frecuencia dentro del
programa.
Por contrapartida, es muy difcil determinar cul es el nmero mnimo de

instrucciones consecutivas, y el mnimo nmero que esta secuencia se debe
repetir para considerar declarar un procedimiento o una funcin.
6.2. PROGRAMAR PROCEDIMIENTOS PARA RESOLVER CASOS

PRCTICOS.
Ejemplo 1:
Realizar un programa para la cracion de una agenda
Cdigo:
using System;
using System.Linq;
using System.Text;
namespace Clases
{
public class Agenda
{
float version = 1.0f; // variable privada

// no puede salir de la clase

// solo puede ser usada
// dentro de la clase
public string Nombre; // poniendo "public" delante
// de cualquier funcion
// o variable, habilitamos
// su uso al invocar la clase
private int Sexo;
public void DameTuNombre()

{
if (Version() == 1.0f)
{
Console.WriteLine("Cual es tu nombre?");
Nombre = Console.ReadLine();
}
}
// podemos sobrecargar una funcin
// en otras palabras, crear la misma
// funcin con diferentes argumentos
public void DameTuNombre(string nombre)
{
Nombre = nombre;
}
public string DameTu(string algo)
{
Console.WriteLine("Escribe tu {0,0:s}", algo);
Nombre = Console.ReadLine();
return Nombre;
}
private float Version()
{
return version;
}
// como ves, no es nada del otro mundo
// luego hay ms historias, cmo el tema
// de los punteros en C#, el "delegate"
// la herencia, y esas cosillas..ZZzzz
}
class Program
{

{
int numero = 3;
string cadena = "mi cadena";
Agenda A = new Agenda ();
A.Nombre = "Pedro";
A.DameTuNombre();
A.DameTuNombre("Pepito");
cadena=A.DameTu("el nombre de tu abuela");
Console.WriteLine("Hola {0,0:s}! ah! y t tambin Mundo...jajaj"

,cadena);
Console.ReadLine();
}
}
}
Ejemplo 2:
Mini-Calculadora en modo consola
1. using System;
2.
3. namespace Calculadora
4. {
5. class Program
6. {
7. public static void Main(string[] args)
8. {
9. float primero; // El primer nmero
10. float segundo; // El segundo nmero
11. string operacion; // La operacin a realizar
12.
13. Console.Title = "Mini-Calculadora"; // Damos
formato a la consola
14. Console.BackgroundColor =
ConsoleColor.White;
15. Console.ForegroundColor =
ConsoleColor.Blue;

16. Console.Clear();
17.
18. Console.SetCursorPosition (3,2); // Pedimos
el primer nmero
19. Console.WriteLine ("Introduzca el
primer nmero");
20. Console.SetCursorPosition (60,2);
21. primero = float.Parse(Console.ReadLine());
22.
la operacin
24. Console.WriteLine ("Introduzca la operacin
a realizar (+,-,*,/)");
26. operacion = Console.ReadLine();
27.
el segundo nmero
29. Console.WriteLine ("Introduzca el segundo
nmero");
31. segundo = float.Parse(Console.ReadLine());
32.
33.
34. Console.SetCursorPosition (57,5); //
Mostramos la solucion...
35. Console.WriteLine ("__________");
36.
38. Console.WriteLine ("El resultado es");
40.
41. Console.WriteLine
(calcular(primero,segundo,operacion));
42. Console.ReadKey ();
43.
44. }
45.
46. private static string calcular (float primero , float segundo,
string operacion)
47. {
48. float temp;
49. switch (operacion) // Estructura con switch
50. {

51. case "+":

52. temp = primero + segundo;
53. return temp.ToString ();
54. case "-":
55. temp = primero - segundo;
57. case "*":
58. temp = primero * segundo;
60. case "/":
61. temp = primero / segundo;
63. }
64. return "-1";
65. }
66. }
67. }
68.
Mini-Calculadora en modo grfico: (los nombres de los controles son faciles de

deducir viendo el code )
Cdigo
1. using System;
2. using System.Collections.Generic;
3. using System.Drawing;
4. using System.Windows.Forms;
5. using System.Text;
6.
7. namespace Calculadora
8. {
9. /// <summary>
10. /// Description of MainForm.
11. /// </summary>
12. public partial class MainForm : Form
13. {
14. int oper ; // 1 -> + | 2 -> - | 3 -> * | 4 -> /
15. float primero;
16.
17.
18. public MainForm()
19. {
20. InitializeComponent();

21. }
22.
23. void Numero7Click(object sender, EventArgs e)
24. {
25. txtnum.Text = txtnum.Text + 7;
26. }
27.
29. {
31. }
32.
34. {
36. }
37.
39. {
41. }
42.
44. {
46. }
47.
49. {
51. }
52.
54. {
56. }
57.
59. {
61. }
62.
64. {


66. }
67.
69. {
71. }
72.
73. void CClick(object sender, EventArgs e)
74. {
75. txtnum.Text = "";
76. }
77.
78. void DivClick(object sender, EventArgs e)
79. {
80. oper = 4;
81. primero = float.Parse (txtnum.Text);
83. }
84.
85. void MulClick(object sender, EventArgs e)
86. {
87. oper = 3;
90. }
91.
92. void ResClick(object sender, EventArgs e)
93. {
94. oper = 2;
97. }
98.
99. void SumClick(object sender, EventArgs e)
100. {
101. oper = 1;
104. }
105.
106. void SolClick(object sender, EventArgs e)
107. {
108. float segundo = int.Parse (txtnum.Text);

109. float resultado;

110.
111. switch (oper)
112. {
113. case 1:
114. resultado = primero + segundo;
115. txtnum.Text = resultado.ToString();
116. break;
117. case 2:
118. resultado = primero - segundo;
120. break;
121. case 3:
122. resultado = primero * segundo;
124. break;
125. case 4:
126. resultado = primero / segundo;
128. break;
129. }
130. }
131. }
132. }
Ejemplo 3:
Resolver ecuaciones de seegundo grado (aadir 3 text box y un boton)
1. using System;
3. using System.ComponentModel;
4. using System.Data;
8.
9. namespace Ecuaciones
10. {
11. public partial class Form1 : Form
12. {
13. public Form1()
14. {

16. }
17.
18. private void resolver_Click(object sender, EventArgs e)
19. {
20. ecuacion miEcuacion = new ecuacion (double.Parse(a.Text),
double.Parse(b.Text), double.Parse(c.Text));
21. }
22. }
23. }
Ejemplo 4:
Exporador de carpetas: (aadir un text box "txtRuta" dos listas "lbcar" y "lbar" y
un boton con nombre por defecto)
1. using System;
3. using System.ComponentModel;
4. using System.Data;
8. using System.IO;
9.
10. namespace ExploradorCarpetas
11. {
12. public partial class Form1 : Form
13. {
14. public Form1()
15. {
17. }
18.
19. // El form load
20. private void Form1_Load(object sender, EventArgs e)
21. {
22. // Iniciamos el txtRuta
23. txtRuta.Text=Directory.GetDirectoryRoot(Directory.GetCurrentDirectory(
));
24.
25. // Listamos las carpetas

26. carpetas(txtRuta.Text);
27.
28. // Listamos los archivos
29. archivos(txtRuta.Text);
30. }
31.
32. // El botn para explorar rutas
33. private void button1_Click(object sender, EventArgs e)
34. {
37.
40. }
41.
42. // Al hacer doble click sobre una ruta la colocamos en txtRuta
43. private void lbcar_DoubleClick(object sender, EventArgs e)
44. {
45. txtRuta.Text = lbcar.SelectedItem.ToString();
46.
49.
52. }
53.
54. // Metodo que coloca las carpetas de la ruta indicada en el list
55. // box correspondiente
56. private void carpetas(string ruta)
57. {
58. lbcar.Items.Clear();
59.
60. string[] carpeta = Directory.GetDirectories(ruta);
61.
62. foreach(string car in carpeta)
63. lbcar.Items.Add (car);
64. }
65.
66. // Metodo que coloca los archivos de la ruta indicada en el list
67. // box correspondiente
68. private void archivos(string ruta)
69. {

70. lbar.Items.Clear();
71.
72. string[] archivo = Directory.GetFiles(ruta);
73.
74. foreach (string ar in archivo)
75. lbar.Items.Add(ar);
76. }
77. }
78. }
Ejemplo 5:
Operaciones simples con matrices:
1. using System;
2.
3. namespace Matrices
4. {
5. class Program
6. {
7. public static void Main(string[] args)
8. {
9. float [,] mat1; // Las matrices
10. float [,] mat2;
11.
12. int f1, c1; // El nmero de filas y columnas de las matrices
13. int f2, c2;
14.
15. //Llamamos al menu y recojemos la opcin seleccionada
16. byte opcion;
17. do {
18. opcion = menu();
19. } while (opcion >= 5);
20.
21. switch (opcion)
22. {
23. case 1: // SUMA
24.
25. // Leemos el nmero de filas y columnas de las matrices 1 y 2
26. Console.WriteLine ("Introduzca el nmero de
filas de las matrices 1 y 2");
27. f1 = int.Parse (Console.ReadLine());


nmero de columnas de las matrices 1 y 2");
29. c1 = int.Parse
(Console.ReadLine());
30.
31. // Pedimos los datos de filas y
columnas
32. Console.WriteLine ("Introduzca los
datos de la matriz 1 enumerandolos por filas:");
33. mat1 = leer(f1,c1);
35. mat2 = leer(f1,c1);
36.
37. //Mostramos la suma de ambas
matrices
38. suma(mat1,mat2);
39. break;
40.
41. case 2: // RESTA
42.
43. // Leemos el nmero de filas y
columnas de las matrices 1 y 2
nmero de filas de las matrices 1 y 2");
nmero de columnas de las matrices 1 y 2");
47. c1 = int.Parse
48.
49.
columnas
52. mat1 = leer(f1,c1);
54. mat2 = leer(f1,c1);
55.
56. // Mostramos la resta de ambas
matrices
57. resta (mat1, mat2);

58. break;
59.
60. case 3: // PRODUCTO POR UN ESCALAR
61.
62. // Leemos el nmero de filas y
columnas de la matriz 1
nmero de filas de la matriz 1");
nmero de columnas de la matriz 1");
66. c1 = int.Parse
67.
68. float escalar;
escalar por el que quiere multiplicar la matriz");
70. escalar =
float.Parse(Console.ReadLine());
71.
columnas
74. mat1 = leer(f1,c1);
75.
76. // Mostramos la solucin
77. prodEscalar (mat1,escalar);
78.
79. break;
80. }
81. Console.ReadKey();
82. }
83.
84. // Funcin que muestra el menu de seleccin de operaciones
85. public static byte menu()
86. {
87. try {
88. byte opcion;
89. Console.SetCursorPosition(10,1);
90. Console.WriteLine("Men:");
91. Console.SetCursorPosition(0,3);
92. Console.WriteLine("Elija la operacin que
quiere hacer:");

93. Console.WriteLine("1 - Suma de matrices");

94. Console.WriteLine("2 - Resta de matrices");
95. Console.WriteLine("3 - Producto por un
escalar");
96.
97. opcion = byte.Parse (Console.ReadLine());
98.
99. if (opcion >=1 && opcion <=3) {
101. return opcion;
102. }
103. else {
105. return 5;
106. }
107. } catch { //En caso de error
109. return 5;
110. }
111. }
112.
113. // Funcin que lee los datos de las matrices
114. public static float [,] leer(int filas, int columnas)
115. {
116. float [,] ret = new float [filas, columnas];
117. for (int fila = 0; fila < filas; fila++)
118. {
119. for (int columna = 0; columna <
columnas; columna++)
120. {
121. ret[fila,columna] =
float.Parse (Console.ReadLine());
122. }
123. }
124. return ret;
125. }
126.
127. // La funcin suma
128. public static void suma (float [,] mat1, float [,] mat2)
129. {
130. Console.WriteLine ("La suma de sus dos
matrices es (enumeradas por filas)");
131. for (int fila = 0; fila <=
mat2.GetUpperBound(0); fila++)

132. {
133. for (int columna = 0; columna <=
mat2.GetUpperBound(1); columna++)
134. {
135. float suma;
136. suma = mat1[fila,columna]
+ mat2[fila,columna];
(suma.ToString());
138. }
139. Console.WriteLine("");
140. }
141. }
142.
143. // La funcin resta
144. public static void resta (float [,] mat1, float [,] mat2)
145. {
146. Console.WriteLine ("La resta de sus dos
matrices es (enumeradas por filas)");
148. {
150. {
151. float resta;
152. resta = mat1[fila,columna] -
mat2[fila,columna];
(resta.ToString());
154. }
156. }
157. }
158.
159. // Producto por un escalar
160. public static void prodEscalar (float [,] mat1, float
escalar)
161. {
162. Console.WriteLine ("La multiplicacin del
escalar por su matriz es (enumerada por filas)");
164. {


166. {
167. float esc;
168. esc = mat1[fila,columna] *
escalar;
(esc.ToString());
170. }
172. }
173. }
174. }
175. }
Ejemplo 6:
Windows-pong, con dos botones y un radio buton simulo en clasico pong, muy
cutre pero entretenido
1. using System;
5.
6. namespace MiniJuegoPelota
7. {
8. /// <summary>
9. /// Description of MainForm.
10. /// </summary>
11. public partial class MainForm : Form
12. {
13. // 1 -> Derecha -1 -> Izquierda
14. // 1 -> Abajo -1 -> Arriba
15. private int dx = -1, dy = 1;
16.
17. // Variables q contiene la ultima tecla pulsada por cierta pala
18. // para q el rebote se efectue en una o otra direcion
19. // 'u' (up) -> arriba 'd' (down) -> abajo
20. private char d1, d2;
21.
22.
23. public MainForm()
24. {
26. }
27.
28. void Timer1Tick(object sender, EventArgs e)
29. {
30. // Movemos la "pelota"
31. pelota.Left += dx;
32. pelota.Top += dy;
33.
34. // Para el movimiento de la pelota
35.
36. //dx = pelota.Location.X >= this.ClientSize.Width ? -1 :
dx;
37. //dx = pelota.Location.X == 0 ? 1 : dx;
38.
39. if (pelota.Location.X + 18 >= this.ClientSize.Width)
40. {
41. timer1.Enabled = false;
42. MessageBox.Show("Gana el jugador 1",
"Felicidades");
43. }
44. if (pelota.Location.X == 0)
45. {
46. timer1.Enabled = false;
47. MessageBox.Show("Gana el jugador 2",
"Felicidades");
48. }
49.
50. // Si choca contra la parte inferior o el men
51. dy = pelota.Location.Y + 50 >= this.ClientSize.Width
? -1 : dy;
52. dy = pelota.Location.Y == 25 ? 1 : dy;
53.
54. // Si choca contra la pala1
55. if (pelota.Left == pala1.Left + pala1.Width)
56. {
57. if (pelota.Top > pala1.Top && pelota.Top <
pala1.Top + pala1.Height)
58. {
59. dx = 1; // Hacemos que valla hacia
la derecha
60. // y en funcion de la ultima tecla
pulsada hacia arriba o abajo
61. dy = d1 == 'u' ? -1 : 1;
62. }

63. }
64.
65. // Si choca contra la pala2
66. if (pelota.Left == pala2.Left - pala2.Width)
67. {
68. if (pelota.Top > pala2.Top && pelota.Top <
pala2.Top + pala2.Height)
69. {
70. dx = -1; // Hacemos que valla hacia
la izq
71. // y en funcion de la ultima tecla
pulsada hacia arriba o abajo
72. dy = d2 == 'u' ? -1 : 1;
73. }
74. }
75.
76. }
77.
78.
79.
80. //Para mover la pala 1 A = arriba, Z = abajo
81. //Para mover la pala 2 K = arriba, M = abajo
82. void MainFormKeyPress(object sender, KeyPressEventArgs
e)
83. {
84. switch (Char.ToUpper(e.KeyChar))
85. {
86. case 'A': //La pala1
87. pala1.Top -= 10;
88. if (pala1.Top < 25) pala1.Top = 25;
89. d1 = 'u';
90. break;
91. case 'Z':
92. pala1.Top += 10;
93. if (pala1.Top + pala1.Height >=
this.ClientSize.Height) pala1.Top = this.ClientSize.Height - pala1.Height;
94. d1 = 'd';
95. break;
96.
97. case 'K': //La pala2
98. pala2.Top -= 10;
99. if (pala2.Top < 25) pala2.Top = 25;
100. d2 = 'u';
101. break;

102.
103. case 'M':
104. pala2.Top += 10;
105. if (pala2.Top + pala2.Height >=
this.ClientSize.Height) pala2.Top = this.ClientSize.Height - pala2.Height;
106. d2 = 'd';
107. break;
108. }
109. }
110.
111.
112. // Las opciones del men
113. void NuevoToolStripMenuItemClick(object sender,
EventArgs e)
114. {
115. timer1.Enabled = true;
116. pelota.Left = 154;
117. pelota.Top = 134;
118. }
119.
120. void ContrrolesToolStripMenuItemClick(object
sender, EventArgs e)
121. {
122. MessageBox.Show ("Pulsar las teclas A y K
para subir y las teclas Z y M para bajar las respectivas paletas de los
jugadores 1 y 2", "Controles");
123. }
124.
125. void SalirToolStripMenuItemClick(object sender,
EventArgs e)
126. {
127. Application.Exit();
128. }
129. }
FUNDAMENTO TERICO.
La programacin por procedimientos es un paradigma de la programacin.

Muchas veces es aplicable tanto en lenguajes de programacin de bajo nivel
como en lenguajes de alto nivel. En el caso de que esta tcnica se aplique en
lenguajes de alto nivel, recibir el nombre de Programacin funcional. Esta
tcnica consiste en basarse de un nmero muy bajo de expresiones repetidas,

englobarlas todas en un procedimiento o funcin y llamarlo cada vez que tenga

que ejecutarse.
Esta tcnica de programacin ofrece muy buena respuesta con relacin al

tamao de los programas, y en bruto casi no se nota en la velocidad de
ejecucin de los mismos (mientras que las variables, constantes o ndices de
vector estn en memoria, como suele ser normal, estos se relacionarn entre
s, sin una carga de memoria considerablemente alta para los procesadores
modernos); aunque es muy complicado conseguir una programacin por
procedimientos pura.
Programacin funcional
En ciencias de la computacin, la programacin funcional es un paradigma

de programacin declarativa basado en la utilizacin de funciones aritmticas
que no maneja datos mutables o de estado. Enfatiza la aplicacin de funciones,
en contraste con el estilo de programacin imperativa, que enfatiza los cambios
de estado. La programacin funcional tiene sus races en el clculo lambda, un
sistema formal desarrollado en los 1930s para investigar la definicin de
funcin, la aplicacin de las funciones y la recursin. Muchos lenguajes de
programacin funcionales pueden ser vistos como elaboraciones del clculo
lambda.
En la prctica, la diferencia entre una funcin matemtica y la nocin de una

"funcin" utilizada en la programacin imperativa es que las funciones
imperativas pueden tener efectos secundarios, al cambiar el valor de clculos
realizados previamente. Por esta razn carecen de transparencia referencial,
es decir, la misma expresin sintctica puede resultar en valores diferentes en
diferentes momentos dependiendo del estado del programa siendo ejecutado.
Con cdigo funcional, en contraste, el valor generado por una funcin depende
exclusivamente de los argumentos alimentados a la funcin. Al eliminar los
efectos secundarios se puede entender y predecir el comportamiento de un
programa mucho ms fcilmente, y esta es una de las principales motivaciones
para utilizar la programacin funcional.
Los lenguajes de programacin funcional, especialmente los que son

puramente funcionales, han sido enfatizados en el ambiente acadmico
principalmente y no tanto en el desarrollo de software comercial. Sin embargo,
lenguajes de programacin importantes tales como Scheme, Erlang, Rust,
Objective Caml y Haskell, han sido utilizados en aplicaciones comerciales e
industriales por muchas organizaciones. La programacin funcional tambin es
utilizada en la industria a travs de lenguajes de dominio especfico como R
(estadstica), Mathematica (matemticas simblicas), J y K (anlisis financiero),
F# en Microsoft.NET y XSLT (XML). Lenguajes de uso especfico usados

comnmente como SQL y Lex/Yacc, utilizan algunos elementos de

programacin funcional, especialmente al procesar valores mutables. Las hojas
de clculo tambin pueden ser consideradas lenguajes de programacin
funcional.
La programacin funcional tambin puede ser desarrollada en lenguajes que no

estn diseados especficamente para la programacin funcional. En el caso
de Perl, por ejemplo, que es un lenguaje de programacin imperativo, existe un
libro que describe como aplicar conceptos de programacin funcional.
JavaScript, uno de los lenguajes ms ampliamente utilizados en la actualidad,
tambin incorpora capacidades de programacin funcional. Python tambin
incorpora particularidades de los lenguajes funcionales como listas de
comprensin y funciones de tratamiento de listas como matemtica de
conjuntos.
Utilidad.
El objetivo es conseguir lenguajes expresivos y matemticamente elegantes,

en los que no sea necesario bajar al nivel de la mquina para describir el
proceso llevado a cabo por el programa, y evitar el concepto de estado del
cmputo. La secuencia de computaciones llevadas a cabo por el programa se
rige nica y exclusivamente por la reescritura de definiciones ms amplias a
otras cada vez ms concretas y definidas, usando lo que se denominan
"definiciones dirigidas".
Caractersticas.
Los programas escritos en un lenguaje funcional estn constituidos

nicamentepor definiciones de funciones, entendiendo stas no como
subprogramas clsicos de un lenguaje imperativo, sino como funciones
puramente matemticas, en las que se verifican ciertas propiedades como la
transparencia referencial (el significado de una expresin depende nicamente
del significado de sus subexpresiones), y por tanto, la carencia total de efectos
colaterales.
Otras caractersticas propias de estos lenguajes son la no existencia de

asignaciones de variables y la falta de construcciones estructuradas como la
secuencia o la iteracin (lo que obliga en la prctica a que todas las
repeticiones de instrucciones se lleven a cabo por medio de funciones
recursivas).
Existen dos grandes categoras de lenguajes funcionales: los funcionales puros

y los hbridos. La diferencia entre ambos estriba en que los lenguajes
funcionales hbridos son menos dogmticos que los puros, al admitir conceptos

tomados de los lenguajes imperativos, como las secuencias de instrucciones o

la asignacin de variables. En contraste, los lenguajes funcionales puros tienen
una mayor potencia expresiva, conservando a la vez su transparencia
referencial, algo que no se cumple siempre con un lenguaje funcional hbrido.
Ventajas de usar un paradigma funcional.
Entre las ventajas que suelen citarse de usar un paradigma funcional en la

programacin de computadoras, estn las siguientes:
- Ausencia de efectos colaterales.

- Proceso de depuracin menos problemtico.
- Pruebas de unidades ms confiables.
- Mayor facilidad para la ejecucin concurrente.
PROGRAMAR PROCEDIMIENTOS PARA RESOLVER CASOS PRCTICOS.
Un programa o aplicacin C# se compone de un conjunto de clases que

contienen variables de diversos tipos utilizadas para almacenar datos, y
mtodos que implementan cdigo capaz de manipular dichas variables y crear
objetos o instancias de clase, que permitan la interaccin con otros mtodos y
variables de esas clases.
El punto de inicio de todo programa C# es el cdigo asociado al mtodo Main

(principal en ingls), es como la puerta de entrada del programa, lo primero que
se ejecuta.
A la clase que contiene al mtodo Main se la llama clase principal.
Las clases y mtodos van entre llaves {} y al final de una instruccin o

declaracin de variable debe escribirse un punto y coma (;). Se utilizan
tabuladores para sangrar las lneas de cdigo con el fin de facilitar su
legibilidad, aunque si se omiten no pasa nada.
El mtodo Main ()
Cada aplicacin de C# debe contener un mtodo Main nico, que especifique

dnde debe comenzar la ejecucin del programa. En C#, Main se pone en
maysculas, mientras que Java utiliza main en minscula.
Main puede devolver slo int o void y tiene un argumento de matriz de cadena
opcional para representar parmetros de lnea de comandos:

C#
static int Main(string[] args)
//...
return 0;
El parmetro de matriz de cadena, que contiene todos los argumentos de la

lnea de comandos pasados, funciona igual que en Java. As, args[0] especifica
el primer parmetro de lnea de comandos, args[1] denota el segundo
parmetro, etc. A diferencia de C++, la matriz args no contiene el nombre del
archivo EXE.
Otros mtodos.
Cuando se pasan parmetros a un mtodo, se pueden pasar por valor o por

referencia. Los parmetros de valor simplemente toman el valor de cualquier
variable para utilizarlo en el mtodo. Por lo tanto, el valor de variable en el
cdigo de llamada no se ve afectado por las acciones realizadas en los
parmetros de un mtodo.
Sin embargo, los parmetros de referencia apuntan a una variable declarada

en el cdigo de llamada; por lo tanto, los mtodos modificarn el contenido de
esa variable cuando se pase por referencia.
Envo de parmetros a los mtodos.
Un mtodo (procedimiento o funcin) puede recibir datos para realizar algunas

acciones, los cuales se denominan parmetros o argumentos.
Existen dos formas de enviar datos a un mtodo: por valor y por referencia.

Cuando se invoca un mtodo al que se le enva un parmetro por valor, se le

manda una copia del valor de una variable o expresin, el cual es recibido por
un parmetro declarado del mismo tipo de dato que el valor enviado. En
cambio, si se le enva un parmetro por referencia, se le manda la referencia
(direccin de memoria) de una variable.
Se pueden enviar varios datos a un mtodo, sin embargo es necesario precisar

que las variables receptoras deben estar declaradas en el orden indicado por el
envo, tambin considerando la correspondencia con el tipo de dato.
Cuando se invoca un mtodo se colocan entre parntesis los parmetros

enviados.
Es importante mencionar que los parmetros que reciben los datos enviados al
mtodo se consideran variables locales (independientemente si se hace por
valor o por referencia) e incluso pueden tener el mismo nombre que la variable
origen, sin embargo se trata de copias de los valores originales, por lo tanto,
son variables diferentes.
Envo de parmetros por valor
Cuando se enva un parmetro por valor, se hace una copia del valor de la
variable enviada en el parmetro recibido, el cual acta como una variable
local, que lo recibe, lo manipula dentro del mtodo y que desaparece y pierde
su valor al terminar la ejecucin de ese segmento de cdigo.
Por ejemplo, al invocar (llamar) el mtodo identificado con el nombre Procesar,

se colocan entre parntesis los parmetros Nombre, Edad y Sueldo separados
por comas:
Procesar(Nombre, Edad, Sueldo);
La declaracin del mtodo se muestra enseguida:
void Procesar(string N, int E, double S)

En este caso, el parmetro N recibe una copia del valor de la variable Nombre,
E recibe copia del valor de Edad y S recibe copia del valor de Sueldo
Obsrvese que durante la llamada del mtodo, se envan una cadena, un
entero y un nmero real respectivamente, los cuales son recibidos en ese
orden por los correspondientes parmetros; esto es, debe respetarse el orden
de los tipos de datos enviados en la declaracin de los parmetros.
Fig. .- Almacenamiento en memoria de los parmetros enviados por

valor.
Ahora se considera el siguiente ejemplo: Declarar una variable global

denominada x y se inicializa con el valor 5 (x=5). Dentro del programa
principal se declara y se inicializa una variable local llamada y con el valor 13
(y=13). Cuando se hace la llamada a un Metodo(y) y se enva la variable y, se
hace por valor, es decir, se enva una copia del valor de la variable (13) que lo
recibe otra variable local a. En ese momento, se transfiere el control de la
ejecucin del programa hacia el mtodo, activando su variable local a y
desactivando momentneamente la variable local del programa principal y (la
variable x permanece activa ya que se trata de una variable global). Dentro
del mtodo, se modifica el valor de su variable local a, se imprime (16) y se
duplica el valor de la variable global x y se imprime (10). Cuando el mtodo
termina, el sistema desactiva su variable local a, regresa el control de la
ejecucin del programa al lugar donde se hizo la llamada, activa y recupera el
valor de su propia variable local (y=13) y contina con su operacin. Al imprimir

los valores, nos percatamos que la variable x modific su valor por tratarse de
una variable global que puede ser accedida en cualquier parte del programa,
sin embargo, la variable y mantiene su valor original (no fu alterado), ya que
por tratarse de una variable local, fue desactivada al llamar al Metodo() y
reactivada con su valor original al retornar.
Enseguida se muestra el cdigo en C# de este ejemplo
class Program
{
static int x = 5; // Variable global
{
int y = 13; // Variable local
Console.WriteLine("\nx=" + x);
// Llamada al mtodo y envo por valor
Metodo(y);
Console.WriteLine("\ny=" + y);
Console.ReadKey();
}
// El parmetro "a" recibe el valor de "y"
static void Metodo(int a)
{
a = a + 3;
Console.WriteLine("\na=" + a);
x = x * 2;
}
}
Salida del programa de envo de parmetros por valor:

x=5
a=16
x=10
y=13
Pasar por referencia.
En Java y C#, los parmetros de mtodo que hacen referencia a un objeto

siempre se pasan por referencia, mientras que los parmetros de tipo de datos
primitivo (tipos de valor en C#) se pasan por valor.
En C#, para pasar un tipo de valor por referencia, debe especificar una de las
palabras clave ref o out. La diferencia entre estas dos palabras clave radica en
la inicializacin de los parmetros. Un parmetro ref se debe inicializar antes de
su utilizacin, mientras que un parmetro out no debe inicializarse

explcitamente sin que antes se haya pasado por referencia y se haya omitido
cualquier valor anterior.
Todas las variables se almacenan en celdas de la memoria RAM (Random

Access Memory por sus siglas en ingls), las cuales estn identificadas por una
direccin expresada en nmeros hexadecimales (p. ejem FA4D:32CE).
Cuando se enva un parmetro por referencia, no se hace una copia de su

valor y quien lo recibe, no contiene directamente el dato, sino una referencia
(direccin de memoria) a l.
El envo de parmetros por referencia permite a un mtodo cambiar el valor del

parmetro y mantener vigente dicho cambio. Cuando una variable es enviada
por referencia, el mtodo recibe la referencia de la variable original y esto
implica que los cambios realizados a esa variable dentro del mtodo, afectan la
variable original.
Para ilustrarlo mejor, consideremos el ejemplo de la seccin anterior, pero

ahora enviando la variable y por referencia: Se declara una variable global
denominada x y se inicializa con el valor 5 (x=5).
Dentro del programa principal se declara y se inicializa la variable y con el

alor 13 (y=13), la cual se considera variable local al ser declarada dentro de un
mtodo. Cuando se hace la llamada del Mtodo (ref y) y se enva la variable
y, se hace por referencia, es decir, se enva la direccin de memoria (no el
valor) de la variable y, que lo recibe 5 la variable local a. Dentro del mtodo,
se modifica el valor de la variable a, se imprime (16) y se duplica el valor de la
variable global x (10) y se imprime. Cuando el mtodo termina, el sistema
desactiva su variable local a, regresa el control de la ejecucin del programa
al lugar donde se hizo la llamada, activa y recupera los valores de su propia
variable local (y=13) y contina con su operacin. Al imprimir los valores, nos
percatamos que la variable x modific su valor por tratarse de una variable
global que puede ser accedida en cualquier parte del programa y la variable y,
aunque se trata de una variable local, tambin modific su valor, ya que siendo
la variable a una referencia de la variable y, entonces al modificar a
tambin se modifica y. Esto se debe a que la variable a no recibe una copia
del valor de la variable y sino la direccin de memoria donde est almacenado
dicho valor (FA31:C45C). A este concepto se le conoca con el nombre de
apuntador en lenguajes como Pascal, C y C++, ya que la variable a apunta al
valor almacenado en la variable y.

El siguiente cdigo en C# ilustra este ejemplo (Prog.2):
class Program
{
{
// Llamada al mtodo y envo por referencia
Metodo(ref y);
Console.ReadKey();
}
// El parmetro "a" recibe la ref. de "y"
static void Metodo(ref int a)
{
a = a + 3;
x = x * 2;
}
}
Al ejecutar el programa anterior se produce la salida mostrada
x=5
a=16
x=10
y=16
Para monitorear los valores de las variables e identificar su mbito, se
recomienda ejecutar paso a paso por instrucciones este programa en Microsoft
Visual C# 2010 2012 oprimiendo repetidamente la tecla F11.

Parmetros de salida out en C# .NET.

Un parmetro de salida en C# (out) es muy similar a un parmetro por
referencia (ref), excepto que los parmetros por referencia deben ser
inicializados antes de enviarse; sin embargo, el mtodo debe asignarle un valor
antes de devolverlo. Para utilizar un parmetro de salida, basta con anteponer
la palabra out tanto en el parmetro enviado como en su declaracin en el
mtodo.
Este tipo de parmetros son tiles cuando se requiere que una funcin
devuelva ms de un dato,
ya que por definicin, existe una restriccin de que una funcin solamente
devuelve un valor.
Para ilustrar mejor el uso de un parmetro de salida, tomaremos como ejemplo
el programa anterior
(Prog. 2) al que se le agrega una variable booleana como parmetro de salida
para determinar si el
parmetro enviado por referencia es par impar. Este cdigo en C# muestra
este ejemplo (Prog. 3):
class Program
{
{
bool esImpar;
// Llamada al mtodo y envo por referencia Metodo(ref y, out esImpar);
if (esImpar)
Console.WriteLine("\ny es un nmero impar");
else
Console.WriteLine("\ny es un nmero par");
Console.ReadKey();
}
// El parmetro "a" recibe la referencia de "y" y el parmetro de salida sirve para
determinar si el parmetro enviado es Impar static void Metodo (ref int a, out
bool Impar)
{
a = a + 3;
x = x * 2;
if (a % 2 != 0)
Impar = true;

else
Impar = false;
}
}
Prog.3.- Parmetro de salida en C#. Al ejecutar el programa anterior se
produce la salida mostrada
x=5
a=16
x=10
y=16
y es un nmero par
La palabra clave ref.

Especifique esta palabra clave en un parmetro de tipo de valor cuando desee
que el mtodo llamado cambie permanentemente el valor de las variables
utilizadas como parmetros. De esta manera, en lugar de pasar el valor de una
variable utilizada en la llamada, se pasa una referencia a la propia variable.
Entonces el mtodo funciona en la referencia, de modo que los cambios
realizados al parmetro durante la ejecucin del mtodo se conservan en la
variable original utilizada como parmetro para el mtodo.
El cdigo siguiente muestra un ejemplo de esto en el mtodo Add, donde el

segundo parmetro int se pasa por referencia con la palabra clave ref:
C#
class TestRef
{
private static void Add(int i, ref int result)
{
result += i;
return;
}
static void Main()

{
int total = 20;
System.Console.WriteLine("Original value of 'total': {0}", total);
Add(10, ref total);

System.Console.WriteLine("Value after calling Add(): {0}", total);
}
}

El resultado de este sencillo ejemplo demuestra que los cambios realizados al

parmetro resultante se reflejan en la variable total, utilizada en la llamada al
mtodo Add :
Original value of 'total': 20
Value after calling Add(): 30
Esto se debe a que el parmetro resultante hace referencia a la ubicacin de

memoria real que ocupa la variable total en el cdigo de llamada. Una
propiedad de una clase no es una variable; por lo tanto, no se puede utilizar
directamente como parmetro ref.
La palabra clave ref debe preceder al parmetro cuando se llama al mtodo, al

igual que en la declaracin de mtodo.
La palabra clave out.
La palabra clave out tiene un efecto muy similar a la palabra clave ref. Las
modificaciones realizadas a un parmetro declarado que utiliza out sern
visibles fuera del mtodo. Las dos diferencias con respecto a ref son que todo
valor inicial de un parmetro out se omite dentro del mtodo y que un
parmetro out se debe asignar durante la ejecucin del mtodo:
C#
class TestOut
{
private static void Add(int i, int j, out int result)
{
// The following line would cause a compile error:
// System.Console.WriteLine("Initial value inside method: {0}", result);
result = i + j;
return;
}
static void Main()

{
int total = 20;
System.Console.WriteLine("Original value of 'total': {0}", total);
Add(33, 77, out total);

System.Console.WriteLine("Value after calling Add(): {0}", total);
}

En este caso, el tercer parmetro para el mtodo Add se declara con la palabra
clave out y las llamadas al mtodo tambin necesitan la palabra clave out para
ese parmetro. El resultado ser:
Original value of 'total': 20
Value after calling Add(): 110
Por lo tanto, en resumen, utilice la palabra clave ref cuando desee que un
mtodo modifique una variable existente y utilice la palabra clave out, para
devolver un valor generado dentro del mtodo. Generalmente, esto se utiliza
junto con el valor que el mtodo devuelve cuando ste genera ms de un valor
resultante para el cdigo de llamada.
Ejemplo:
Este programa consta de una clase de nombre PrimerSaludo, no declara

ninguna variable y cuenta con dos mtodos de nombres Main y
MostrarMensaje. En programas ms complejos, se tendrn varias clases, en
cada clase habr muchos mtodos y declaraciones de variables, dentro de los
mtodos se declararn tambin variables, etc. Por el momento, con esta
sencilla clase nos conformaremos. Se va a explicar ahora cada una de sus
lneas.
La primera lnea es la definicin de una clase, la segunda es el mtodo Main o

punto de entrada del programa (adems de esta forma, se puede definir de
otras tres), la tercera es una instruccin o sentencia que muestra por la consola
del DOS el mensaje entrecomillado, la cuarta sirve para crear un objeto de la
clase llamado ps mediante el que se llama o invoca a otros mtodos de la
clase, la quinta es la llamada mediante el objeto ps al mtodo

mostrarMensaje(), la sexta muestra por consola el mensaje entrecomillado.

Luego aparece la definicin del mtodo MostrarMensaje() cuyo cdigo hace
que se muestre por consola el mensaje entrecomillado. Despus de compilar y
ejecutar este programa va a mostrarse por consola lo siguiente:
Por consola:
Hola Jesus
Primera clase del curso de C#
FIN DEL PROGRAMA
Recibiendo un valor de una funcin.
Una vez que se invoca una funcin es necesario utilizar la variable capaz de
recibir el valor devuelto por sta, la cual debe ser del mismo tipo de la funcin.
Por ejemplo, si se invoca el siguiente mtodo x = Procesar(a, b); 7 la variable
x recibe el valor calculado por la funcin Procesar(), que acepta los
parmetros a y b respectivamente.
Para ilustrarlo mejor, se considera el siguiente ejemplo: Se desea implementar

una funcin que calcule el rea de una circunferencia; para ello, la funcin
recibe como parmetro el valor del radio,
aplica la frmula correspondiente y devuelve el resultado calculado. El

programa principal solicita al usuario capturar el valor del radio de una
circunferencia y almacenarlo en la variable local llamada Radio, la cual es
enviada como parmetro por valor a la funcin CalcularArea(), que recibe el
parmetro en la variable local llamada r aplica la frmula ___ = _ y devuelve
el resultado calculado al programa principal quien lo recibe en la variable
Area. El siguiente cdigo en C# ilustra este ejemplo (Prog. 4):
class Program
{
{
double Radio, Area;
Console.Write("Teclee el valor del radio:");
Radio = double.Parse(Console.ReadLine());
// La variable Area recibe el valor devuelto por la funcin
Area = CalcularArea(Radio);
Console.Write("rea = " + Area);
Console.ReadKey();
}
static double CalcularArea(double r)

{
return (Math.PI * Math.Pow(r, 2));
}
}
Prog. 4.- Funcin para calcular el rea de una circunferencia

Al ejecutar el programa anterior se produce la salida mostrada:
Teclee el valor del radio: 2.3
rea = 16.61902513749
Aplicaciones prcticas del uso de mtodos.

Existen numerosas aplicaciones prcticas del uso de mtodos para el
desarrollo de sistemas computacionales. La implementacin de mtodos ayuda
a organizar mejor el diseo de programas y facilitan su mantenimiento.
El Prog. 5 muestra una aplicacin tpica de un mtodo al que se le envan

parmetros: el ordenamiento de los datos de un arreglo. El programa principal
solicita al usuario que capture la cantidad de celdas de un arreglo
unidimensional y lo almacena en la variable local llamada Tamao, crea el
arreglo local y lo llena con nmeros enteros generados de manera aleatoria.
Despus invoca al procedimiento llamado Ordenar() y le enva como
parmetros el Arreglo completo y su Tamao (los cuales son recibidos por el
arreglo A y la variable T respectivamente) para implementar un algoritmo
que ordena de manera ascendente (de menor a mayor) los datos almacenados
en el arreglo (en este momento no es importante explicar el mtodo de
ordenamiento). Obsrvese que se trata de un procedimiento, puesto que no
devuelve valor; sin embargo, no es necesario devolver valor alguno, ya que
cuando se enva un arreglo como parmetro a un mtodo, automticamente se
hace por referencia; es decir, no se requiere implementar una funcin que
devuelva el arreglo con los datos ordenados; sino que al hacer los cambios en
el arreglo recibido dentro del mtodo (arreglo A), stos se reflejan de manera
inmediata en el arreglo original (Arreglo) que fue generado en el programa
principal. El siguiente cdigo en C# muestra este ejemplo:
class Program
{
{
// Declaracin del tamao del arreglo
int Tamao;
// Declaracin del arreglo

int [] Arreglo;
// Generar un nmero aleatorio
Random NumeroAleatorio = new
Random(int.MaxValue);
Console.Write("Teclee el tamao del arreglo:");
Tamao = int.Parse(Console.ReadLine());
// Creacin del arreglo
Arreglo = new int[Tamao];
// Llena el Arreglo con nmeros generadosaleatoriamente
Console.WriteLine("\nARREGLO DESORDENADO\n");
for (int i = 0; i < Tamao; i++)
{
// Genera nm. aleatorio y lo almacena en la celda "i" del Arreglo
Arreglo[i] = NumeroAleatorio.Next();
// Imprime el nm. generado
Console.WriteLine("{0:N0} ",Arreglo[i]);
}
Console.Write("\nOprima cualquier tecla para ordenar el arreglo ...");
Console.ReadKey();
// Invoca el procedimiento "Ordenar" y le enva el "Arreglo" y su
"Tamao"
Ordenar(Arreglo, Tamao);
// Limpia la pantalla
Console.Clear();
// Imprime el arreglo
Console.WriteLine("ARREGLO ORDENADO\n");
for(int i=0; i<Tamao; i++)
Console.WriteLine("{0:N0} ", Arreglo[i]);
Console.Write("\nOprima cualquier tecla para salir ...");
Console.ReadKey();
}
// Procedimiento para ordenar un arreglo recibido como parmetro
static void Ordenar(int[] A, int T)
{
for(int p=0; p<T-1; p++)
for(int e=p+1; e<T; e++)
if (A[e] < A[p])
{
int temp=A[p];
A[p] = A[e];
A[e] = temp;
}
}
}

Al ejecutar el programa anterior se produce la salida mostrada:
Teclee el tamao del arreglo: 6

ARREGLO DESORDENADO
1,559,595,546
1,755,192,844
1,649,316,172
1,198,642,031
442,452,829
1,200,195,955
Oprima cualquier tecla para ordenar el arreglo
ARREGLO ORDENADO
442,452,829
1,198,642,031
1,200,195,955
1,559,595,546
1,649,316,172
1,755,192,844
Oprima cualquier tecla para salir

1. Crear una funcin que tenga como entrada dos valores enteros, m y n, y
determine si m es mltiplo de n. La funcin devolver un valor lgico. En
el programa principal reportar el resultado de dicha funcin.
2. Crear una funcin que tenga como entradas 3 nmeros y devuelva el
mayor de ellos. En el programa principal reportar el resultado.
3. Crear un subprograma que reciba como entrada un valor entero e
indique si se trata de un nmero par o impar. Qu tipo de subprograma
cree que es el ms apropiado, procedimiento o funcin? En el programa
principal reportar el resultado.
4. Crear un procedimiento que reciba tres valores reales como entrada y
los ordene de mayor a menor. En el programa principal reportar el
resultado.
5. Crear un subprograma apropiado que lea por teclado una secuencia de
nmeros enteros positivos entre 0 y 100, ambos inclusive. La secuencia
de nmeros introducidos terminar cuando se introduzca un nmero
que no cumpla la condicin (que no est entre 0 y 100). En el programa
principal reportar los valores ledos y el nmero de valores que hay
dentro del arreglo.

Lenguaje de Programación

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lenguaje de Programación

Uploaded by

Copyright:

Available Formats

SERVICIO NACIONAL DE ADIESTRAMIENTO EN TRABAJO INDUSTRIAL

ESCUELA DE TECNOLOGAS DE LA INFORMACIN 5

ESCUELA DE TECNOLOGAS DE LA INFORMACIN 6

I. ANALIZAR EL ENTORNO DE TRABAJO CON MICROSOFT

En esta tarea trataremos las siguientes operaciones:

ESCUELA DE TECNOLOGAS DE LA INFORMACIN 7

1.1. DEFINIR EL CONCEPTO DE VISUAL NET.

Visual Basic es hoy el lenguaje de programacin ms popular del mundo.

.Net conduce a la tercera generacin de Internet. La primera generacin

Precisamente, el principio de .Net es que los sitios Web aislados y los

1.2. ANALIZAR LA ESTRUCTURA DEL FRAMEWORK.

.NET Framework es una plataforma de desarrollo para compilar aplicaciones

Se requiere una estructura, no solo para facilitar el desarrollo de aplicaciones,

integrarlo en una aplicacin resulte transparente para usuarios y

Segn se puede ver en la figura siguiente, .NET Framework es un componente

1.3. INSTALAR Y TRABAJAR CON EL ENTORNO DE DESARROLLO DE

La instalacin de esta versin es un proceso realmente sencillo. Lejos queda la

Todo lo referente a las versiones Express de Microsoft se encuentran en la

ESCUELA DE TECNOLOGAS DE LA INFORMACIN 9

Este es el centro de todo el mundo "Express" de Microsoft, vamos a hacer clic

Tenemos dos formas de instalar el programa: conectado a Internet con

ESCUELA DE TECNOLOGAS DE LA INFORMACIN 10

Por experiencia he visto que la instalacin Web no os ha funcionado en todos

Se abrir la habitual ventana de descarga de ficheros:

As que lo descargaremos completo, ya vez que tiene 1,71 GB as que un poco

ESCUELA DE TECNOLOGAS DE LA INFORMACIN 11

Ya lo tenemos descomprimido as que nos vamos a la carpeta y hacemos

ESCUELA DE TECNOLOGAS DE LA INFORMACIN 12

As que finalmente pulsaremos en "Visual Basic 2010 Express".

Al cabo de unos momentos tendremos el asistente de instalacin en pantalla:

Pulsamos en "Siguiente" para comenzar la instalacin...

ESCUELA DE TECNOLOGAS DE LA INFORMACIN 13

Y al cabo de unos minutos nos mostrar que el proceso ha finalizado...

DEFINIR EL CONCEPTO DE VISUAL NET.

Visual Basic 2010 ofrece soporte para entorno de ejecucin dinmico..

VB 2010 forma parte de Microsoft Silverlight. visual basic es un lenguaje de

ESCUELA DE TECNOLOGAS DE LA INFORMACIN 14

ANALIZAR LA ESTRUCTURA DEL FRAMEWORK.

La palabra inglesa "framework" (marco de trabajo) define, en trminos

En el desarrollo de software, un framework o infraestructura digital, es una

Representa una arquitectura de software que modela las relaciones generales

Son diseados con la intencin de facilitar el desarrollo de software,

Fuera de las aplicaciones en la informtica, puede ser considerado como el

.NET Framework es un entorno de ejecucin administrado que proporciona

ESCUELA DE TECNOLOGAS DE LA INFORMACIN 15

Administracin de la memoria. En muchos lenguajes de programacin, los

Sistema de tipos comunes. En los lenguajes de programacin tradicionales,

Biblioteca de clases extensa. En lugar de tener que escribir cantidades

Frameworks y tecnologas de desarrollo. .NET Framework incluye bibliotecas

Interoperabilidad de lenguajes. Los compiladores de lenguajes destinados a

Compatibilidad de versiones. Con raras excepciones, las aplicaciones que se

Ejecucin en paralelo. .NET Framework ayuda a resolver conflictos entre

Compatibilidad con mltiples versiones (multi-targeting). Al usar la Biblioteca

ESCUELA DE TECNOLOGAS DE LA INFORMACIN 16

.NET Framework para usuarios.

Si no desarrollara aplicaciones de .NET Framework, pero las usa, no es

Si usa el sistema operativo Windows, es posible que .NET Framework ya est

En general, no debe desinstalar ninguna versin de .NET Framework que est

.NET Framework para Silverlight para desarrolladores.

Si es desarrollador, puede elegir cualquier lenguaje de programacin

Para desarrollar aplicaciones o componentes de .NET Framework, haga lo

1. Instale la versin de .NET Framework que ser destino de su aplicacin. La

2. Seleccione el lenguaje o los lenguajes de .NET Framework que utilizar para