Sesión 03 - Control y Excepciones

Desarrollo de aplicaciones .NETEduardo Rivera Alva - MCTS.Net ([email protected])

Desarrollo de Aplicaciones

Capítulo 03

Control de Flujo y Excepciones


Agenda

• Repaso sesión anterior.• Control de flujo

– Branching– Branching No-Condicional– Branching Condicional (Control)

• if, else, else if• switch

– Iteración y bucles• do• while• for• foreach

• Excepciones– Introducción– Sentencias try-catch– Sentencias try-catch-finally– Clase System.Exception– Excepciones generadas por el compilador– Jerarquía de las excepciones– Excepciones personalizadas y mejores prácticas

• Que veremos la próxima sesión?


Repaso sesión anterior

• Sintaxis C#

• Depuración básica

• Ver diapositivas previas.

Control de Flujo

Desarrollo de aplicaciones .NET

Eduardo Rivera Alva - MCTS.Net ([email protected])

Referencias

1. Learning C# 2005. Caps. 5 (Branching)

2. Csharp Language Specification

3. MSDN C# Reference (http://msdn2.microsoft.com/en-us/library/618ayhy6(VS.80).aspx)

4. MSDN C# Programming Guide (http://msdn2.microsoft.com/en-

us/library/67ef8sbd(VS.80).aspx)

http://msdn2.microsoft.com/en-us/library/618ayhy6(VS.80).aspx)



http://msdn2.microsoft.com/en-us/library/67ef8sbd(VS.80).aspx)



Branching

• Las sentencias se ejecutan en un orden.

• A veces no se necesita ejecutar todo el código.

• Es necesario dirigir el “curso” de un programa.

• A veces es necesario ejecutar sentencias en base

a condiciones a lo largo del programa.

• Este proceso se denomina “branching”.

• Existen 2 tipos de branching:

– No Condicional (unconditional branching statements)

– Condicional (conditional branching statements)



Branching No Condicional

• La forma simple de branching no

condicional es la llamada a un método.

• El compilador detiene la ejecución y

entrega al control al método llamado

hasta completar su ejecución.

• El compilador continúa con las

sentencias del programa principal (el que

invocó al método).



using System;

class Functions

{

static void Main( )

{

Console.WriteLine( "In Main! Calling SomeMethod( )..." );

SomeMethod( );

Console.WriteLine( "Back in Main( )." );

}

static void SomeMethod( )

{

Console.WriteLine( "Greetings from SomeMethod!" );

}

}

In Main! Calling SomeMethod( )...

Greetings from SomeMethod!

Back in Main( ).

Branching Condicional

• El flujo del programa es controlado en base a la

evaluación de ciertas condiciones.

• Se realiza en tiempo de ejecución.

• Es soportado mediante las sentencias: if, else y

switch.




• If, else, elseif:

– Si se requiere ejecutar múltiples sentencias, se deben

agrupar en bloque {..}



if (x > 10) if (x < 10) if (x < 10) if (x < 10)

HacerAlgo(); { { {

Hacer1(); Hacer1(); Hacer1();

Hacer2(); } }

} else else if (x > 20)

{ {

Hacer2(); Hacer2();

} }

else

{

Hacer3();

}

bool flagCheck = true;

if (flagCheck == true)

{

Console.WriteLine("The flag is set to true.");

}

else

{

Console.WriteLine("The flag is set to false.");

}

if (y > 20)

Console.Write("Statement_1");

else

Console.Write("Statement_2");


• Switch:



int a = 0;

switch(a) {

case 1:{ //CODIGO 1

break;

}

case 2: { //CODIGO 2

break;

}

default:{ //CODIGO DEFAULT

break;

}

}

using System;

class Values

{

static void Main( )

{

String myChoice = "NewLeft";

// switch on the string value of myChoice

switch ( myChoice )

{

case "NewLeft":

Console.WriteLine("The NewLeft members are voting Democratic." );

goto case "Democrat";

case "Democrat":

Console.WriteLine( "You voted Democratic.\n" );

break;

case "CompassionateRepublican": // fall through

case "Republican":

Console.WriteLine( "You voted Republican.\n" );

Console.WriteLine( "Don't you feel compassionate?" );

break;

case "Progressive":

Console.WriteLine( "You voted Progressive.\n" );

break;

default:

Console.WriteLine( "You did not make a valid choice." );

break;

}

Console.WriteLine( "Thank you for voting." );

}

}

