ProgramacionCSharp 02

Captulo 2
EL LENGUAJE C#

C# es un moderno lenguaje de programacin orientada a objetos desarrollado para
programar sobre la plataforma .NET. Comenzando con su nombre, la intencin
fundamental ha sido ofrecer a los programadores de C++, un entorno familiar para
programar aplicaciones de software sobre esta plataforma y aquellas que cumplan la
especificacin de .NET. En consecuencia se han adoptado muchos de los recursos de
programacin que maneja este lenguaje, pero adaptados a .NET y todas las
herramientas que este entorno pone a disposicin del programador.
En este captulo se realizar una breve descripcin de los elementos bsicos del
lenguaje como tal, intentando hacer una explicacin precisa sobre estos. Aunque el
lector debe tener una nocin bsica sobre programacin de computadores, no se
requiere ser experto en programar con C++, ya que la realidad es que este lenguaje ha
sido solo un punto de partida para C#, y solo se conservan sus estructuras bsicas. C#
est dotado de su propia estructura y evita los aspectos difciles de C++, al menos en lo
bsico, como es el manejo de los recursos de programacin.
Se espera con el desarrollo de este captulo dejar claros los conceptos bsicos de la
estructura del lenguaje C# y poner a disposicin del programador los recursos ms
importantes que le permitan comprender la programacin en .NET con este lenguaje.

El estilo de programacin C#
Todos los programas desarrollados en C# comienzan su ejecucin a travs de una
funcin o mtodo principal llamado Main(), sin importar el entorno donde se vaya a
ejecutar la aplicacin: consola, entorno grfico o web. Este mtodo es quien se encarga
de informarle al sistema operativo el inicio de la ejecucin, cargar los componentes
bsicos del programa en memoria y al final terminar la ejecucin.
En el instante en que se inicia la ejecucin de un programa cualquiera, el sistema
operativo no posee nada de ese programa en su memoria. En un entorno orientado a
objetos, como lo es .NET, se esperara un objeto producto de alguna clase, pero en este
punto es imposible contar con alguna clase de nuestro programa en memoria, por lo
tanto es necesario recurrir a una funcin o mtodo que se ejecute independiente de un
objeto. La solucin, en C#, es declarar el mtodo Main como esttico, mediante la
palabra static, lo cual permite llamar a Main en forma independiente, sin necesidad de
un objeto.
El lenguaje C# dentro de su sintaxis utiliza obligatoriamente las llaves, { }, para
determinar bloques de cdigo, y el carcter punto y coma (;) para establecer el final de
una instruccin. La apertura de una llave marca el punto de inicio de un bloque, y su
cierre el punto de finalizacin.
Uno de los problemas ms frecuentes para en este tipo de lenguajes, es el cierre no
adecuado de una llave, o la no colocacin de una finalizacin de instruccin al final de
una instruccin, lo cual provoca un error de compilacin, por eso es recomendable
distinguir los bloques con tabulaciones creadas a partir de los puntos de apertura y
cierre de una llave y escribir en cada lnea una instrucciones completa.
CAPITULO CAPITULO CAPITULO CAPITULO 2 2 2 2 PROGRAMACION CON C#
www.pedrov.phpnet.us
16 16 16 16
La mayora de programadores han adoptado, como regla de estilo, establecer sangras
para cada bloque de cdigo, dejando claro donde empieza y donde termina dicho
bloque, como por ejemplo:

namespace HolaMundo
{
public class PrimerPrograma
{
static void Main()
{
System.Console.WriteLine("Hola mundo");
}
}
}

Para el compilador, y tal vez para muchos programadores, es vlido escribir un
programa como,

namespace HolaMundo
{
{
static void Main()
{
}
}
}

o incluso as,

namespace HolaMundo {public class PrimerPrograma {
static void Main() {System.Console.WriteLine(
"Hola mundo");}}}

Sin embargo este tipo de codificacin, aunque es vlida, perjudica la lectura posterior
del programa, ya sea por el mismo programador o por cualquier otra persona, y adems
vuelve casi imposible encontrar los errores de programacin.

Comentarios

