miércoles, 13 de febrero de 2013

Lenguaje C# Parte 3 Instrucciones

Lenguaje C# Parte 3

Instrucciones

Una instrucción es una unidad de creación de procedimientos a partir de la cual se construyen todos los
programas de C#. Una instrucción puede declarar una variable o constante local, llamar a un método, crear
un objeto o asignar un valor a una variable, propiedad o campo.
Una serie de instrucciones que aparecen entre llaves forma un bloque de código. El cuerpo de un método es un ejemplo de bloque de código. A menudo, los bloques de código siguen una instrucción de control. Las
variables o constantes declaradas dentro de un bloque de código sólo están disponibles para las
instrucciones dentro del mismo bloque de código.

Las instrucciones de C# a menudo contienen expresiones. Una expresión de C# es un fragmento de código
que contiene un valor literal, un nombre simple o un operador y sus operandos. Las expresiones más
comunes, cuando se evalúan, producen un valor literal, una variable o una propiedad de objeto.
Evalúa como un resultado de valor lógico se asigna a una variable de tipo bool

Instrucciones de selección

Una instrucción de selección hace que el control del programa se transfiera a un determinado punto del
flujo de ejecución dependiendo de si cierta condición es true o no (false/null). Son también conocidas como
instrucciones de bifurcación, ya que determinan un camino definido a seguir en la ejecución del programa.

if-else

La instrucción if selecciona una instrucción para ejecución en base al valor de una expresión lógica.

Para poder evaluar la igualdad de dos operandos se utiliza el operador “==”

También es posible extender la instrucción if de modo que puedan controlarse varias condiciones, mediante la construcción else-if.

switch

La instrucción switch es una instrucción de control que controla múltiples selecciones y enumeraciones.

Si ninguna expresión case coincide con el valor de la instrucción switch, entonces el control se transfiere a las instrucciones que siguen la etiqueta default opcional. Si no existe ninguna etiqueta default, el control se transfiere fuera de la instrucción switch.

Instrucciones de iteración

Las instrucciones de iteración permiten crear bucles. En un bucle, las instrucciones internas se ejecutan un
determinado número de veces, según el criterio de terminación del bucle.

do

La instrucción do ejecuta una instrucción o un bloque de instrucciones entre {} repetidamente hasta que una expresión especificada se evalúe como false.

El Resultado del bloque anterior será una impresión secuencial: 0, 1, 2 … 5.

A diferencia de la instrucción while, un bucle do-while se ejecuta una vez antes de que se evalúe la expresión 
condicional.


for

El bucle for ejecuta una instrucción o un bloque de instrucciones repetidamente hasta que una determinada
expresión se evalúa como false. El bucle for es útil para recorrer en iteración matrices y para procesar
secuencialmente.

La instrucción for ejecuta la instrucción o instrucciones internas repetidamente del siguiente modo:
  • Primero, se evalúa el valor inicial de la variable i.
  • A continuación, mientras el valor de i sea menor o igual que 5, la condición se evalúa como true, se ejecuta la instrucción Console.WriteLine y se vuelve a evaluar i.
  • Cuando i es mayor que 5, la condición se convierte en false y el control se transfiere fuera del bucle.
Todas las expresiones de la instrucción for son opcionales; por ejemplo para crear un bucle infinito:

foreach

La instrucción foreach repite un grupo de instrucciones incluidas en el bucle para cada elemento de una
matriz o de un objeto collection. La instrucción foreach se utiliza para recorrer en iteración una colección de
elementos y obtener la información deseada, pero no se recomienda para cambiar el contenido de la
colección.
Esencialmente lo que se debe especificar en el bucle foreach es una “variable de paso” del tipo que
colecciona la matriz o colección, este elemento tomará la identidad del ítem que se recorre de manera
secuencial en la matriz o acorde al iterador de la colección.


Una de las ventajas que proporciona en bloque foreach, es que no se debe trabajar con una variable de paso 
interna cuando es requerida una conversión explícita para un tipo definido por el usuario al recorrer 

colecciones. Si bien for nos permitiría realizar este recorrido, es necesario definir una variable de paso para 

realizar el casting, acción que es realiza de manera automática en foreach.




while

La instrucción while ejecuta una instrucción o un bloque de instrucciones repetidamente hasta que una
expresión especificada se evalúa como false.


Como la comprobación de la expresión while tiene lugar antes de la ejecución del bucle, las instrucciones 
internas de un bucle while pueden no llegar a ejecutarse.

Instrucciones para el control de excepciones

C# incorpora mecanismos para el tratamiento de las situaciones anómalas, denominadas excepciones, que pueden producirse durante la ejecución de un programa.

Para el manejo de las excepciones, C# nos provee de un bloque try…catch, la clausula throw y el bloque finally.

try .... catch


Este ejemplo muestra un bloque try…catch en acción. Antes del bloque, se declara un arreglo de enteros con
tres elementos, dentro del bloque hay un bucle for el cual poblará el arreglo con números enteros, 
considerando 4 elementos. El bucle for imprime el elemento y posteriormente lo asigna a su posición. 
Todo trabaja bien hasta que se llega a la cuarta iteración del bucle for. Debido a que el arreglo solo puede 
contener tres elementos, se produce una excepción al intentar acceder al cuarto elemento (índice 3). Esto 
genera una excepción, ocasionando que el flujo de control del programa salte al bloque catch.

finally

Una importante consideración es que el bloque finally, se ejecutará si o si, se ha generado una excepción,
por lo tanto debemos ser cautos en su utilización. Por ello se debe tener presente que este bloque es para
garantizar la ejecución de un set de instrucciones, se produzca o no una excepción.

throw

Este nos
permitirá pasar la excepción generada al bloque try…catch padre o a la línea de programa desde donde se 
llamó el método, si es que no podemos o no debemos manejar la excepción en el lugar donde se produce.

Otro uso que podemos dar a la clausula throw, es para enmascarar o cambiar el tipo de excepción. En tal
caso controlamos la excepción original y luego generamos la excepción que deseamos.







________________________________________________________________________

No hay comentarios:

Publicar un comentario