Iteración y bucles

• Los bucles se crean usando sentencias de

iteración.

• Las sentencias de iteración permiten ejecutar

sentencias en forma repetida, sujetas a un

criterio de terminación.

• Las sentencias de iteración son: do-while,

for, foreach-in y while.



Iteración y bucles

• do-while (C#)

– Se ejecuta repetidamente hasta que se cumple una condición.

– Se puede salir del bucle con break, goto, return o throw.



using System;

public class TestDoWhile

{

public static void Main ()

{

int x = 0;

do

{

Console.WriteLine(x);

x++;

} while (x < 5);

}

}

Output:

0

1

2

3

4

Iteración y bucles

• for (C#)

– Se ejecuta repetidamente hasta que se cumple una condición.




using System;

class ForLoopTest

{

static void Main()

{

for (int i = 1; i <= 5; i++)

{

Console.WriteLine(i);

}

}

}

Output:

1

2

3

4

5

Iteración y bucles

• while (C#)

– Se ejecuta repetidamente hasta que se la condición sea false.




using System;

class WhileTest

{

static void Main()

{

int n = 1;

while (n < 6)

{

Console.WriteLine("Current value of n is {0}", n);

n++;

}

}

}

Output:

Current value of n is 1





Iteración y bucles

• foreach-in (C#)

– Ejecuta un grupo de sentencias para todos los elementos de un

array o colección.

– Se utiliza mayormente para iterar sobre una colección.

– No debe ser utilizado para para cambiar el contenido de la colección

recorrida.




class ForEachTest

{

static void Main(string[] args)

{

int[] fibarray = new int[] { 0, 1, 2, 3, 5, 8, 13 };

foreach (int i in fibarray)

{

System.Console.WriteLine(i);

}

}

}

Output:

0

1

2

3

5

8

13

Excepciones



Referencias

1. Learning C# 2005. Caps. 16 (Throwing and Catching Exceptions)

2. MSDN C# Reference (http://msdn2.microsoft.com/en-us/library/618ayhy6(VS.80).aspx)

3. MSDN C# Programming Guide (http://msdn2.microsoft.com/en-

us/library/67ef8sbd(VS.80).aspx)

4. Apress Ilustrated C Sharp 2005. Caps 11 (Exceptions)

5. MSDN Design Guidelines for Exceptions (http://msdn2.microsoft.com/en-

us/library/ms229014(VS.80).aspx)

6. MSDN Handling and Throwing Exceptions (http://msdn2.microsoft.com/en-

us/library/5b2yeyab(VS.80).aspx )







http://msdn2.microsoft.com/en-us/library/ms229014(VS.80).aspx)



http://msdn2.microsoft.com/en-us/library/5b2yeyab(VS.80).aspx



Excepciones

• Una excepción es el indicador de un problema: una mala

operación o situación anómala que ocurre durante la

ejecución de un programa.

• Las excepciones deben ser interceptadas y manejadas para

no desestabilizar el programa.

• Todas las excepciones son instancias de System.Exception

o de sus derivadas.

• El CLR provee un número amplio de excepciones

predefinidas: ArgumentNullException, InvalidCastException,

OverflowException, etc.

• Se pueden crear excepciones personalizadas derivando de

System.Exception.



Excepciones

• Manejando las excepciones:

– Las excepciones deben ser atrapadas y controladas para asegurar la

continuidad del programa.

– Si la función en ejecución C() no intercepta la excepción, se le da la

oportunidad a la función B() o función solicitante.

– Si B() no intercepta la excepción, se la da la oportunidad a la función A().

– Si A() no intercepta la excepción, el CLR la intercepta y termina el programa

en forma abrupta.

– Las excepciones se manejan con las sentencias: try - catch - finally.



Excepciones

• Esquema try-catch-finally:



Excepciones

• Sentencias try-catch:

– Encerrar cualquier código sospechoso de generar una excepción

dentro de un bloque try.

– Atrapar la excepción lanzada dentro del bloque catch.

– Consisten en un bloque try seguida de una o más cláusulas catch.

– No se pueden utilizar variables que han sido declaradas dentro de

un bloque try, fuera del mismo.



int SafeDivision(int x, int y)

{

try

{

return (x / y);

}

catch (System.DivideByZeroException dbz)

{

System.Console.WriteLine("Division by zero attempted!");

return 0;

}

}

Excepciones

• Cláusula catch/esquema:



Excepciones

• Cláusula catch:

– La cláusula catch puede ser utilizada sin argumentos, la cual

captura cualquier tipo de excepción.



public void Func2( )

{

Console.WriteLine( "Enter Func2..." );

try

{

Console.WriteLine( "Entering try block..." );

throw new ApplicationException( );

// this code never executes because of the exception

Console.WriteLine( "Exiting try block..." );

}

catch

{

Console.WriteLine( "Exception caught and handled!" );

}

Console.WriteLine( "Exit Func2..." );

}

Excepciones

• Cláusula catch:– Pueden existir múltiples cláusulas catch, las cuales pueden tomar un

argumento de tipo objeto, derivado de System.Exception.



static void Main()

{

try

{

string s = null;

ProcessString(s);

}

// Most specific:

catch (ArgumentNullException e)

{

Console.WriteLine("{0} First exception caught.", e);

}

// Least specific:

catch (Exception e)

{

Console.WriteLine("{0} Second exception caught.", e);

}

}

Excepciones

• Cláusula catch/tipos:



Excepciones

• Sentencia throw:

– Las excepciones se pueden relanzar, para ser

recapturadas por el método solicitante, o capa superior.

– Se puede utilizar el catch sin parámetros para

excepciones no-manejadas por el CLR.



try

{

// try to access a resource

}

catch

{

throw; // re-throw the error}

try

{

// try to access a resource

}

catch (System.UnauthorizedAccessException e)

{

LogError(e); // call a custom error logging procedure

throw e; // re-throw the error

// throw; // also works !!}

Excepciones

• Sentencias try-catch-finally:

– El bloque finally es útil para limpiar y liberar recursos utilizados en el

bloque try. Se puede utilizar para cerrar conexiones a BD, cerrar

archivos, limpiar el buffer, etc.

– Se ejecuta después de la ejecución de los bloques try y catch.

– El bloque finally siempre se ejecuta, independiente del resultado del

bloque try.



public class MainClass

{

static void Main()

{

int i = 123;

string s = "Some string";

object o = s;

try

{

// Invalid conversion; „o‟ contains a string not an int

i = (int)o;

}

finally

{

Console.Write("i = {0}", i);

}

}

}

try

{

// Code to try here.

}

catch (System.Exception ex)

{

// Code to handle exception here.

}

finally

{

// Code to execute after try (and possibly catch) here.

}

Excepciones


– Esquema.



Excepciones


– Ejemplos.



static void CodeWithCleanup()

{

System.IO.FileStream file = null;

System.IO.FileInfo fileInfo = null;

try

{

fileInfo = new System.IO.FileInfo("C:\\file.txt");

file = fileInfo.OpenWrite();

file.WriteByte(0xF);

}

catch(System.Exception e)

{

System.Console.WriteLine(e.Message);

}

finally

{

if (file != null)

{

file.Close();

}

}

}

using System;

public class EHClass

{

static void Main()

{

try

{

Console.WriteLine("Executing the try statement.");

throw new NullReferenceException();

}

catch (NullReferenceException e)

{

Console.WriteLine("{0} Caught exception #1.", e);

}

catch

{

Console.WriteLine("Caught exception #2.");

}

finally

{

Console.WriteLine("Executing finally block.");

}

}

}

Excepciones

• La Clase System.Exception

– Propiedad StackTrace (string / read-only)

• Devuelve una cadena con el nombre de los métodos de la pila.

• Devuelve el número de línea donde se generó la excepción en cada método.

– Propiedad Message (string / read-only)

• Devuelve una cadena explicativa de la razón de la excepción.

– Propiedad HelpLink (string / read-only)

• Se puede establecer para devolver un link con información de ayuda para resolver el

problema.



Excepciones

• Ejemplos de uso de la clase Exception:



public void Run( )

{

try

{

Console.WriteLine( "Open file here" );

double a = 12;

double b = 0;

Console.WriteLine( "{0} / {1} = {2}“, a, b, DoDivide( a, b ) );

Console.WriteLine("This line may or may not print" );

}

// most derived exception type first

catch (DivideByZeroException e )

{

Console.WriteLine(“DivideByZeroException! Msg: {0}“,e.Message );

Console.WriteLine(“HelpLink: {0}", e.HelpLink );

Console.WriteLine(“Here's a stack trace: {0}\n“, e.StackTrace );

}

catch

{

Console.WriteLine(

"Unknown exception caught" );

}

finally

{

Console.WriteLine(

"Close file here." );

}

}

Excepciones

• Excepciones lanzadas por el compilador (CLR)

– Son lanzados cuando una operación básica falla.



Exception Description

ArithmeticExceptionA base class for exceptions that occur during arithmetic operations, such as

DivideByZeroException and OverflowException.

ArrayTypeMismatchExceptionThrown when an array cannot store a given element because the actual type of the element is

incompatible with the actual type of the array.

DivideByZeroException Thrown when an attempt is made to divide an integral value by zero.

IndexOutOfRangeExceptionThrown when an attempt is made to index an array when the index is less than zero or outside

the bounds of the array.

InvalidCastExceptionThrown when an explicit conversion from a base type to an interface or to a derived type fails at

runtime.

NullReferenceException Thrown when you attempt to reference an object whose value is null.

OutOfMemoryExceptionThrown when an attempt to allocate memory using the new operator fails. This indicates that the

memory available to the Common Language Runtime has been exhausted.

OverflowException Thrown when an arithmetic operation in a checked context overflows.

StackOverflowExceptionThrown when the execution stack is exhausted by having too many pending method calls; usually

indicates a very deep or infinite recursion.

TypeInitializationExceptionThrown when a static constructor throws an exception and no compatible catch clause exists to

catch it.

http://msdn2.microsoft.com/en-us/library/system.arithmeticexception(VS.80).aspx

http://msdn2.microsoft.com/en-us/library/system.dividebyzeroexception(VS.80).aspx

http://msdn2.microsoft.com/en-us/library/system.overflowexception(VS.80).aspx

http://msdn2.microsoft.com/en-us/library/system.arraytypemismatchexception(VS.80).aspx

http://msdn2.microsoft.com/en-us/library/system.indexoutofrangeexception(VS.80).aspx

http://msdn2.microsoft.com/en-us/library/system.invalidcastexception(VS.80).aspx

http://msdn2.microsoft.com/en-us/library/system.nullreferenceexception(VS.80).aspx

http://msdn2.microsoft.com/en-us/library/edakx9da(VS.80).aspx

http://msdn2.microsoft.com/en-us/library/system.outofmemoryexception(VS.80).aspx

http://msdn2.microsoft.com/en-us/library/fa0ab757(VS.80).aspx

http://msdn2.microsoft.com/en-us/library/system.stackoverflowexception(VS.80).aspx

http://msdn2.microsoft.com/en-us/library/system.typeinitializationexception(VS.80).aspx

Excepciones

• Jerarquía de System.Exception



Excepciones

• Expansión de la jerarquía



Excepciones

• Excepciones personalizadas:

– No se cumple la expansión de la jerarquía en las mismas

clases base del NET Framework.

– Evitar jerarquías demasiado profundas.

– Derivar de System.Exception o otra excepción base.

– Terminar el nombre de la clase con el prefijo “Exception”.

– Hacer la excepción serializable para asegurar su

funcionamiento a través de las capas de la aplicación y

límites remotos (webservices, remoting).



Excepciones

• Excepciones personalizadas:

– Proveer (por lo menos) los siguientes constructores:

– Evitar poner información de seguridad o sensible en el

método ToString() de la excepción.

– Considerar agregar propiedades a la clase con

información extra o adicional relativa a la excepción.



public class SomeException: Exception, ISerializable {

public SomeException();

public SomeException(string message);

public SomeException(string message, Exception inner);

// this constructor is needed for serialization.

protected SomeException(SerializationInfo info, StreamingContext context);

Que veremos la próxima sesión?

• Arrays y Colecciones



Fin de la sesión

• Dudas, comentarios, sugerencias?

• Comunicarse por email a [email protected]

• Gracias por su atención !!

Sesión 03 - Control y Excepciones

Documents

Transcript of Sesión 03 - Control y Excepciones