Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Lenguaje de Programación
Lenguaje de Programación
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
FUNDAMENTO TERICO. .................................................................................................. 158
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
FUNDAMENTO TERICO. .................................................................................................. 220
Identificar la importancia de un procedimiento. ....................................................................... 220
PROGRAMAR PROCEDIMIENTOS PARA RESOLVER CASOS PRCTICOS. .............. 223
01
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.
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.
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:
Puede que nos pida reinicio, lo hacemos y ya tenemos nuestro Visual Basic
2010 instalado. Hasta aqu ha sido todo muy fcil.
FUNDAMENTO TERICO.
.Net Framework
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.
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.
- Image: Imagen
- Data: Conexin a origen de datos
- OLE: Contenedor de documentos embebidos compatibles con Object
Linking and Embedding
? 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.
Auto.color = rojo
Sub girarllave( )
Auto.encendido=true
end sub.
Ejemplo de cdigo
Inconvenientes:
Las crticas hechas en las ediciones de Visual Basic anteriores a VB.NET son
variadas; se citan entre ellas:
02
II. DIFERENCIAR LA PROGRAMACIN POR CONSOLA Y CON
FORMULARIOS.
Equipos y Materiales:
Computadora con microprocesadores core 2 Duo de mayor
capacidad.
Sistema operativo Windows.
Acceso a internet.
Software de maquetacin y desarrollo de pginas web.
Orden de Ejecucin:
Definicin de un proyecto en Visual Net
Elaborar programa en modo consola
Disear y programar un formulario
Para iniciar la codificacin en Visual Net 2010 seguimos los siguientes pasos:
4
5
Ejemplo:
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
2.- Ingrese por teclado un nmero de dos cifras, visualice su nmero invertido.
Imports System.Console
Imports System.Math
Module Module2
Sub Main()
Dim nmero, inverso, unidad, decena As Integer
End Sub
End Module
3.- Ingrese por teclado un nmero de 3 cifras, visualice la suma de las cifras del
nmero ingresado.
Imports System.Console
Imports System.Math
Module Module3
Sub Main()
Dim nmero, unidad, decena, centena, suma As Integer
End Sub
End Module
Imports System.Console
Imports System.Math
Module Module3
Sub Main()
Dim nombre, precio, descuento1, descuento2, neto As Double
End Sub
End Module
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
Tipo_Dato: Lista_Variables
Ejemplos:
ENTERO: A, B, C
REAL: X, Y, Z
CARCTER: Car1, Car2
CADENA: Texto1, Texto2
LOGICO: Estado, Ok, Done
Seudocdigo Visual
Entero Integer
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
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
Module Module1
Sub Main()
Dim A, B, Mayor As Integer
End Sub
End Module
Imports System.Console
Imports System.Math
Module Module2
Sub Main()
Dim N As Integer
End Sub
End Module
Imports System.Console
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
Imports System.Console
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
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());
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());
Console.WriteLine();
Console.WriteLine();
//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.Collections.Generic;
using System.Text;
namespace Convertir_pies_a_metros
{
class Program
{
static void Main(string[] args)
{
//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.Collections.Generic;
using System.Text;
namespace Sumatoria_Numeros_Pares
{
class Program
{
static void Main(string[] args)
{
//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.ReadLine();
}
ESCUELA DE TECNOLOGAS DE LA INFORMACIN 44
LENGUAJE DE PROGRAMACIN I
}
}
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.Collections.Generic;
using System.Text;
namespace Cajero_Automatico
{
class Program
{
static void Main(string[] args)
{
//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;
Monedas5 = Residuo / 5;
Residuo=Residuo%5;
Monedas2 = Residuo / 2;
Residuo = Residuo % 2;
Monedas1 = Residuo / 1;
Residuo = Residuo % 1;
//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("Billetes de 50 : {0}", Billetes50);
Console.WriteLine("Billetes de 20 : {0}", Billetes20);
Console.WriteLine("Billetes de 10 : {0}", Billetes10);
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();
}
}
}
O bien
O bien
Modificar formularios
O bien
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.
Puesto que sta es la ventana en la que aparecern las pginas web, ser
mejor que no quede demasiado reducida.
Ahora ver que el texto situado en la parte superior del formulario Windows
Forms (en el rea denominada barra de ttulo) ha cambiado.
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.
Sintaxis en C#
[ComVisibleAttribute(true)]
[ClassInterfaceAttribute(ClassInterfaceType.AutoDispatch)]
public class Button : ButtonBase, IButtonControl
Sintaxis en C#
[ClassInterfaceAttribute(ClassInterfaceType.AutoDispatch)]
[DefaultBindingPropertyAttribute("Text")]
[ComVisibleAttribute(true)]
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.
Nota:
Asegrese de incluir http:// delante de cada una de las direcciones de sitio web.
Sintaxis en c#
[ComVisibleAttribute(true)]
[ClassInterfaceAttribute(ClassInterfaceType.AutoDispatch)]
[DockingAttribute(DockingBehavior.AutoDock)]
[PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = FullTrust")]
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.
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.
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();
}
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.
C#
comboBox1.SelectedIndex = 0;
webBrowser1.GoHome();
FUNDAMENTO TERICO:
Propiedades de archivo.
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).
Propiedad BuildAction.
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
Propiedad CopyToOutputDirectory.
Nota:
siguiente forma:
Nota:
Propiedad CustomTool.
Propiedad CustomToolNamespace.
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.
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).
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.
8. Guarde el archivo.
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++.
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.
Como ves, es una ventana en modo texto. Lo nico que se pueden mostrar son
filas de caracteres. No hay grficos.
El indicativo por defecto muestra la carpeta actual seguida del smbolo mayor
que (>). El cursor est esperando que escribamos una orden.
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.
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.
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 >):
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:
cl /Feejecutable programa.cpp
cl /Fehola.exe hola.cpp
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:
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.
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.
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.
<FORM>
<Layout>
<Group>
<Column PercentWidth="70">
<Group>
<Column PercentWidth="100">
<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:"
LabelPosition="Left" />
<Group>
<Column PercentWidth="50">
<Control FieldName="Microsoft.VSTS.Common.ProductUnit"
Type="FieldControl" Label="PU (Use Area Path)" LabelPosition="Left" />
</Column>
<Column PercentWidth="50">
<Control FieldName="Microsoft.VSTS.Common.Priority"
Type="FieldControl" Label="Priority" LabelPosition="Left" />
</Column>
</Group>
</Column>
</Group>
</Column>
<Column PercentWidth="30">
<Group Label="Status">
<Column PercentWidth="100">
<Control FieldName="System.Id" Type="FieldControl" Label="Id"
LabelPosition="Left" />
<Control FieldName="System.State" Type="FieldControl" Label="State"
LabelPosition="Left" />
<Control FieldName="System.AssignedTo" Type="FieldControl"
Label="Assigned To" LabelPosition="Left" />
</Column>
</Group>
</Column>
</Group>
<Group Label="">
<Column PercentWidth="60">
...
</Layout>
</FORM>
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.
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.
<FORM>
<Layout>
...
<TabGroup>
<Tab Label="Planning">
<Group Label="Status" Padding="(0,0,0,3)">
<Column PercentWidth="50">
<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>
<Column PercentWidth="100">
<Control FieldName="Microsoft.DevDiv.Story" Type="HtmlFieldControl"
Label="Story Board" LabelPosition="Top" />
</Column>
</Group>
<Group>
<Column PercentWidth="100">
</Layout>
</FORM>
Agrupar campos.
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.
<TabGroup>
<Tab Label="Planning">
<Group Label="Status" Padding="(0,0,0,3)">
<Column PercentWidth="5100">
<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>
<FORM>
<Layout>
<Group>
<Column PercentWidth="36">
<Group>
<Control FieldName="System.Title" Type="FieldControl" Label="Title"
LabelPosition="Left" />
<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>
<Column PercentWidth="33">
<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>
<Column PercentWidth="31">
<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"
LabelPosition="Left" />
</Group>
</Column>
</Group>
...
</Layout>
</FORM>
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.
<Group>
<Column PercentWidth="50">
<Column PercentWidth="50">
<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>
<Column PercentWidth="50">
<Control Type="DateTimeControl"
FieldName="ABC_Company.Project.Manual.ChangeDate" Label="Change
Date" Format="Short" LabelPosition="Right" />
<Control Type="DateTimeControl"
FieldName="ABC_Company.Project.Manual.EstimateStartDate"
Label="Estimated Start Date" Format="Short" LabelPosition="Right" />
<Control Type="DateTimeControl"
FieldName="ABC_Company.Project.Manual.ActualStartDate" Label="Actual
Start Date" Format="Short" LabelPosition="Right" />
<Control Type="DateTimeControl"
FieldName="ABC_Company.Project.Manual.FinishDate" Label="Finish Date"
Format="Short" LabelPosition="Right" />
</Group>
</Column>
</Group>
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.
definir el tamao del borde que rodea al control. Para obtener ms informacin,
vea los temas siguientes:
<FORM>
<Layout Target="WinForms" >
...
</Layout>
<Layout Target="Web" >
...
</Layout >
</FORM>
03
III. PROGRAMAR ESTRUCTURAS CONDICIONALES.
Equipos y Materiales:
Computadora con microprocesadores core 2 Duo de mayor
capacidad.
Sistema operativo Windows.
Acceso a internet.
Software de maquetacin y desarrollo de pginas web.
Orden de Ejecucin:
Trabajar con constantes y variables.
Identificar los tipos de datos que existen en visual net.
Analizar la importancia de una estructura condicional.
Variable.
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;
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
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).
Como variables:
C#
int answer = 42;
string greeting = "Hello, World!";
Como constantes:
C#
const int speedLimit = 55;
const double pi = 3.14159265358979323846264338327950;
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).
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"
Ejemplo
// 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")]
// TraceTest.cs
// compile with: /reference:CondMethod.dll
// arguments: A B C
using System;
using TraceFunctions;
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
Ejecucin de ejemplo
El comando:
tracetest A B C
El comando:
tracetest
Representacin grfica:
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:
Diagrama de flujo:
No hay que confundir los rombos de las estructuras condicionales con los de
las estructuras repetitivas do while.
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:
using System;
using System.Collections.Generic;
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();
}
ESCUELA DE TECNOLOGAS DE LA INFORMACIN 94
LENGUAJE DE PROGRAMACIN I
}
static void Main(string[] args)
{
}
}
}
Ejemplo 2:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
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("--------TIENDA KEDINN -------");
}
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("--------TIENDA KEDINN -------");
Cliente clie = new Cliente();
clie.Inicio();
clie.Descuento();
}
}
}
Ejemplo 3:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ejercicio3
{
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");
precio = float.Parse(Console.ReadLine());
}
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();
}
}
}
}
Ejemplo 4:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ejercicio3
{
class Camisas
{
float precio;
public void Ingresar()
{
Console.WriteLine("-----EMPRESA FAEMAS-----");
}
else
{
sem.Ingresar();
sem.Trabajo();
}
}
}
FUNDAMENTO TERICO.
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.
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;
}
Se pueden declarar varias constantes del mismo tipo al mismo tiempo, por
ejemplo:
C#
class Calendar2
{
const int months = 12, weeks = 52, days = 365;
}
C#
class Calendar3
{
const int months = 12;
const int weeks = 52;
const int days = 365;
C#
int birthstones = Calendar.months;
C#
int x = 1; // x holds the value 1
x = 2; // now x holds the value 2
Class Class1 {
private const int min = 1;
private const int max = 100;
public const int rango = max min;
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.
string s4 = @"C:\WINNT";
mbito y Visibilidad:
using System;
namespace ConsoleAppVisibilitat
{
class Simple
{
public int Var1=10;
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 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.
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);
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.
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));
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.
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#
int i = 10;
object o = i;
System.Console.WriteLine(o.ToString());
Constantes.
Enumeraciones.
C#
public enum Color
{
Green, //defaults to 0
Orange, //defaults to 1
Red, //defaults to 2
Blue //defaults to 3
}
C#
public enum Color2
{
Green = 10,
Orange = 20,
Red = 30,
Blue = 40
}
C#
class TestEnums
{
static void Main()
{
System.Console.WriteLine("Possible color choices: ");
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.
C#
static void Main()
ESCUELA DE TECNOLOGAS DE LA INFORMACIN 112
LENGUAJE DE PROGRAMACIN I
{
//Using escaped characters:
string path1 = "\\\\FileShare\\Directory\\file.txt";
System.Console.WriteLine(path1);
C#
int int1 = 5;
C#
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.
C#
int i = 10;
int j = 20;
Tienen ubicaciones de memoria independiente:
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:
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#).
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.
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.
{}+
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.
Semntica.
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.
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.
Por ejemplo:
Estructuras estticas
Tipos primitivos:
Tipos numricos:
Tipos estructurados:
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
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.
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.
Unidades.
ESTRUCTURAS SECUENCIALES.
PSEUDOCODIGO Nombre
VARIABLES
Nombre: Tipo De Dato
CONSTANTES
Nombre = Valor
INICIO
accion
accion1
accion2
.
.
.
accionN
FIN
En Diagrama de Flujo:
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.
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.
Estructuras condicional.
Estructura condicional simple.
Representacin grfica:
Representacin grfica:
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: }
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?
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: }
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.
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: ");
ESCUELA DE TECNOLOGAS DE LA INFORMACIN 132
LENGUAJE DE PROGRAMACIN I
9: edad = System.Convert.ToInt32(System.Console.ReadLine());
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: }
Desarrolle una aplicacin que nos permita saber lo siguiente, segn la edad
que se haya ingresado:
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 >= 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: }
Switch Case.
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: }
1: namespace Ejemplos_MVA
2: {
3: class Program
4: {
5: static void Main(string[] args)
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.
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.
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.
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.
04
IV. PROGRAMAR ESTRUCTURAS REPETITIVAS.
Equipos y Materiales:
Orden de Ejecucin:
Definir una estructura repetitiva.
Tipos de estructuras repetitivas en visual net.
Elaborar casos prcticos utilizando estructuras repetitivas.
Bucles While
Bucles Do
Bucles For
Usando while.
Diagrama de flujo:
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.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaWhile2
{
class Program
{
static void Main(string[] args)
{
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)
Ejemplo 1:
El usuario introduce nmeros y el ordenador cuenta cuantos son positivos.
class Program
{
static void Main(string[] args)
{
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
{
static void Main(string[] args)
{
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();
Console.WriteLine("Final del programa");
} // fi Main
} // fin Class
Usando do while.
Ejemplo 01.
Diagrama de flujo:
No hay que confundir los rombos de las estructuras condicionales con los de
las estructuras repetitivas do while.
Programa:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaDoWhile1
class Program
int valor;
string linea;
do {
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.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaDoWhile
{
class Program
{
static void Main(string[] args)
{
int suma, cant, valor, promedio;
string linea;
ESCUELA DE TECNOLOGAS DE LA INFORMACIN 148
LENGUAJE DE PROGRAMACIN I
suma = 0;
cant = 0;
do
{
Console.Write("Ingrese un nimero (0 para finalizar):");
linea = Console.ReadLine();
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();
}
}
}
Ejemplo 3:
Se pide realizar un programa que lea los datos de las cuentas corrientes e
informe:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaDoWhile
{
class Program
{
static void Main(string[] args)
{
int cuenta;
float saldo, suma;
string linea;
suma = 0;
do
{
Console.Write("Ingrese nmero de cuenta:");
linea = Console.ReadLine();
cuenta = int.Parse(linea);
if (cuenta >= 0)
{
Console.Write("Ingrese saldo:");
linea = Console.ReadLine();
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();
}
}
}
Usando for:
Ejemplo 1:
Diagrama de flujo:
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.Collections.Generic;
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:
Console.Clear();
if (dado == 1)
contador = contador + 1;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("-");
Ejemplo 3:
Console.Clear();
Console.Write("*");
Console.WriteLine(" ");
Ejemplo 4:
Programa que muestra el da que ser maana. Ex: 31/12/08 -> 01/01/09
#include <iostream>
void main()
int d,max,m,a,resto;
scanf("%d",&d);
scanf("%d",&m);
scanf("%d",&a);
if (m==2)
resto = funcion_divisor(a,4);
if (resto==0) max=29;
else max=28;
d++;
if (d>max)
d=1;
m++;
printf("\n\n");
return (resto);
Ejemplo 5:
using System;
using System.Collections.Generic;
using System.Text;
class Ejercicio_2_6
string n_resultado="";
double resultado=0;
Console.WriteLine("-");
teclado = Console.ReadLine();
switch (teclado)
case "1":
n_resultado = "Potencia";
case "2":
n_resultado = "Tension";
case "3":
n_resultado = "Intensidad";
case "4":
break;
} // fi Main
Console.WriteLine("Introduce {0}",nom1);
FUNDAMENTO TERICO.
Sabemos hacer que el programa tome una serie de decisiones, en funcin del
estado del programa. Y es hora de pasar al siguiente punto.
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;
x++;
Console.ReadKey();
Programa();
Programa();
int x = 0;
do
Console.WriteLine(x.ToString() + "\n");
Console.ReadKey();
x++;
Console.ReadKey();
do
Console.WriteLine(x.ToString() + "\n");
Console.ReadKey();
x++;
if (x == 8) { break; }
x++;
Console.WriteLine(x.ToString() + "\n");
Console.ReadKey();
do
x++;
if (x == 8) { continue; }
Console.WriteLine(x.ToString() + "\n");
Console.ReadKey();
Console.WriteLine(x.ToString() + "\n");
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.
while (true)
Hay que tener mucho cuidado con sto, sobre todo en programas muy
complejos en los que se usen muchos bucles.
Representacin grfica:
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.
Representacin grfica:
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.
Analicemos el ejemplo:
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++).
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:
Ejemplo 1:
Diagrama de flujo:
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.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaWhile3
{
class Program
{
static void Main(string[] args)
{
int x,suma,valor,promedio;
string linea;
x=1;
suma=0;
while (x<=10)
{
Console.Write("Ingrese un valor:");
linea = Console.ReadLine();
valor=int.Parse(linea);
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.Write(promedio);
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:
Programa:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaWhile4
{
class Program
{
static void Main(string[] args)
{
int x,cantidad,n;
float largo;
string linea;
x=1;
cantidad=0;
Console.Write("Cuantas piezar procesar:");
linea = Console.ReadLine();
n=int.Parse(linea);
while (x<=n)
{
Console.Write("Ingrese la medida de la pieza:");
linea = Console.ReadLine();
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:
No existe una RECETA para definir una condicin de una estructura repetitiva,
sino que se logra con una prctica continua solucionando problemas.
namespace EstructuraRepetitivaWhile1
{
class Program
{
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.
Ejemplo 01:
Diagrama de flujo:
Programa:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaDoWhile2
{
class Program
{
static void Main(string[] args)
{
int suma,cant,valor,promedio;
string linea;
suma=0;
cant=0;
do {
Console.Write("Ingrese un valor (0 para finalizar):");
linea = Console.ReadLine();
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();
}
}
}
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:
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:
Programa:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaDoWhile3
{
class Program
{
static void Main(string[] args)
{
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):");
linea = Console.ReadLine();
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.WriteLine(cant1);
Console.Write("Piezas con un peso inferior a 9.8:");
Console.WriteLine(cant3);
Console.ReadLine();
}
}
}
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.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraRepetitivaFor2
{
class Program
{
static void Main(string[] args)
{
int suma,f,valor,promedio;
string linea;
suma=0;
for(f=1;f<=10;f++)
{
Console.Write("Ingrese valor:");
linea=Console.ReadLine();
valor=int.Parse(linea);
suma=suma+valor;
}
Console.Write("La suma es:");
Console.WriteLine(suma);
promedio=suma/10;
Console.Write("El promedio es:");
Console.Write(promedio);
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
namespace EstructuraRepetitivaFor3
{
class Program
{
static void Main(string[] args)
{
int aprobados,reprobados,f,nota;
string linea;
aprobados=0;
reprobados=0;
for(f=1;f<=10;f++)
{
Console.Write("Ingrese la nota:");
linea = Console.ReadLine();
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:
namespace EstructuraRepetitivaFor4
{
class Program
{
static void Main(string[] args)
{
int mul3,mul5,valor,f;
string linea;
mul3=0;
mul5=0;
for(f=1;f<=10;f++)
{
Console.Write("Ingrese un valor:");
linea = Console.ReadLine();
valor=int.Parse(linea);
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:
La estructura for permite que el valor inicial o final dependa de una variable
cargada previamente por teclado.
Diagrama de flujo:
05
V. PROGRAMAR ESTRUCTURAS ANIDADAS SIMPLES Y
COMPLEJAS.
Equipos y Materiales:
Orden de Ejecucin:
Definir la importancia de anidar correctamente dos o ms estructuras.
Desarrollar estructuras anidadas para la solucin de problemas.
Este programa lee las temperaturas de los 365 das del ao cada hora
#include <conio.h>
#include <stdio.h>
void main(void)
{ float temp;
clrscr();
while(dias<=365)
for( horas=1;horas<=24;horas++)
scanf(%f,&temp);
dias=dias+1;
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;
clrscr();
for(dias=1;dias<=365;dias++)
for( horas=1;horas<=24;horas++)
scanf(%f,&temp);
Diagrama de flujo:
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.
Programa:
import java.util.Scanner;
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.
FUNDAMENTO TERICO:
En programacin.
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
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 .
Niveles de anidamiento.
.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
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
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:
Identificar la importancia de un procedimiento.
Programar procedimientos para resolver casos prcticos.
Ejemplo
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);
}
Ejemplo 1:
Cdigo:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Clases
{
public class Agenda
{
float version = 1.0f; // variable privada
class Program
{
static void Main(string[] args)
{
int numero = 3;
string cadena = "mi cadena";
A.Nombre = "Pedro";
A.DameTuNombre();
A.DameTuNombre("Pepito");
cadena=A.DameTu("el nombre de tu abuela");
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.
23. Console.SetCursorPosition (3,3); // Pedimos
la operacin
24. Console.WriteLine ("Introduzca la operacin
a realizar (+,-,*,/)");
25. Console.SetCursorPosition (59,3);
26. operacion = Console.ReadLine();
27.
28. Console.SetCursorPosition (3,4); // Pedimos
el segundo nmero
29. Console.WriteLine ("Introduzca el segundo
nmero");
30. Console.SetCursorPosition (60,4);
31. segundo = float.Parse(Console.ReadLine());
32.
33.
34. Console.SetCursorPosition (57,5); //
Mostramos la solucion...
35. Console.WriteLine ("__________");
36.
37. Console.SetCursorPosition (3,6);
38. Console.WriteLine ("El resultado es");
39. Console.SetCursorPosition (60,6);
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. {
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.
28. void Numero8Click(object sender, EventArgs e)
29. {
30. txtnum.Text = txtnum.Text + 8;
31. }
32.
33. void Numero9Click(object sender, EventArgs e)
34. {
35. txtnum.Text = txtnum.Text + 9;
36. }
37.
38. void Numero4Click(object sender, EventArgs e)
39. {
40. txtnum.Text = txtnum.Text + 4;
41. }
42.
43. void Numero5Click(object sender, EventArgs e)
44. {
45. txtnum.Text = txtnum.Text + 5;
46. }
47.
48. void Numero6Click(object sender, EventArgs e)
49. {
50. txtnum.Text = txtnum.Text + 6;
51. }
52.
53. void Numero1Click(object sender, EventArgs e)
54. {
55. txtnum.Text = txtnum.Text + 1;
56. }
57.
58. void Numero2Click(object sender, EventArgs e)
59. {
60. txtnum.Text = txtnum.Text + 2;
61. }
62.
63. void Numero3Click(object sender, EventArgs e)
64. {
Ejemplo 3:
Resolver ecuaciones de seegundo grado (aadir 3 text box y un boton)
1. using System;
2. using System.Collections.Generic;
3. using System.ComponentModel;
4. using System.Data;
5. using System.Drawing;
6. using System.Text;
7. using System.Windows.Forms;
8.
9. namespace Ecuaciones
10. {
11. public partial class Form1 : Form
12. {
13. public Form1()
14. {
15. InitializeComponent();
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;
2. using System.Collections.Generic;
3. using System.ComponentModel;
4. using System.Data;
5. using System.Drawing;
6. using System.Text;
7. using System.Windows.Forms;
8. using System.IO;
9.
10. namespace ExploradorCarpetas
11. {
12. public partial class Form1 : Form
13. {
14. public Form1()
15. {
16. InitializeComponent();
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. {
35. // Listamos las carpetas
36. carpetas(txtRuta.Text);
37.
38. // Listamos los archivos
39. archivos(txtRuta.Text);
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.
47. // Listamos las carpetas
48. carpetas(txtRuta.Text);
49.
50. // Listamos los archivos
51. archivos(txtRuta.Text);
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());
58. break;
59.
60. case 3: // PRODUCTO POR UN ESCALAR
61.
62. // Leemos el nmero de filas y
columnas de la matriz 1
63. Console.WriteLine ("Introduzca el
nmero de filas de la matriz 1");
64. f1 = int.Parse (Console.ReadLine());
65. Console.WriteLine ("Introduzca el
nmero de columnas de la matriz 1");
66. c1 = int.Parse
(Console.ReadLine());
67.
68. float escalar;
69. Console.WriteLine ("Introduzca el
escalar por el que quiere multiplicar la matriz");
70. escalar =
float.Parse(Console.ReadLine());
71.
72. // Pedimos los datos de filas y
columnas
73. Console.WriteLine ("Introduzca los
datos de la matriz 1 enumerandolos por filas:");
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:");
132. {
133. for (int columna = 0; columna <=
mat2.GetUpperBound(1); columna++)
134. {
135. float suma;
136. suma = mat1[fila,columna]
+ mat2[fila,columna];
137. Console.WriteLine
(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)");
147. for (int fila = 0; fila <=
mat2.GetUpperBound(0); fila++)
148. {
149. for (int columna = 0; columna <=
mat2.GetUpperBound(1); columna++)
150. {
151. float resta;
152. resta = mat1[fila,columna] -
mat2[fila,columna];
153. Console.WriteLine
(resta.ToString());
154. }
155. Console.WriteLine("");
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)");
163. for (int fila = 0; fila <=
mat1.GetUpperBound(0); fila++)
164. {
Ejemplo 6:
Windows-pong, con dos botones y un radio buton simulo en clasico pong, muy
cutre pero entretenido
1. using System;
2. using System.Collections.Generic;
3. using System.Drawing;
4. using System.Windows.Forms;
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. {
25. InitializeComponent();
ESCUELA DE TECNOLOGAS DE LA INFORMACIN 217
LENGUAJE DE PROGRAMACIN I
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.
Programacin funcional
Utilidad.
Caractersticas.
El mtodo Main ()
Main puede devolver slo int o void y tiene un argumento de matriz de cadena
opcional para representar parmetros de lnea de comandos:
C#
//...
return 0;
Otros mtodos.
Existen dos formas de enviar datos a un mtodo: por valor y por referencia.
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.
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.
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.
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.
class Program
{
static int x = 5; // Variable global
static void Main(string[] args)
{
int y = 13; // Variable local
Console.WriteLine("\nx=" + x);
// Llamada al mtodo y envo por valor
Metodo(y);
Console.WriteLine("\nx=" + x);
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;
}
}
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.
class Program
{
static int x = 5; // Variable global
static void Main(string[] args)
{
int y = 13; // Variable local
Console.WriteLine("\nx=" + x);
// Llamada al mtodo y envo por referencia
Metodo(ref y);
Console.WriteLine("\nx=" + x);
Console.WriteLine("\ny=" + y);
Console.ReadKey();
}
// El parmetro "a" recibe la ref. de "y"
static void Metodo(ref int a)
{
a = a + 3;
Console.WriteLine("\na=" + a);
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.
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
{
static int x = 5; // Variable global
static void Main(string[] args)
{
int y = 13; // Variable local
bool esImpar;
Console.WriteLine("\nx=" + x);
// Llamada al mtodo y envo por referencia Metodo(ref y, out esImpar);
Console.WriteLine("\nx=" + x);
Console.WriteLine("\ny=" + y);
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;
Console.WriteLine("\na=" + a);
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
C#
class TestRef
{
private static void Add(int i, ref int result)
{
result += i;
return;
}
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;
}
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:
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:
Por consola:
Hola Jesus
Primera clase del curso de C#
FIN DEL PROGRAMA
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.
class Program
{
static void Main(string[] args)
{
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();
}
ESCUELA DE TECNOLOGAS DE LA INFORMACIN 234
LENGUAJE DE PROGRAMACIN I
class Program
{
static void Main(string[] args)
{
// 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;
}
}
}
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
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.