Los comentarios son trozos de texto que pretenden explicar algo dentro del cdigo de
un programa, pero que no son tenidos en cuenta por el compilador, y su utilidad solo es
vlida para el programador o quin desee interpretar el cdigo. Esto no quiere decir
que los cometarios no sean importantes, todo lo contrario son una parte muy
importante de la programacin ya que, bien utilizados, permiten explicar el cdigo
programado y de esta forma facilitar su interpretacin y posterior mantenimiento.
Al igual que C++, el lenguaje C# interpreta como comentarios todo aquello que este
precedido por dos caracteres de lnea diagonal (//), siempre y cuando se encuentren en
una sola lnea. Por ejemplo, se consideran comentarios los siguientes:

// Esta lnea es ignorada por el compilador
// por que se trata de un comentario

Los comentarios se pueden colocar al principio de una lnea o al final, pero nunca
pueden partirse a dos o ms lneas. Si se desea colocar comentarios de ms de una
CAPITULO CAPITULO CAPITULO CAPITULO 2 22 2: EL LENGUAJE C#

pedrov.cs@hotmail.com
17 17 17 17
lnea, deber incluirlos entre los caracteres /* y */, que permite escribir cualquier
cantidad de lneas. El siguiente programa tiene las dos formas de comentarios:

/* Este es un comentario que ocupa
ms de una lnea */
namespace HolaMundo
{
// Este es un comentario de una lnea
{
static void Main()
{
}
}
}

Un buen programador no puede confiarse de su memoria, son tantas las lneas que
puede llegar a tener un programa que con el tiempo se olvidan o se pierde la
explicacin sobre su forma de funcionar. Una buena documentacin del cdigo a travs
de los comentarios facilita en mucho el posterior mantenimiento del cdigo o su
aprovechamiento para otros programas.

Secuencias de escape
Los caracteres especiales, tambin llamados secuencias de escape, le permiten al
programa realizar algunas acciones especiales, relacionadas especialmente con cadenas
de caracteres. Estos caracteres no son imprimibles y estn compuestos por dos
grafemas, de los cuales el primero siempre ser la lnea diagonal invertida, \. La
siguiente tabla muestra las secuencias de escape definidas en C#:

Secuencia de escape Descripcin
\a Alerta (timbre)
\b Retroceso
\f Avance de pgina
\n Nueva lnea
\r Retorno de carro
\t Tabulador horizontal
\v Tabulador vertical
\0 Nulo
\' Comilla sencilla
\" Comilla doble
\\ Diagonal invertida

Ejemplo 2.1 Tabla de pases

En este ejemplo se construir, en la consola, una pequea tabla con los nombres de
algunos pases suramericanos, aprovechando la secuencia de escape tabulador
horizontal. Al final del programa se coloca una secuencia de escape de alerta que
produce un pitido de la bocina del computador.

18 18 18 18

/* Archivo: Ejemplo21.cs
Programa para mostrar el uso de las secuencias de escape
*/
using System; // Espacio de nombres
public class TablaPaises
{
static void Main()
{
Console.WriteLine("-----------------");
Console.WriteLine("No.\tPAIS");
Console.WriteLine("-----------------\n");
Console.WriteLine("1\tColombia");
Console.WriteLine("2\tEcuador");
Console.WriteLine("3\tParaguay");
Console.WriteLine("4\tBolivia");
Console.WriteLine("5\tUruguay");
Console.WriteLine("6\tArgentina");
Console.WriteLine("7\tVenenzuela");
Console.WriteLine("\a");
}
}

Tipos

Un tipo se debe entender como una palabra del lenguaje de programacin que establece
como se comporta, se almacena en memoria y se procesa un valor por parte del
computador. Estos tipos son fijados por estructuras definidas en System.
La siguiente tabla muestra los tipos bsicos definidos en C#:

Tipo C# Estructura .NET Tamao en bits
bool Boolean
byte Byte 8
char Char 16
DateTime DateTime 64
decimal Decimal 128
double Double 64
int Int32 32
long Int64 64
object Object 32
sbyte SByte 8
short Int16 16
float Single 32
string String
uint UInt32 32
ulong UInt64 64
ushort UInt16 16


19 19 19 19
En .NET todos los tipos son en realidad estructuras, cuyo objetivo no es solo fijar el
tamao del tipo en memoria sino ofrecer una serie de operaciones que permiten
manipular el valor definido por dicho tipo. C# por ser el lenguaje base de .NET hace
un manejo directo de esta forma de definir los tipos, pero para mantener la consistencia
con los estndares de lenguajes de programacin se han establecido alias para cada uno
de ellos, y de esta forma ahorrarle al programador el uso de los nombres de las
estructuras en las declaraciones que deba realizar. Por ejemplo, en C# el tipo valor
entero, que se identifica con la palabra clave int, en realidad lo establece la estructura
Int32 que en .NET corresponde a un nmero entero de 32 bits.
Todos los tipos bsicos que se manejan en C# pueden asociarse a un alias, como lo
muestra la tabla anterior, pero se debe tener en cuenta que estos alias, cuyos nombres
coinciden con los tipos definidos en otros lenguajes de programacin, no
necesariamente coinciden en sus caractersticas con sus correspondientes utilizados en
otros lenguaje. Estas diferencias se ven especialmente en cuanto al tamao ocupado en
la memoria del sistema.

El programa de este ejemplo le muestra los rangos de valores que maneja cada uno de
los tipos definidos en C#. Teniendo en cuenta que los tipos son definidos por clases se
utilizar un mtodo incluido en cada uno de ellos.

En este programa se ha utilizado otra versin del mtodo WriteLine, con tres
argumentos. En los anteriores ejemplos se haba utilizado una versin que trabajaba
con un solo argumento. Esta posibilidad que tienen un mtodo, de ofrecer diferentes
versiones para su uso, es lo que se denomina sobrecarga.
La salida que se obtiene despus de la ejecucin de este programa es similar a la
siguiente:

Byte: False y True
Byte: 0 a 255
Byte: a ?
Byte: 01/01/0001 12:00:00 a.m. a 31/12/9999 11:59:59 p.m.
Byte: -79228162514264337593543950335 a 79228162514264337593543950335
Ejemplo 2.2 Rango de valores manejado por cada tipo
/* Archivo: Ejemplo22.cs
Programa que muestra los rangos de los diferentes tipos
*/

using System;
public class RangoTipos
{
static void Main()
{
Console.WriteLine("boolean: {0} y {1}", Boolean.FalseString, Boolean.TrueString);
Console.WriteLine("byte: {0} a {1}", Byte.MinValue, Byte.MaxValue);
Console.WriteLine("char: {0} a {1}", Char.MinValue, Char.MaxValue);
Console.WriteLine("DateTime: {0} a {1}", DateTime.MinValue, DateTime.MaxValue);
Console.WriteLine("decimal: {0} a {1}", Decimal.MinValue, Decimal.MaxValue);
Console.WriteLine("double: {0} a {1}", Double.MinValue, Double.MaxValue);
Console.WriteLine("int: {0} a {1}", Int32.MinValue, Int32.MaxValue);
Console.WriteLine("long: {0} a {1}", Int64.MinValue, Int64.MaxValue);
Console.WriteLine("sbyte {0} a {1}", SByte.MinValue, SByte.MaxValue);
Console.WriteLine("short: {0} a {1}", Int16.MinValue, Int16.MaxValue);
Console.WriteLine("float: {0} a {1}", Single.MinValue, Single.MaxValue);
Console.WriteLine("uint: {0} a {1}", UInt32.MinValue, UInt32.MaxValue);
Console.WriteLine("ulong: {0} a {1}", UInt64.MinValue, UInt64.MaxValue);
Console.WriteLine("ushort: {0} a {1}", UInt16.MinValue, UInt16.MaxValue);
}
}
20 20 20 20
Byte: -1,79769313486232E+308 a 1,79769313486232E+308
Byte: -2147483648 a 2147483647
Byte: -9223372036854775808 a 9223372036854775807
Byte: -32768 a 32767
Single -3,402823E+38 a 3,402823E+38

Tipo de dato object
El tipo object es un tipo de dato que puede contener a cualquier otro tipo. En C# todo
es un objeto y los tipos que se definen en .NET se encuentran definidos en el espacio
de nombres System y se heredan directamente de System.Object, la estructura a la cual
representa el alias object.

Tipo de datos short, int y long
El tipo short es un entero de 16 bits, lo que significa que puede manipular 2
16
valores
numricos enteros con signo. Esto da un total de 65536 posibles valores enteros
diferentes. Para manipular por igual, valores negativos y positivos se divide esta cifra
entre 2 y se obtiene 32768 posibles valores para cada uno de esos grupos, pero para
incluir el cero es necesario sacrificar un valor negativo, quedando para estos un
mximo de 32767. Esto significa que este tipo puede manejar valores comprendidos en
el rango de -32767 a 32768.
En los primeros compiladores de C++ se defina un tipo int como un nmero entero de
16 bits, pero en C# el tipo int es el alias de la estructura Int32, que como se dijo, es un
entero de 32 bits, que permite manipular 2
32
(4294967296) valores numricos, los
cuales se reparten entre valores enteros positivos, negativos y el cero, con lo cual
permite un rango de valores comprendidos entre -2147483647 y 2147483648.
El tipo long es un entero de 64 bits, lo que da la posibilidad de manipular 2
64
valores
numricos enteros con signo, repartidos, al igual que los anteriores, entre enteros
positivos, negativos y el cero.

Tipos de datos enteros sin signo
Los nmeros enteros sin signo ocupan el mismo espacio en memoria que sus
correspondientes enteros con signo, pero se diferencian en que estos tipos solo
manipulan enteros positivos y el cero, lo cual significa que se los posibles valores a
generar son todos los valores comprendidos entre cero y el valor igual a la cantidad
total posible menos uno.

El tipo char
El tipo char se utiliza para definir un espacio de memoria que almacenara un nico
carcter. El espacio utilizado en memoria por este tipo es de 16 bits, lo cual permite la
definicin de 65536 posibles valores, suficientes para el sistema de caracteres
UNICODE, en el cual se incluyen todos los smbolos necesarios para todos los idiomas
que existen actualmente en el mundo.

El tipo string
Este tipo de datos sirve para definir cadenas de caracteres de la familia UNICODE. En
el momento este tipo de datos admite manejar cadenas de hasta 2 billones de
caracteres.
La estructura String cuenta con muchos mtodos que permiten la manipulacin de las
cadenas. En la siguiente tabla se describen brevemente algunas de ellas:


21 21 21 21
Nombre Descripcin
Contains Establece si una cadena de texto aparece dentro de aquella que ejecuta
a este mtodo
Copy Crea una copia exacta de la cadena.
CopyTo Copia un cierto numero de caracteres a una posicin que se haya
establecido.
EndsWith Determina si el final de una instancia de la cadena es igual a una cadena
especificada.
Equals Determina si dos cadenas tienen el mismo valor.
IndexOf Retorna el ndice de la primera aparicin de una cadena o carcter
dentro de otra cadena.
Insert Inserta una cadena especificada en una posicin indicada de otra
cadena.
LastIndexOf Informa la posicin de la ltima aparicin de un carcter Unicode
especificado o de una cadena dentro de otra.
PadLeft Alinea a la derecha los caracteres de la cadena e inserta a la izquierda
espacios en blanco o un carcter Unicode especificado hasta alcanzar la
longitud total especificada.
PadRight Alinea a la izquierda los caracteres de la cadena e inserta a la derecha
espacios en blanco o un carcter Unicode especificado hasta alcanzar la
longitud total especificada.
Remove Elimina un nmero de caracteres especificado de la cadena.
Replace Reemplaza todas las apariciones de un carcter Unicode o una cadena
en la cadena que ejecuta este mtodo, por otro carcter o cadena.
StartsWith Determina si el principio de una cadena coincide con una cadena
especificada.
Substring Recupera una subcadena de la cadena que lo ejecuta.
ToLower Devuelve una copia de esta cadena convertida en minsculas.
ToString Convierte el valor del objeto que lo ejecuta en una cadena.
ToUpper Devuelve una copia de esta cadena convertida en maysculas.
Trim Quita todas las apariciones de un conjunto de caracteres especificados
desde el principio y el final de la cadena.
TrimEnd Quita todas las apariciones de un conjunto de caracteres especificado en
una matriz del final de esta instancia.
TrimStart Quita todas las apariciones de un conjunto de caracteres especificado en
una matriz del principio de esta instancia.

Ejemplo 2.3 Trabajando con cadenas

El programa debe solicitar una cadena al usuario, para hacer algunos clculos y
cambios en ella. Entre los clculos estn: determinar la longitud de la cadena y
establecer la posicin donde aparece un carcter. Los cambios consisten en recortar la
cadena y cambiarle su forma a minsculas o maysculas.

22 22 22 22

/* Archivo: Ejemplo23.cs */

using System;

public class CadenaTexto
{
static void Main()
{
// Declaracin de variables
string cadena;
string mayusculas, minusculas;
string subcadena;
int longitud;
int posicionCaracter;
char caracter;
// Lectura de datos
Console.Write("Escriba una cadena: ");
cadena = Console.ReadLine();
Console.Write("Escriba un caracter: ");
caracter = Convert.ToChar(Console.ReadLine());
// Tareas sobre la cadena
longitud = cadena.Length; // Calcula la longitud
mayusculas = cadena.ToUpper(); // Convierte a maysculas
minusculas = cadena.ToLower(); // Convierte a minsculas
subcadena = cadena.Substring(2,5); // Toma un trozo de la cadena
posicionCaracter = cadena.IndexOf(caracter, 1);// Posicin en la cadena
// Mostrar los resultados
Console.Write("\nLongitud de la cadena: ");
Console.WriteLine(longitud);
Console.Write("En maysculas: ");
Console.WriteLine(mayusculas);
Console.Write("En minsculas: ");
Console.WriteLine(minusculas);
Console.Write("Subcadena: ");
Console.WriteLine(subcadena);
Console.Write("Primera posicin del caracter: ");
Console.WriteLine(posicionCaracter);
}
}

Al ejecutar este programa se debe ingresar una cadena de texto de al menos 5
caracteres, de lo contrario se producir un error en la ejecucin, al momento de intentar
obtener la subcadena, con la instruccin,

subcadena = cadena.Substring(2,5);

la cual lee los caracteres comprendidos entre la posicin 2 a 5 de la cadena.
En la instruccin,

caracter = Convert.ToChar(Console.ReadLine());

el mtodo esttico ToChar() de la clase Convert, se encarga de convertir el carcter
ingresado en forma de cadena de texto, al tipo char. Esta clase contiene todos los
mtodos necesarios para realizar la conversin de un tipo de dato a otro diferente,
siempre y cuando sea posible. Tambin cuenta con algunos mtodos para el manejo de
tipos.


23 23 23 23
Tipos enumerados
Los tipos enumerados son tipos definidos por el usuario y corresponden a conjuntos de
constantes numricas enteras que comienzan en 0. Para crearlos se utiliza la palabra
clave enum.
Por ejemplo, supongamos que un programador en el desarrollo de una aplicacin de
software necesita hacer referencia a los cargos de una empresa, tal como: Gerente,
Portero, Mensajero, Secretario, Contador. Si la referencia a estos nombres es necesaria
en varias partes del cdigo del programa, pueden presentarse muchos errores de
digitacin que complicaran la programacin. Una solucin sera relacionar a estos
cargos con valores numricos.

Cargo Constante
Gerente 0
Portero 1
Mensajero 2
Secretario 3
Contador 4

Pero en un momento dado esto puede complicar an ms las cosas por que con el
tiempo puede llegarse a olvidar la relacin existente entre la constante numrica y el
nombre del cargo. Para facilitar las cosas el programador podra definir un tipo
enumerado, en la siguiente forma:

enum Cargo
{
Gerente,
Portero,
Mensajero,
Secretario,
Contador,
};

De esta manera se dispone de cuatro constantes numricas que relacionan los cargos
con un valor. Para referirse a una de estas constantes se debe hacer mediante el
llamado al tipo seguido de un punto y el nombre de la constante.

Cargo.Mensajero // Se refiere al valor numrico 2

En la tarea de escribir un programa resulta muy importante el uso de estos tipos por
que facilitan al programador hacer referencia a las constantes sin tener que memorizar
la correspondencia entre su nombre y el valor numrico. En los entornos de desarrollo
integrado que cuentan con herramientas asistentes de generacin de cdigo,
IntelliSense, resulta bastante prctico, ya que con el nombre del tipo seguido del punto
se muestra automticamente los nombres de las constantes.

Literales
Un literal es la forma escrita que tiene el lenguaje C# para crear una constante. Un
literal puede ser un nmero entero, un real, un valor booleano, un carcter, una cadena
de texto, una fecha y hora, o un valor null.
Sistema IntelliSense utilizado
por entornos de programacin
como Sharpdevelop y
VisualStudio .NET
24 24 24 24
C# permite bsicamente especificar un literal entero en base 10 y 16. Por ejemplo, para
codificar el decimal 105 en base diez basta con escribir el valor tal cual, 105; para
codificar el valor hexadecimal 200, se debe escribir 0x200.
Un literal real se codifica formado por una parte entera y una parte decimal, tal como
12.35.
Un literal de un solo carcter se codifica escribindolo entre comillas simples, como

'a' // Carcter a
'\n' // Retorno de carro ms avance de lnea

Un literal de cadena de caracteres es una secuencia de caracteres encerrados entre
comillas dobles. Estas cadenas, inmediatamente se crean, son asociadas con un objeto
del tipo System.String.
Los literales del tipo fecha y hora son asociados a un objeto del tipo DateTime. Estos
literales estn formados por una fecha y una hora. Una variable de este tipo bien
podra cargarse de la siguiente forma:

DateTime fecha = new System.DateTime(2009, 02, 15)

Identificadores
Un identificador es el nombre que se la da a un tipo, un literal, una variable, una clase,
una interface, un espacio de nombres y las sentencias de un programa. Los
identificadores deben iniciar por un carcter alfabtico, seguido de una cadena de
letras, nmeros o el carcter de subrayado. En C# se admiten identificadores formados
hasta por 1023 caracteres.
La documentacin de .NET sugiere una serie de reglas para nombrar a los
identificadores, que si bien no son de estricto cumplimiento, es importante tenerlas en
cuenta para generar cdigo estndar y fcilmente comprensible a otros programadores
y de esta manera facilitar el trabajo en equipo.
Para identificadores de variables se sugiere utilizar minsculas cuando su alcance sea
local, es decir que se defina para un determinado bloque de cdigo. Se sugiere utilizar
palabras simples, o palabras compuestas, iniciando cada palabra en mayscula cuando
su alcance sea global, entendido este como una definicin que permite visualizarlos a
nivel pblico
1
.

int numero // una variable local
int NumeroPersonas // una variable pblica

Los parmetros deben iniciar con minscula y usar maysculas intermedias para
separar las palabras compuestas, tal como,

codigoEmpleado // un parmetro de alguna funcin

En lo posible se recomienda utilizar identificadores significativos, es decir que por si
solos resulte fcil de interpretar su finalidad y esencia. Por ejemplo, es fcil hacerse
una idea a simple vista para que sirve un identificador como NombreAutor, que si se
utiliza un identificador como na.

1
En programacin orientada a objetos no es admisible, y en C# no es posible, que se utilicen variables
globales como aquellas que se utilizan en programacin estructurada. Toda variable debe hacer parte de
alguna clase.

25 25 25 25
Variables
Una variable es la unidad bsica que utiliza un programa para almacenar un dato. Las
variables en esencia son secciones de memoria que el programa asigna para colocar los
valores que se requieran para su correcto funcionamiento.
Cualquier variable se declara, a lo mnimo, mediante dos elementos bsicos: un tipo y
un identificador. En la siguiente forma se muestra como debe manejarse una
declaracin de una variable cualquiera en C#:

tipo identificador;

Por ejemplo, para establecer una variable que se encargue de almacenar valores enteros
y se identifique como numero, se utiliza la siguiente instruccin:

int numero;

El lenguaje C# admite la declaracin de varias variables del mismo tipo en una sola
instruccin, incluso inicindolas con algn valor. Por ejemplo, la instruccin

double valorIVA, precio = 1000;

declara dos variable de tipo double y al mismo tiempo a la variable precio, le asigna un
valor inicial igual a 1000.
Algunos lenguajes como C++, admiten declarar variables por fuera de las clases, y
estas se denominan variables globales, pero en C# esto no es vlido. Para este lenguaje
todo debe hacer parte de alguna clase y los datos deben obtenerse a travs de las
variables que estas clases y sus objetos pongan a disposicin del programa.
Se pueden identificar tres lugares o espacios bsicos donde puede ser declarada una
variable y de ello depende su alcance o posibilidad de ser leda. Estos espacios,
denominados mbitos de una variable, son:
- A nivel de la clase. Son variables que se declaran por fuera de cualquier
mtodo que compone la clase. En este caso la variable puede ser leda y
utilizada por cualquier elemento de la clase. A este tipo de variables tambin
se les llama campos.
- A nivel de un mtodo. Estas variables se declaran dentro del bloque de cdigo
que compone a un mtodo y estn al alcance de todos los elementos que
trabajan dentro del mismo, pero no pueden ser ledas por fuera del mtodo.
- A nivel de un bloque de cdigo. Son variables que se declaran dentro de
cualquier bloque de cdigo, definido por la apertura y cierre de las llaves. Este
tipo de variables solo son vlidas dentro del bloque donde se declaran y no son
visibles por fuera de l.
El siguiente fragmento de cdigo muestra los diferentes mbitos donde puede
declararse una variable:

public class Curso
{
// Ambito de clase
string nombreCurso;

static void Main()
{
// Ambito a nivel de mtodo
int numero;
26 26 26 26
if (numero > 0)
{
// Ambito a nivel de bloque
string libro;
// Instrucciones...
}
}
}

Las variables definidas a nivel da la clase, que en el .NET Framework comnmente se
les conoce como campos, podran ser declaradas como variables pblica, es decir que
su alcance sea visible hacia afuera de la clase, tanto para ser ledas como para ser
modificadas. Sin embargo, no es recomendable hacer esto por cuanto va en contra del
principio de encapsulamiento que es uno de los pilares clave de la programacin
orientada a objetos. Los campos deben ser declarados como privados, para evitar su
contacto directo con el mundo exterior (es decir permanecen encapsulados) y sus
valores se asignan o leen a travs de mtodos o propiedades definidas en la clase.
Las variables campo de una clase son inicializadas por el compilador C# para cada
objeto que se instancia de la misma: las variables numricas son inicializadas con cero,
los caracteres con \0 y los dems tipos incluyendo las cadenas de texto con un valor
null. En cambio las variables locales, a nivel de mtodo y de bloque de cdigo, no son
inicializadas y por lo tanto es el programador quin debe asignarles un valor antes de
su utilizacin, de lo contrario se puede generar un error en el momento de la ejecucin.

Ejemplo 2.4: Clculos aritmticos

El siguiente ejemplo de programa recibe dos datos numricos y realiza con ellos las
operaciones de suma, resta, multiplicacin, divisin y clculo del residuo entero, y
muestra los resultados en pantalla. Los datos sern ingresados en forma de argumentos
del mtodo Main( );


using System;
public class OperacionesAritmeticas
{
static void Main(string[] numero)
{
int a = 0, b = 0;
int suma = 0, resta = 0;
int producto = 0, division = 0, residuo = 0;
// Conversin de cadena a entero
a = Convert.ToInt32(numero[0]);
b = Convert.ToInt32(numero[1]);
// Realizar las operaciones
suma = a + b;
producto = a * b;
resta = a - b;
division = a / b;
residuo = a % b;
// Mostrar resultados en pantalla
Console.WriteLine("a + b = {0}", suma);
Console.WriteLine("a - b = {0}", resta);
Console.WriteLine("a * b = {0}", producto);
Console.WriteLine("a / b = {0}", division);
Console.WriteLine("a % b = {0}", residuo);
}
}

27 27 27 27
Compile el programa con el nombre de ejecutable Operar.EXE. Para ello debe
utilizarse la opcin /out del compilador. As:

> csc /out:operar.exe ejemplo24.cs

Para ejecutar el programa debe teclear en la lnea de comando el nombre del ejecutable
seguido de dos nmeros enteros separados por un espacio. Por ejemplo, para realizar
las operaciones aritmticas con los nmeros 10 y 3 se debe ejecutar el programa de la
siguiente forma:

> operar 10 3

La salida que se obtiene es la siguiente:

a + b = 13
a - b = 7
a * b = 30
a / b = 3
a % b = 1

Los primeros cuatro operadores son fciles de distinguir para cualquier programador
sin importar el nivel que posea. Todos loe hemos utilizado desde los primeros aos
escolares. El operador mdulo, %, realiza el clculo del residuo de hacer la divisin
entera del nmero a con el nmero b.

Operadores
Los operadores son caracteres especiales que le informan al compilador que se debe
realiza una operacin sobre unos elementos llamados operandos que se encuentran
antes o despus de ellos. Las instrucciones de operacin se indican mediante
operadores y los operandos pueden ser variables, expresiones o literales que
representan valores.
Algunos operadores se aplican sobre un nico operando y se les llama operadores
unarios. De estos algunos se colocan antes del operando y se los denomina operadores
prefijo. Otros se colocan despus del operador y se llaman operadores sufijo. La
mayora de los operadores actan sobre dos operandos y se escriben en medio de ellos,
y se les denomina operadores binarios infijo.
En C# los operadores se pueden considerar clasificados en siete grupos: aritmticos,
relacionales, lgicos, unarios, a nivel de bits, de asignacin y operadores
condicionales.

Operadores aritmticos
Los operadores aritmticos se utilizan para operaciones matemticas, exactamente de
la misma forma que estn definidos en la aritmtica y el lgebra. Los operandos deben
ser de tipo numrico.

Operador Operacin
+ Suma
- Resta
* Multiplicacin
/ Divisin
% Residuo
28 28 28 28
En cualquier caso, los operandos pueden ser enteros o reales. En caso de aplicarse el
operando a dos nmeros de diferente tipo, ambos son convertidos al tipo del operando
que ofrezca mejor precisin. En el caso del residuo, cuando uno de los operandos es un
real, el resultado ser un valor real.

Operadores relacinales
Los operadores relacionales permiten comparar dos operandos. El resultado de la
comparacin es un valor booleano verdadero (true) cuando la relacin se cumple, o
falso (false) cuando no se cumple.

Operador Operacin
< Menor que
> Mayor que
<= Menor o igual que
>= Mayor o igual que
!= Diferente de
== Igual a

Operadores lgicos
Los operadores lgicos son utilizados para operar valores bolanos, que en la mayora
de los casos se obtienen como resultado de la aplicacin de los operadores relacionales.
Los valores devueltos son de tipo booleano.

Operador Operacin
& AND
| OR
! NOT
^ XOR
&& AND en cortocircuito
|| OR en cortocircuito

Las cuatro primeras operaciones corresponden a las operaciones de la Lgica
Matemtica, conjuncin, disyuncin, negacin y disyuncin exclusiva,
respectivamente. El operador AND devuelve verdadero (true) nicamente si ambos
operandos sobre los cuales se aplica son verdaderos; el operador OR devuelve
verdadero (true) cuando al menos uno de los dos operandos es verdadero; el operador
NOT, es unario, y devuelve el valor booleano contrario al que posea el operando; el
operador XOR, devuelve verdadero nicamente cuando se aplica a dos operandos de
valores opuestos, uno verdadero (true) y el otro falso (false).
Los operadores en cortocircuito empiezan evaluando el primer operando, y la
evaluacin del segundo depende del valor booleano obtenido en este. El operador AND
en cortocircuito, evala el segundo operando nicamente si el primero devuelve un
valor verdadero. En cambio el operador OR en cortocircuito, cuando el primer
operando es verdadero, deja de evaluar el segundo operando.

Operadores unarios
Estos operadores se encargan de actuar sobre un nico valor numrico. Su trabajo,
bsicamente consiste en modificar los bits que componen a dicho valor.
A B AND
V V V
V F F
F V F
F F F
A NOT
V F
F V
A B OR
V V V
V F V
F V V
F F F
A B XOR
V V F
V F V
F V V
F F F
A B &&
V V V
V F F
F ? F
F ? F
A B ||
V ? V
V ? V
F V V
F F F
Tablas de verdad para
los operadores lgicos

29 29 29 29

Operador Operacin
~ Complemento a 1
- Signo menos

El complemento a 1, cuyo carcter corresponde al Unicode 126, se encarga de cambiar
ceros por unos y unos por ceros, en la cadena de bits que conforman el valor numrico.
El operando debe ser de tipo int, uint, long o ulong.
El signo menos, al igual que en las matemticas, cambia el signo al operando. Esto se
logra, calculando el complemento a 2 sobre los bits que conforman el valor numrico.

Operadores a nivel de bits
Los operadores a nivel de bits actan sobre las cadenas de bits que conforman a un
valor entero.

Operador Operacin
& Operacin AND a nivel de bits
| Operacin OR a nivel de bits
^ Operacin XOR a nivel de bits
<< Desplazamiento a la izquierda
>>
Desplazamiento a la derecha

Operadores de asignacin
Un operador de asignacin se encarga de leer un valor, que puede encontrarse
representado por un literal, como resultado de una operacin o en incluido en algn
elemento de programacin y colocarlo en memoria. En la prctica, la seccin de
memoria puede ser una variable o constante explcitamente identificada

Operador Operacin
++ Incremento
-- Decremento
= Asignacin simple
*= Multiplicacin ms asignacin
/= Divisin ms asignacin
%= Residuo ms asignacin
+= Suma ms asignacin
-= Resta ms asignacin
<<= Desplazamiento a la izquierda ms asignacin
>>= Desplazamiento a la derecha ms asignacin
&= Operacin AND sobre bits ms asignacin
|= Operacin OR sobre bits ms asignacin
^= Operacin XOR sobre bits ms asignacin

A B &
1 1 1
1 0 0
0 1 0
0 0 0
A B |
1 1 1
1 0 1
0 1 1
0 0 0
A B ^
1 1 0
1 0 1
0 1 1
0 0 0
Operaciones boolenas
a nivel de bits
30 30 30 30

Operador condicional
El operador condicional, que se representa mediante un signo de interrogacin y el
carcter dos puntos, trabaja sobre tres operadores y por esta razn se lo denomina
operador ternario. Las expresiones sobre las que acta este operador, generalmente
tienen la forma,

variable = Operando1 ? Operando2 : Operando3

El Operando1 debe ser obligatoriamente una expresin que retorna un valor booleano,
mientras que los otros operandos pueden ser de cualquier tipo. Si Operando1 es
verdadero (true) entonces variable recibe el valor del Operando2; en cambio si
Operando1 es falso (false) entonces variable recibe el valor de Operando3.

Precedencia de operadores
En una expresin existe un orden, o precedencia de los operadores, que indica cual
operacin se realiza antes que otra. Este manejo en la mayora de lenguajes de
programacin se realiza en forma similar a como lo hacen las matemticas. En una
operacin como,

2 * 5 + 10

es importante saber que operacin, entre la multiplicacin y la suma, se realizar
primero, para de acuerdo a eso prever el resultado que se obtendr en el procesamiento
de la expresin. Al observar este sencillo ejemplo, nos damos cuenta que si se realiza
primero la multiplicacin, 2 * 5, se obtiene como resultado final, 20; pero si se realiza
primero la suma, 5 + 10, el resultado final es 30. Esta ambigedad se ha resuelto tanto
en matemticas, como en programacin de computadores, dando un orden bien
definido a los operadores y a los smbolos de agrupacin, como los parntesis.
En la siguiente tabla se muestran las operaciones en C#, de acuerdo al orden de
precedencia, las de ms alta precedencia hasta las de ms baja precedencia,
entendindose como alta precedencia aquellas que se aplican primero.

La ms alta precedencia
() [] .
- ~ ! ++ --
* / %
+ -
<< >>
< <= > >=
== !=
&
^
|
&&
||
?:
= += -= &= |=
La ms baja precedencia

Retomando nuestro ejemplo, y basados en la anterior tabla, vemos que la
multiplicacin tiene mayor precedencia que la suma, por lo tanto se aplica primero. En
definitiva el resultado de la expresin es,


31 31 31 31
2 * 5 + 10 = 10 + 10 = 20

Una buena tcnica, para evitar confusiones, cuando no se tenga muy claro el orden de
precedencia de un grupo de operadores, es utilizar los parntesis. Una expresin entre
parntesis siempre se evala primero. Los parntesis tienen mayor prioridad y son
evaluados desde el ms interno hasta el ms externo.

Sobrecarga de operadores
La sobrecarga de operadores hace referencia a la posibilidad que tiene un operador de
actuar y producir un resultado de acuerdo al tipo de datos sobre los cuales se aplique.
Por ejemplo, si se aplica el operador + a los literales numricos 5 y 6, se procesar
como una suma, en este caso 5 + 6 = 11. En consecuencia el operador + acta como un
operador aritmtico que realiza la suma de los dos nmeros. Pero, si este mismo
operador se aplica a dos cadenas de texto, Curso + C Sharp , el operador realiza la
operacin de concatenacin (unin de cadenas), dando como resultado la cadena
CursoC Sharp. Vemos que el operador acta de acuerdo al tipo de datos que se
aplique, numricos o cadenas. Entonces se dice que el operador + esta sobrecargado.
Lo realmente importante es que el programador puede sobrecargar la gran mayora de
operadores definidos en C#, permitiendo que estos se ajusten a los tipos de datos que
se estn utilizando y de esta manera ampliar su funcionalidad. Sin embargo, aunque la
sobrecarga es un proceso que solo depende de la creatividad del programador, no se
debe abusar de esta capacidad del lenguaje de programacin y se recomienda usarla
solo en los casos estrictamente necesarios y en forma conveniente. No est bien
sobrecargar el operador + para que con algn tipo de datos realice una operacin
similar a la resta, ya que esto le hace perder claridad y coherencia al cdigo.

Control de flujo
Uno de los logros ms importantes en los aos 60s, desde la aparicin de los lenguajes
de programacin de alto nivel, fue el hecho de haber reconocido que cualquier
algoritmo, sin importar su complejidad poda ser construido con la combinacin de tres
estructuras de control de flujo estandarizadas: secuencial, seleccin y repetitiva, ms
una cuarta estructura denominada de salto o bifurcacin.
Los programas que hemos realizado hasta el momento, se han construido utilizando
nicamente la estructura secuencial. Las instrucciones se ejecutan en estricto orden, de
izquierda a derecha y de arriba hacia abajo, sin obviar ninguna.
Las sentencias de seleccin en C# son if y switch; las de repeticin, for, while,
dowhile y foreach; las sentencias de salto incluyen break, continue y return.

Sentencia if
La construccin if, en su forma simple provoca que la ejecucin de un conjunto de
instrucciones se realice siempre y cuando se cumpla una condicin.
if (condicin)
instrucciones;

La condicin es una expresin que devuelve un valor booleano (true o false). Si esta
condicin es verdadera, genera el valor true, entonces se ejecuta el bloque de
instrucciones. En caso de que la instruccin sea falsa, retorna el valor false, la
ejecucin salta a la lnea de cdigo que se encuentra inmediatamente despus del
bloque de instrucciones.
32 32 32 32
Pero adems, la sentencia if posee la forma mltiple conocida generalmente como
ifelse, la cual permite ejecutar un bloque de instrucciones para el caso en que se
cumpla la condicin y otro bloque para el caso en que esta no se cumpla. Su sintaxis
es la siguiente:
if (condicin)
instrucciones1;
else
instrucciones2;

En este caso se evala inicialmente la condicin y su el valor devuelto es verdadero
(true), se ejecuta el bloque de instrucciones 1 y si no es as, se ejecuta el bloque de
instrucciones 2. En cualquier caso la ejecucin del programa contina en la lnea de
cdigo que se encuentra despus del bloque de instrucciones 2.

Ejemplo 2.5: Controlar la divisin por cero

En los ejemplos que se han realizado anteriormente, relacionados con operaciones
matemticas, no se tuvo en cuenta que para algunas entradas de valores el programa
poda fallar. Esta situacin es la que se presenta en el programa que hace la divisin de
nmeros, cuando el divisor (nmero que divide) es igual a cero, el programa falla por
que esta operacin no est definida ni para las matemticas ni para el computador. En
el siguiente ejemplo vamos a programar la divisin, controlando que se realice
nicamente para aquellos divisores diferentes de cero.


using System;
public class ControlDivision
{
static void Main()
{
double dividendo, divisor, cociente = 0;
string numero1, numero2;
// Lectura de las cadenas de entrada
Console.Write("\nDividendo = ");
numero1 = Console.ReadLine();
Console.Write("Divisor = ");
numero2 = Console.ReadLine();
// Conversin de cadena a tipo numrico
dividendo = Convert.ToDouble(numero1);
divisor = Convert.ToDouble(numero2);
// Si el divisor es diferente de cero...
if (divisor != 0)
{
cociente = dividendo / divisor;
Console.WriteLine("Cociente = {0} ", cociente);
}
else
Console.WriteLine("La divisin por cero no existe...");

Console.WriteLine("\nPrograma finalizado...");
}
}

La estructura if que se utiliza en este programa se encarga de controlar el valor del
divisor. Si la condicin, el divisor es diferente de cero, se cumple, entonces se realiza
la operacin de divisin y se muestra el resultado en pantalla, pero en caso de que no

33 33 33 33
se cumpla la condicin, es decir que el divisor sea igual a cero, entonces se muestra en
pantalla un mensaje indicando que la divisin por cero no existe.
Observe que, en la estructura if, el primer bloque de instrucciones se ha colocado
entre llaves, mientras que en el segundo bloque, correspondiente a else, no ha sido
necesario utilizarlas. Los bloques se deben colocar, obligatoriamente, entre llaves
cuando estn formados por ms de una instruccin, en caso contrario se pueden obviar
estos smbolos. Cuando no se escriben las llaves, el compilador considera que el
bloque correspondiente est formado por una sola instruccin y como tal se ejecuta.
La instruccin que se encuentra inmediatamente despus de la estructura if es,

Console.WriteLine("La divisin por cero no existe...");

y es en este punto donde contina la ejecucin del programa.

Sentencia switch
La estructura switch permite seleccionar una de varias opciones, en funcin del valor
obtenido en una expresin que se analiza inicialmente. Su estructura general en C#
tienen el siguiente formato:

switch (expresin)
{
case valor1:
instrucciones1;
break;
case valor2:
instrucciones2;
break;
.
.
.
[default:]
[instruccionespordefecto;]
}

Donde la expresin que se evala puede retornar un tipo entero, enumerado o cadena
de texto. Los valores de cada uno de los casos, case, deben ser del mismo tipo que la
expresin o de un tipo que pueda ser convertido implcitamente a ese tipo. Cada case
va seguido de un posible valor que pueda tomar la expresin, y al final el carcter dos
puntos ( : ). No es necesario que las instrucciones que hacen parte de un case se
encierren con llaves. En cada case, incluida la opcin por defecto, default, debe
incluirse un break, que tiene como finalidad sacar la ejecucin del programa fuera de
al estructura switch.
La estructura switch se encarga de determinar el valor que tiene expresin y de acuerdo
a eso manda la ejecucin a uno de los case que la componen. Si ningn case y su valor
respectivo es igual al valor de la expresin, entonces se ejecutan las instrucciones por
defecto, incluidas bajo default. Esta ltima es opcional, y bien puede no incluirse, en
cuyo caso, el programa de no encontrar ningn case que cumpla con el valor de la
expresin continua su ejecucin inmediatamente despus del cierre de la estructura.
Cuando se desee ejecutar un mismo grupo de instrucciones para varios casos, se
pueden escribir varios case, seguidos unos de otros, siempre y cuando entre ellos no se
coloque una instruccin. Por ejemplo la siguiente estructura case ejecuta las mismas
acciones para los casos en que la variable numero sea igual a 1, 2 y 3:

34 34 34 34
switch (numero)
{
case 1:
case 2:
case 3:
instrucciones;
break;
.
.
.
}

Ejemplo 2.6: Das de la semana

En este programa el usuario debe ingresar un nmero comprendido entre 1 y 7, para
que el sistema le devuelva el nombre del da de la semana que le corresponde. En caso
de que se ingrese un valor diferente el programa deber mostrar un mensaje
informando que ese da no existe.


using System;
public class DiasSemana
{
static void Main()
{
string numeroDia;
string nombreDia;
// Lectura de datos
Console.Write("Da nmero: ");
numeroDia = Console.ReadLine();
// Seleccionar el nombre del da acuerdo al nmero
switch (numeroDia)
{
case "1":
nombreDia = "LUNES";
break;
case "2":
nombreDia = "MARTES";
break;
case "3":
nombreDia = "MIERCOLES";
break;
case "4":
nombreDia = "JUEVES";
break;
case "5":
nombreDia = "VIERNES";
break;
case "6":
nombreDia = "SABADO";
break;
case "7":
nombreDia = "DOMINGO";
break;
default:
nombreDia = "(Este da no existe...)";
break;
}
// Escribir en pantalla el nombre del da
Console.WriteLine("Nombre del da: {0}", nombreDia);
}
}

35 35 35 35
En este programa la estructura switch se encarga de evaluar el valor de la variable
numeroDia y de acuerdo a eso selecciona el caso que le corresponde. De esta manera,
siempre y cuando el valor se encuentre entre 1 y 7, encontrar un nombre apropiado
para ese da. No olvidemos que el mtodo ReadLine de la clase Console nicamente
lee cadenas de texto, por lo cual fue necesario definir la variable numeroDia del tipo
string.

Ejemplo 2.7: Nmeros pares e impares

En el siguiente ejemplo se muestra como utilizar switch para procesar mltiples casos,
los cuales tienen la misma salida. El usurario debe ingresar un nmero entre 1 y 9, para
que el sistema determine si es par o impar. Son pares los nmeros 2, 4 , 6 y 8, y se sabe
que la salida en este programa debe ser la misma para todos ellos, por lo tanto, se
programan varios casos con una nica posibilidad de salida.


using System;
public class ParImpar
{
static void Main()
{
Console.Write("Ingrese un nmero entero [1 a 9]: ");
string numero = Console.ReadLine();
switch (numero)
{
case "1": case "3": case "5": case "7": case "9":
Console.WriteLine("{0} es un nmero impar", numero);
break;
case "2": case "4": case "6": case "8":
Console.WriteLine("{0} es un nmero par", numero);
break;
default:
Console.WriteLine("{0} est fuera de rango", numero);
break;
}
}
}

La forma como se han escrito los casos (case), uno en seguida de otro, solo es cuestin
de estilo, si se quiere pueden escribirse cada uno en diferente lnea.

Sentencia while
La estructura repetitiva while (en espaol mientras) repite un conjunto de instrucciones
mientras se cumpla una condicin dada.

while (condicin)
{
Instrucciones;
}

La condicin es una expresin que devuelve un valor booleano. La repeticin se
produce siempre y cuando el valor devuelto sea verdadero (true). En el instante en que
el valor devuelto sea falso (false), la ejecucin sale del ciclo repetitivo y contina en la
siguiente lnea despus del cierre del bloque de cdigo correspondiente a la estructura.
Cuando en el cuerpo de la estructura while solo existe una instruccin, puede escribirse
sin necesidad de utilizar las llaves, e incluso en una sola lnea.
36 36 36 36
while (condicin) instruccin;

Una caracterstica bsica de esta estructura, que se debe tener en cuenta, es que antes
de iniciar la ejecucin, por primera vez, de las instrucciones, se revisa el cumplimiento
de la condicin. Si esta no se cumple, nunca se ejecutar la repeticin de las
instrucciones.
Supongamos el siguiente fragmento de cdigo, donde inicialmente se asigna el valor 2
a la variable i,

i = 2;
while (i < 1)
Console.WriteLine("Nmero = {0}", i);

En este caso, la condicin exige que el valor de i sea menor que 1, pero antes esta
variable a asumido el valor 2, por lo cual la condicin nunca se cumple y en
consecuencia no se ejecuta ni una sola vez la lnea del cuerpo de while,
Console.WriteLine("Nmero = {0}", i);
Tambin puede suceder que la condicin se cumpla siempre y en tal situacin la
ejecucin entra en una repeticin indefinida, que nunca termina. Si esta situacin se
produce por error de programacin, y no existe una forma de control establecida en el
programa, este no podr salir del ciclo y el usuario deber acudir a alguna forma de
terminacin forzada.

Ejemplo 2.8: Sumatoria de enteros positivos

Este ejemplo nos permite tener un programa que sume todos los nmeros
comprendidos entre 1 y cualquier valor ingresado por el usuario utilizando la estructura
repetitiva while.


using System;
public class Sumatoria
{
static void Main(string[] numero)
{
// Convierte a entero el texto ingresado, como argumento
// por el usuario, y lo asigna a la variable numeroFinal
int numeroFinal = Convert.ToInt32(numero[0]);
int i = 1, suma = 0;

// Repetir mientras i sea menor que numeroFinal...
while (i <= numeroFinal)
{
suma = suma + i;
i++;
}
// Mostrar el resultado de la suma
Console.WriteLine("Sumatoria = {0}", suma);
}
}

Compile el programa con la sentencia,

> csc /out:sumarhasta.exe ejemplo28.cs


37 37 37 37
Para ejecutarlo, recuerde, debe llamar el nombre del programa, seguido de un
argumento numrico, por ejemplo as:

> sumarhasta 500

El programa sumarhasta realiza la suma entre 1 y cualquier valor que ingrese como
argumento el usuario, repitiendo la suma acumulativa,

suma = suma + i

En esta expresin, incluso con poco sentido matemtico, el sistema realiza la operacin
indicada en la derecha del signo igual, =, y lo almacena en la misma variable
sustituyendo cualquier valor anterior.
La operacin i++ se encarga de incrementar el valor de i en 1 cada vez que se ejecute
esta instruccin, y el resultado lo almacena en la misma variable i. en el momento que
el valor de i supere al valor de la variable numeroFinal, deja de ser verdadera la
condicin y se da por terminado el ciclo, pasando a mostrar en pantalla el ltimo valor
acumulado en la variable suma.
Puede probar a ingresar como argumento, en la ejecucin, cualquier valor negativo, o
incluso el cero, y el programa no realizar ninguna operacin, devolviendo siempre 0.
Esto ocurre por que bajo estas condiciones jams se realiza la suma acumulativa.

Sentencia dowhile
La sentencia do while ejecuta un conjunto de instrucciones una o varias veces. Esta
estructura de control, primero ejecuta el bloque de instrucciones y al final comprueba
si se cumple la condicin que le permite repetir la ejecucin. Su estructura bsica es la
siguiente:

do
{
instrucciones;
}
while (condicin);

En esta estructura de control las instrucciones se ejecutan al menos una vez, antes de
que se verifique la condicin. Esta es la diferencia sustancial con la estructura while,
quien antes de realizar cualquier ejecucin, verifica el cumplimiento de la condicin.
Una vez realizada la primera ejecucin de las instrucciones, se comprueba que la
condicin, que corresponde a una expresin booleana, devuelva un valor verdadero
(true) para continuar con el ciclo repetitivo. En caso que la condicin devuelva un
valor falso (false) se da por terminado el ciclo y se continua la ejecucin en la
instruccin que sigue al cierre de esta estructura de control.

Ejemplo 2.9 Validacin de una contrasea de paso

Las contraseas son cadenas de caracteres alfanumricos que deben ser tecleadas por el
usuario de un programa para permitirle ingresar o utilizar algn componente de la
aplicacin. El programa se encarga de leer la cadena de texto ingresada por el usuario y
luego compararla con una cadena preestablecida y que se encuentra almacenada en
algn lugar del programa. Si la cadena ingresada coincide con esta ltima se deja
continuar con la ejecucin del programa, en caso contrario, generalmente, se vuelve a
pedir la contrasea. El siguiente es un programa que valida una contrasea utilizando
la sentencia de control do while.

38 38 38 38


using System;
public class Contrasena
{
static void Main()
{
string contrasena = "tangua";
string cadena = "";
// Hacer lectura de cadena mientras....
do
{
Console.Write("Ingrese la contrasea: ");
cadena = Console.ReadLine();
cadena = cadena.ToLower() // convierte la cadena a minsculas
} while (cadena != contrasena);
// La contrasea fue correcta, mostrar un mensaje
Console.WriteLine("Contrasea correcta... Bienvenido");
}
}

Al ejecutar este programa solicita al usuario escribir una contrasea. Si el usuario
escribe una palabra incorrecta, diferente a tangua, el programa volver a pedir la
contrasea, y repetir esta accin hasta que se escriba la contrasea correcta. Es
importante destacar, que como se ha diseado el programa, es necesario pedir el
ingreso de la contrasea antes de verificarla. Si la cadena es diferente a la contrasea
preestablecida se vuelve a repetir el ciclo.
El mtodo ToLower se encarga de convertir la cadena sobre la cual se aplica, a
minsculas. De esta forma el usuario puede ingresar su contrasea en maysculas o
minsculas e igual el programa la aceptar.

Sentencia for
La sentencia for se encarga de repetir un conjunto de instrucciones un nmero definido
de veces. En la teora general de algoritmos esta estructura se utiliza solo para casos en
que se conoce exactamente el nmero de veces que debe repetirse el ciclo, pero en C#
y otros lenguajes similares se ha ampliado este concepto, y su ejecucin depende de
una condicin, semejante a como funciona while. En cualquier caso, una estructura
while puede ser convertida a una estructura for, o viceversa.
La estructura general de for es,

for (inicializacin; condicin; variacin)
{
instrucciones;
}

La seccin de inicializacin es donde se especifican los valores iniciales de la variable
o variables que influyen sobre la condicin. La condicin es una expresin booleana
que controla la repeticin. Si la condicin devuelve verdadero (true), se ejecutan las
instrucciones, de lo contrario se sale del ciclo. La variacin est conformada por
operaciones que se aplican a la variable o variables de control, ya sea incrementando su
valor o disminuyndolo.
En la mayora de los casos los programadores utilizan la versin bsica de esta
estructura, en la cual interviene una sola variable de control. As:


39 39 39 39
for (v = valorinicial; condicin; variacin(v))
{
instrucciones;
}

En este caso v es una variable, generalmente numrica y la condicin depende del
valor que vaya adquiriendo v.
En general la estructura de control for permite incluir en la seccin de inicializacin
ms de una variable, separadas por comas. De igual manera en la seccin de variacin
se pueden incluir una o ms operaciones que modifiquen el valor de las respectivas
variable. As, por ejemplo si se utilizan dos variables, v1 y v2, se tendra una
estructura como la siguiente:

for (v1 = ini1, v2 = ini2; condicin; var(v1), var(v2))
{
instrucciones;
}

Ejemplo 2.10 Cadena de decenas

El programa de este ejemplo va a imprimir una cadena de texto formada por todas las
decenas comprendidas entre 10 y 500. En este caso se necesita una variable cuyo valor
inicie en 10 y se vaya incrementando de 10 en 10 hasta llegar a 500. La estructura for
permite implementar la secuencia de una forma clara y efectiva.


using System;
public class Decenas
{
static void Main()
{
string decenas = "";
// Repetir desde i = 10 hasta 500...
for (int i = 10; i <= 500; i += 10)
{
// Formar una cadena con las decenas
decenas = decenas + i.ToString() + ", ";
}
// Mostrar la cadena de las decenas
Console.WriteLine(decenas);
}
}

El programa imprime en pantalla una cadena de nmeros de 10 en 10. la primera vez
que se ejecuta la sentencia for inicializa la variable i en el valor 10, comprueba que el
valor sea menor que 500 y si esto se cumple ejecuta el bloque de instrucciones, que en
este caso consiste en asignar a la variable decenas el valor de i convertido al tipo
string. En la siguiente ejecucin del ciclo, primero se aplica la variacin a la variable
i, incrementando su valor en 10, luego se comprueba la condicin y se ejecuta la
instruccin que conforma el cuerpo de la estructura. Cuando i asuma el valor 510,
inmediatamente se da por terminada la ejecucin de la estructura de control y se
contina con la instruccin que se encuentra por debajo de esta. En este caso se
imprime la cadena en pantalla.
Se ha utilizado el mtodo, ToString, que est incluido en todos los objetos de C# , en
particular en la clase Int32 que define el tipo int. Este mtodo se encarga de devolver
40 40 40 40
una representacin en cadena del objeto sobre el cual se aplica. En este caso dicha
representacin corresponde al valor que representa el entero.

Ejemplo 2.11 Regla de los simtricos de una secuencia de enteros

Existe un problema clsico de clculo que consiste en determinar la suma desde 0 hasta
cierto valor entero dado (supongamos hasta 1000). Para quienes manejan unos
mnimos conocimientos de Clculo, la solucin a este tipo de problemas puede resultar
trivial, pero para la mayora de las personas, este puede ser un problema de difcil
solucin. Sin embargo existe una propiedad que cumplen todas las secuencias de
nmeros y que aplicndola nos facilitar encontrar la suma tan solo con la ayuda de un
pedazo de papel y un lpiz.
Tomaremos la secuencia de nmeros, la partimos a la mitad, colocando en forma
invertida una de las mitades con respecto a la otra, sumamos los nmeros consecuentes
y ponemos al descubierto la regla matemtica que se oculta detrs de todas estas
sucesiones. Para encontrarla, compile y ejecute este programa y todo quedar al
descubierto.


using System;
public class ReglaSecuencias
{
static void Main()
{
int numero = 0;
int suma = 0;
Console.Write("Escriba un nmero entero: ");
numero = Convert.ToInt32(Console.ReadLine());
// Para j >= i hacer...
for (int i = 0, j = numero; j >= i; i++, j--)
{
suma = i + j;
Console.WriteLine("{0} \t + \t {1} \t = \t {2} ", i, j, suma);
}
}
}

Para empezar ejecute el programa e ingresando un numero impar, por ejemplo el valor
9. Obtenemos una salida como la siguiente:

Escriba un nmero entero: 9
0 + 9 = 9
1 + 8 = 9
2 + 7 = 9
3 + 6 = 9
4 + 5 = 9

Si repetimos la ejecucin ingresando un nmero par, como por ejemplo 12, se obtiene:

Escriba un nmero entero: 12
0 + 12 = 12
1 + 11 = 12
2 + 10 = 12
3 + 9 = 12
4 + 8 = 12
5 + 7 = 12
6 + 6 = 12

41 41 41 41
En ambos casos observamos que la suma de los nmeros simtricos respecto a la
mitad, reproduce el nmero original dado. El lector puede comprobar que para el caso
de los impares, la suma total de la secuencia se obtiene multiplicando el nmero dado
por la cantidad de sumas que se han realizado, la cual es igual al numero ms 1
dividido entre 2 (en este caso 5). Para los nmeros pares se aplica la misma regla, pero
teniendo en cuenta que la cantidad de sumas se obtienen sumando 2 al numero dado, y
restando el valor medio, que siempre se va a repetir la ltima suma (en este caso 6).

Sentencia foreach
La sentencia foreach repite un grupo de instrucciones para cada elemento que hace
parte de una coleccin o de una matriz.

Sentencia break
Una sentencia break se encarga de finalizar la ejecucin de una estructura de control.
Esta sentencia nicamente acta sobre la estructura de control que la contiene
directamente. En el caso de existir un anidamiento, de estructuras repetitivas, como por
ejemplo,

for (int i =0; i < 50; i++)
{
for (int j = 0; j < 10; j++)
{
if (i + j == 50) break;
}
}

break da por terminada la ejecucin del for interno, controlado por la variable j,
dejando que contine la ejecucin del for externo.

Sentencia continue
De la misma manera como puede desearse salir prematuramente de un ciclo repetitivo,
tambin puede desearse continuar dentro del bucle pero sin ejecutar algunas o todas las
instrucciones que hagan falta. La sentencia continue se encarga de evitar que se
ejecuten las instrucciones que hacen parte de una estructura de control y que estn a
continuacin de la sentencia, pero dejando que siga la ejecucin de la estructura.

42 42 42 42

ProgramacionCSharp 02

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

ProgramacionCSharp 02

Hochgeladen von

Copyright:

Verfügbare Formate

Captulo 2

Das könnte Ihnen auch gefallen