c# programación orientada a objetos

Ignacio García, Ismael Caballero

{Ignacio.GRodriguez, Ismael.Caballero}@uclm.es

Universidad de Castilla La Mancha

Sesión 1.4.C#-Programación Orientada a Objetos

Versión 1.0

Curso de Enseñanzas Propias “Lenguaje de Programación C#”

Curso 2008/09

2CEP "Lenguaje de Programación C#"- Curso 08/09

1. POO con C #2. Algunas Clases útiles.3. Gestión de Errores y Excepciones4. El proyecto de Hoy

Sesión 1.4.

Contenidos


1. POO en C#

•Relación entre Estructura y Clase� Una estructura define un valor

• Sin identidad, estado accesible, sin comportamiento añadido

� Una clase define un objeto• Identidad, estado inaccesible, comportamiento añadido

• Los objetos representan mejor el mundo real, mientras que lasestructuras permiten representar simplemente agrupacionesheterogéneas de datos.

Relación entre Estructura y Clase

No puede tener constructoressobrecargados

Puede tenerconstructoressobrecargados

No destructorPuede tener un destructor

No permite la herenciaPuede heredar de otrasclases

Tipo Por ValorTipo Por Referencia

StructStructStructStructClassClassClassClass


• Relación entre Clase y Objeto� Una clase como generalización para el modelado

de las características de una colección de individuos de la realidad

• Clase como plantilla• El papel de las ontologías…

� Un objeto como instancia de una clase• Cogiendo sólo lo que interesa al dominio del

problema…

•Los objetos tienen Estado� Definido por el valor de sus atributos

� El comportamiento permite cambiar el estado de un objeto• Cambio de Estado � Cambio en el valor de al menos un

atributo

1. POO en C#

Relación entre Clase y Objeto


• Creación de Clases y Objetos

1. POO en C#

Creación de Clases y Objetos

Persona YoYoYoYo = newnewnewnew Persona(Persona(Persona(Persona(““““IsmaelIsmaelIsmaelIsmael””””););););Persona YoYoYoYo = newnewnewnew Persona(Persona(Persona(Persona(““““IsmaelIsmaelIsmaelIsmael””””););););

Reserva de Memoria para el

objeto

Inicialización del Estado del

Objeto

public class Persona{

private string nombre;public string Nombre{

get { return nombre; }set { nombre = value; }

}public Persona (string sNombre){

this.Nombre (sNombre);}}}}}}}}


private string nombre;public string Nombre{

get { return nombre; }set { nombre = value; }

}public Persona (string sNombre){

this.Nombre (sNombre);}}}}}}}}

Campo

Propiedad (asociada al

campo)

Método (en este caso sobrecarga de constructor)

Puntero/Referencia a Objeto de la Clase

Persona


1. POO en C#

Creación de Clases y Objetos (II)

• Dos referencias pueden apuntar a un mismo objeto� Dos formas de acceder a un mismo objeto para

lectura/escritura

• Comparación de tipos valor� == and != comparan valores

• Comparación de tipos referencia� == and != comparan las referencias, no los valores

••Objeto con datos sobre IsmaelObjeto con datos sobre Ismael

••

yo

profesor

Un objeto vive vive vive vive mientras tengaalgun referencia apuntándole


• Sobre los Campos (“Atributos”)� Normales / regulares o “Variables”

• Pueden almacenar referencias a un objeto, a una estructurao a una matriz de clases o estructuras

� Constantes• Es un miembro de adtos que es evaluado en tiempo de

compilación y es implícitamente estático– e.g. Math.PI

– public const string version = “1.0.0”;

� Sólo-Lectura• Son similares a las constantes, pero son inicializadas en

tiempo de ejecución en su declaración o en un constructor, y ya su valor no cambia durante toda la ejecución del programa.

• Pueden ser de clase o de instancia– public readonly string s1;

1. POO en C#

Creación de Clases y Objetos (III)


• Sobre Los Métodos� Tipos

• Constructores / Destructores– Inicializan el estado de un objeto / Especifican que hay que hacer cuando

ya no se tienen referencias al objeto

• De Acceso a Datos– ~ setXXX/getXXX �� Propiedades en C#

• De Lógica de Dominio– Implementan las operaciones típicas del dominio

� Aspectos Específicos• Se puede sobrecargar y hay que especificar si se pueden/deben

sobre-escribir– Hay que especificar si son virtuales (para definir la existencia un

comportamiento en clases bases) o no virtuales (para especificar cómo se realiza un comportamiento en clases derivadas)

– Los virtuales pueden contener una especificación por defecto, o ninguna y entonces ser abstractos (definidos en una clase abstracta )

– Los no-virtuales no pueden ser abstractos ni sirven para implementar el polimofismo

1. POO en C#

Creación de Clases y Objetos (IV)

Puede ser necesariosobrecargarlos



private string nombre;public int Nombre {

get { return nombre; }set { if (nombre != NULL) nombre = value;

else throw new NombreInvalidoException(); }}

private string apellido1;public string Apellido1 ; {

get { return this.apellido1; }set { this.apellido1= value; }

}

public Persona (string sNombre, string sApellido1){this.Nombre = sNombre;this.Apellido1= sApellido1;

}public Persona (string sNombre): this (sNombre, “”) { }

}


private string nombre;public int Nombre {

get { return nombre; }set { if (nombre != NULL) nombre = value;

else throw new NombreInvalidoException(); }}

private string apellido1;public string Apellido1 ; {

get { return this.apellido1; }set { this.apellido1= value; }

}

public Persona (string sNombre, string sApellido1){this.Nombre = sNombre;this.Apellido1= sApellido1;

}public Persona (string sNombre): this (sNombre, “”) { }

}

1. POO en C#

Creación de Clases y Objetos (V)

Usamos la propiedad y no los campos.


• Imaginemos una obra de teatro…� …personajes ~ clases� …papeles ~ objetos� ...actos ~ métodos� ...obra ~ programa de orientación a objetos� …representación ~ ejecución� …escenario ~ entorno de ejecución

• Idea:� Tiempo de Diseño: Identificar a los

personajes (clases) y establecer un guiónpara que interactúen

1. POO en C#

Metáfora de POO


•Miembros en Java: atributos y métodos•Miembros en C#:

� Campos• Como los atributos en Java. Los campos son instancias de objetos que

se consideran parte de una clase y que normalmente contienen datos de la clase. Por ejemplo, una clase de calendario puede tener un campo con la fecha actual.

� Propiedades• Una implementación de la encapsulación

� Métodos• Los métodos definen las acciones que una clase puede realizar. El

método puede aceptar parámetros que proporcionan datos de entrada y puede devolver datos de salida a través de parámetros.

� Eventos• Los eventos son una manera de proporcionar a otros objetos

notificaciones sobre lo que ocurre, como clics en botones o la realización correcta de un método. Los eventos se definen y desencadenan mediante delegados.

1. POO en C#

Miembros de Clases


� Indizadores• Los indizadores permiten indizar un objeto de una manera

similar a como se hace con las matrices.

� Constructores • Se utilizan para inicializar el estado de un nuevo objeto.

� Destructores • Los destructores son métodos a los que llama el motor de

ejecución cuando el objeto está a punto de quitarse de la memoria. Generalmente se utilizan para asegurarse de que los recursos que se tienen que liberar se controlan apropiadamente.

� Tipos Anidados • Los tipos anidados son tipos declarados dentro de una clase

o estructura. Los tipos anidados se utilizan a menudo para describir objetos únicamente utilizados por los tipos que los contienen.

1. POO en C#

Miembros de Clases


• Los campos de instancia describen información para objetos concretos, mientras que los campos estáticos describen información para todos los objetos de una clase.

• Por defecto los miembros son de instancia� Cada instancia tiene sus propios campos

� Los métodos se aplican sobre los datos de cada instancia

• Los miembros estáticos son por clase� Los métodos estáticos no pueden acceder a los datos de una

instancia, sólo a los campos estáticos

� No se puede usar la palabra reservada this en los métodosestáticos

• Los miembros estáticos son funciones y datos globales� No se deberían utilizar, pues hacen que se pierda el sentido de

la POO en cierto modo

1. POO en C#

Miembros estáticos vs miembros de instancia


1. POO en C#

Acceso a Miembros

Persona YoYoYoYo = newnewnewnew Persona(Persona(Persona(Persona(““““IsmaelIsmaelIsmaelIsmael””””););););

Yo.Apellido1Yo.Apellido1Yo.Apellido1Yo.Apellido1 = = = = ““““CaballeroCaballeroCaballeroCaballero””””;;;;

Yo.Apellido2Yo.Apellido2Yo.Apellido2Yo.Apellido2 ====““““MuMuMuMuññññozozozoz----RejaRejaRejaReja””””;;;;

Yo.CambiarEstadoYo.CambiarEstadoYo.CambiarEstadoYo.CambiarEstado ((((““““DormidoDormidoDormidoDormido””””););););

Persona YoYoYoYo = newnewnewnew Persona(Persona(Persona(Persona(““““IsmaelIsmaelIsmaelIsmael””””););););

Yo.Apellido1Yo.Apellido1Yo.Apellido1Yo.Apellido1 = = = = ““““CaballeroCaballeroCaballeroCaballero””””;;;;

Yo.Apellido2Yo.Apellido2Yo.Apellido2Yo.Apellido2 ====““““MuMuMuMuññññozozozoz----RejaRejaRejaReja””””;;;;

Yo.CambiarEstadoYo.CambiarEstadoYo.CambiarEstadoYo.CambiarEstado ((((““““DormidoDormidoDormidoDormido””””););););

Para poder usar un objeto antes hay que crearlo y asignarlo a una

referencia

NombreReferencia.NombreMiembroNombreReferencia.NombreMiembroNombreReferencia.NombreMiembroNombreReferencia.NombreMiembro


• Pilares de la OO� Encapsulamiento

• Ocultar al resto de las clases el estado de un objeto

– Confiere seguridad

� Herencia• Poder compartir características y comportamiento

comunes enter clases de la misma familia– Confiere posibilidad de clasificar y estructurar

� Polimorfismo• Poder compartir un mismo comportamiento por

clases de distinas famiilas– Confiere la posibilidad de establecer y adherirse a

contratos (generalizar comportamientos)

1. POO en C#

Pilares de POO


•Encapsulamiento� Son un conjunto de mecanismos para evitar que

cualquier otro objeto modifique el estado de un objeto. Sólo un método específico (setXXX) debería tener esta responsabilidad (ni siquiera los constructores, que deberían invocarlos)

• Se consigue tener un único punto de acceso al valor del atributo / campo, con lo que siempre se puedeasegurar dónde encontrar las reglas para mantener la coherencia en el valor del atributo/campo

• Se implementa poniendo los modificadores de accesode tal manera que sean coherentes con los principios de diseño

– Por ejemplo si pongo algo como privado no se puedeheredar

1. POO en C#

Encapsulamiento


•Modificadores de Acceso

A la clase y a los que heredan de ellaProtected

Solo dentro de claseprivate

A las clases y a los que heredan de ella o están en su mismo espacio de nombre

protected internal

A las clases definidas dentro de la claseInternal

Todo el mundopublic

Entonces se permite el acceso al miembro de la clase a

Si el modificador de acceso es

1. POO en C#

Encapsulamiento (II)


•Herencia� Mecanismos de clasificación

•Tipos De Clases� Abstractas

• No puede ser instanciada, porque no tienen sentidopropiamente dicho

• Sirve como base para la herencia• Puede contener métodos con y sin implementación• No puede ser final

� Regulares• Son las clases normales que se definen. Pueden heredar (o

extender) de otras clases y a su vez pueden ser base de heredadas (o ser extendidas)

� Selladas (Sealed) o finales• Son clases que se definen para que no se puedan heredar de

ellas, bien por razones de diseño, bien por seguridad

1. POO en C#

Herencia

public abstract class SerVivo

public sealed class Alumno : public sealed class Alumno : public sealed class Alumno : public sealed class Alumno : PersonaPersonaPersonaPersona

public public public public cccclass lass lass lass PersonaPersonaPersonaPersona : : : : SerVivoSerVivoSerVivoSerVivo


class Persona{

...}class Alumno : Persona {

...}

class Persona{

...}class Alumno : Persona {

...}

1. POO en C#

Herencia (II)

Clase Base

ClaseDerivada

Clase Base

El extends de C#


• Seleccionando qué se hereda� Los miembros heredados con protección están

implícitamente protegidos en la clase derivada� Los miembros de una clase derivada sólo pueden acceder

a sus miembros heredados con protección

• Redefinición de Métodos y propiedades� Con la palabra reservada new creo otra versión del

método heredado, ocultando al heredado

1. POO en C#

Herencia (III)

public class BaseC { public int x; public void Invoke() { }

} public class DerivedC : BaseC{

new int x;new public void Invoke() { }

}

public class BaseC { public int x; public void Invoke() { }

} public class DerivedC : BaseC{

new int x;new public void Invoke() { }

}


•Polimorfismo� Un tipo puede sustituir a su supertipo

• Se pueden tener comportamientos mediante contratos

� Para implementar polimorfismo se escogen los métodos virtuales , que obligan a que en cada clasederivada se tengan que sobre-escribir/reemplazar

1. POO en C#

Polimorfismo

class class class class FiguraFiguraFiguraFigura {{{{public virtual void public virtual void public virtual void public virtual void CalcularAreaCalcularAreaCalcularAreaCalcularArea() { ... }() { ... }() { ... }() { ... }

}}}}class class class class RecuadroRecuadroRecuadroRecuadro : : : : FiguraFiguraFiguraFigura { { { {

public override void public override void public override void public override void CalcularAreaCalcularAreaCalcularAreaCalcularArea() { ... }() { ... }() { ... }() { ... }}}}}class class class class EsferaEsferaEsferaEsfera : : : : FiguraFiguraFiguraFigura { { { {

public override void public override void public override void public override void CalcularAreaCalcularAreaCalcularAreaCalcularArea() { ... }() { ... }() { ... }() { ... }}}}}


• Una interfaz es un conjunto bien definido de métodos queno contiene datos.•Un interfaz define un contrato, una especificación

� Una interface es un tipo

� Incluye métodos, propiedades, indexadores y eventos� Cualquier clase o estructrua que implemente una interfaz

debe dar soporte a todas las partes del contrato

•Los Interfaces no proporcionan implementación� Cuando una clase o una estructura implementa una interfaz

entonces es cuando se debe crear la implementaciónespecífica para dicha clase o estructura

• Los Interfaces dan soporte al polimorfismo� Muchas clases o estructuras pueden implementar una

misma interfaz� Esto no se considera herencia múltiple

1. POO en C#

Polimorfismo: Interfaces


1. POO en C#

Polimorfismo: Interfaces (II)

public interface public interface public interface public interface IDeleteIDeleteIDeleteIDelete {{{{void Delete();void Delete();void Delete();void Delete();

}}}}public class public class public class public class TextBoxTextBoxTextBoxTextBox : : : : IDeleteIDeleteIDeleteIDelete {{{{

public void Delete() { ... }public void Delete() { ... }public void Delete() { ... }public void Delete() { ... }}}}}public class Car : public class Car : public class Car : public class Car : IDeleteIDeleteIDeleteIDelete {{{{

public void Delete() { ... }public void Delete() { ... }public void Delete() { ... }public void Delete() { ... }}}}}

TextBoxTextBoxTextBoxTextBox tbtbtbtb = new = new = new = new TextBoxTextBoxTextBoxTextBox();();();();IDeleteIDeleteIDeleteIDelete iDeliDeliDeliDel = = = = tbtbtbtb;;;;iDel.DeleteiDel.DeleteiDel.DeleteiDel.Delete();();();();

Car c = new Car();Car c = new Car();Car c = new Car();Car c = new Car();iDeliDeliDeliDel = c;= c;= c;= c;iDel.DeleteiDel.DeleteiDel.DeleteiDel.Delete();();();();


1. POO con C #2. Algunas Clases útiles.3. Gestión de Errores y Excepciones4. El proyecto de hoy

Sesión 1.4

Contenidos


•Filosofía de Diseño� Cada Clase debe tener una responsabilidad única� Se escribirán métodos para satisfacer esa

responsabilidad� Se seguirá el principio de “ Máxima Coherencia y

Mínimo Acoplamiento ”

2. Algunas Clases Útiles

Principios de Diseño


•Estructura del Software


Modelo de Tres Capas

VerVerVerVer ejemploejemploejemploejemplo en: en: en: en: http://http://http://http://www.codeproject.com/KB/tips/ModelViewController.aspxwww.codeproject.com/KB/tips/ModelViewController.aspxwww.codeproject.com/KB/tips/ModelViewController.aspxwww.codeproject.com/KB/tips/ModelViewController.aspx


•Espacios de Nombres� La palabra clave namespace se utiliza para declarar

un ámbito. � Este ámbito permite organizar el código y proporciona

una forma de crear tipos globalmente únicos.� Dos formas de usarse:

• Primero, las clases de .NET Framework utilizan los espacios de nombres para organizar clases.

• Segundo, declarar sus propios espacios de nombres permite ayudar a controlar el ámbito de la clase y los nombres de método en proyectos de programación de mayor tamaño.

� Incorporar los que sean accesibles con using.� Se pueden anidar creando estructuras� Se pueden usar alias.


Espacios de Nombres


namespacenamespacenamespacenamespace N1 // N1N1 // N1N1 // N1N1 // N1{{{{

classclassclassclass C1 // N1.C1C1 // N1.C1C1 // N1.C1C1 // N1.C1{{{{

classclassclassclass C2 // N1.C1.C2C2 // N1.C1.C2C2 // N1.C1.C2C2 // N1.C1.C2{{{{}}}}

}}}}namespacenamespacenamespacenamespace N2 // N1.N2N2 // N1.N2N2 // N1.N2N2 // N1.N2{{{{

classclassclassclass C2 // N1.N2.C2C2 // N1.N2.C2C2 // N1.N2.C2C2 // N1.N2.C2{{{{}}}}

}}}}}}}}


Espacios de Nombres (II)

usingusingusingusing N1;N1;N1;N1;namespacenamespacenamespacenamespace N3 {N3 {N3 {N3 {

classclassclassclass D1 {D1 {D1 {D1 {C1 uC1= C1 uC1= C1 uC1= C1 uC1= newnewnewnew C1 ();C1 ();C1 ();C1 ();

}}}}}}}}

UnaUnaUnaUna forma de forma de forma de forma de organizarorganizarorganizarorganizar laslaslaslas clasesclasesclasesclasesdel del del del ModeloModeloModeloModelo de de de de TresTresTresTres

CapasCapasCapasCapas



•Generalidades� Permite interactuar con la consola

• Lectura: Métodos Read, ReadLine– Leen siempre una cadena de caracteres. Si se desea otro tipo de

datos, habrá que hacer la conversión mediante XXX.Parse(), quepuede generar excepciones

• Escritura: Métodos Write, WriteLine– Admite diferentes formatos según la naturaleza de lo que se imprima

La clase System.Console

lunddd07dd

7612,94f7.612,94€c

24 de Enero de 2009D24/01/09d

ResultadoFormatoResultadoFormato


class Sample {

enum Color {Yellow = 1, Blue, Green};static DateTime thisDate = DateTime.Now;

public static void Main() {Console.Clear();

// Format a negative integer or floating-point // number in various ways.

Console.WriteLine("Standard Numeric Format Specifiers ");

Console.WriteLine("(C) Currency: . . . . . . . . {0:C}\n" +"(D) Decimal:. . . . . . . . . {0:D}\n" +"(E) Scientific: . . . . . . . {1:E}\n" +"(F) Fixed point:. . . . . . . {1:F}\n" +"(G) General:. . . . . . . . . {0:G}\n" +" (default):. . . . . . . . {0} (default = 'G')\n" +"(N) Number: . . . . . . . . . {0:N}\n" +"(P) Percent:. . . . . . . . . {1:P}\n" +"(R) Round-trip: . . . . . . . {1:R}\n" +"(X) Hexadecimal:. . . . . . . {0:X}\n",-123, -123.45f);

Console.WriteLine("Standard DateTime Format Specifiers ");

Console.WriteLine("(d) Short date: . . . . . . . {0:d}\n" +"(D) Long date:. . . . . . . . {0:D}\n" +"(t) Short time: . . . . . . . {0:t}\n" +"(T) Long time:. . . . . . . . {0:T}\n" +"(f) Full date/short time: . . {0:f}\n" +"(F) Full date/long time:. . . {0:F}\n" +"(g) General date/short time:. {0:g}\n" +"(G) General date/long time: . {0:G}\n" +" (default):. . . . . . . . {0} (default = 'G')\n" +"(M) Month:. . . . . . . . . . {0:M}\n" +"(R) RFC1123:. . . . . . . . . {0:R}\n" +"(s) Sortable: . . . . . . . . {0:s}\n" +"(u) Universal sortable: . . . {0:u} (invariant)\n" +"(U) Universal full date/time: {0:U}\n" +"(Y) Year: . . . . . . . . . . {0:Y}\n", thisDate);

Console.WriteLine("Standard Enumeration Format Specifiers ");

Console.WriteLine("(G) General:. . . . . . . . . {0:G}\n" +" (default):. . . . . . . . {0} (default = 'G')\n" +"(F) Flags:. . . . . . . . . . {0:F} (flags or integer)\n" +"(D) Decimal number: . . . . . {0:D}\n" +"(X) Hexadecimal:. . . . . . . {0:X}\n", Color.Green);

}}


La clase System.Console (II)


• La clase string� Es un tipo por referencia

• No se pueden hacer comparaciones directas!

� Proporciona los siguientes métodos• bool Contains (string str)

• bool EndsWith (string str)• int IndexOf(Char ch)

• string [ ] Split (params char [] sep): – rompe una cadena en varias partes usando sep como

separador

• ToLower()• ToUpper()

• …


La clase string


• Generalidades� Proporciona muchos métodos estáticos y constantes para

la realización de cálcuos matemáticos• Math.PI• double Abs(double x)

• double Ceiling(double x)

• double Cos(double x)• double Exp(double x)

• double Floor(double x)

• double Log(double x)• double Pow(double x, double y)

• double Sqrt(double x)

• double Tan(double x)


La clase Math


• Generalidades� Todas las estructuras que representan los tipos básicos

del lenguaje tienen un método TryParse que permitetransformar strings en objetos del tipo correspondiente.

� Pero para transformar entre distintos Tipos se usa Convert• int ToInt32 (string sValor)• Int ToString (long value)

• …


La clase Convert


• Uso� Para manejar fechas y horas

• Algunas Propiedades� int Day� int Hour� int Minute� DateTime Now� int Second� int Year

• Algunos Métodos� string ToLongDateString() / ToShortDateString ()� String ToLongTimeString() / ToShortTimeString()� DateTime Parse()� …


La estructura DateTime


• Definición de Clases Genéricas


Clases Genéricas

public class Contenedor<T>{IList<T> list;public Contenedor(){ list= new List<T>(); }

public void Add(params T[] items{foreach (T t in items) list.Add(t);

public void Remove (T item){list.Remove (item);}

public class Contenedor<T>{IList<T> list;public Contenedor(){ list= new List<T>(); }

public void Add(params T[] items{foreach (T t in items) list.Add(t);

public void Remove (T item){list.Remove (item);}

En ocasiones seránecesario restringir

las clases


Libro B1, B2;Contenedor<Libro> MiBiblio;B1= new Libro();B2= new Libro();MiBiblio = new Contenedor<Libro>();MiBiblio.Add(B1);MiBiblio.Add(B2);MiBiblio.Add(“Harry Potter”);

Libro B1, B2;Contenedor<Libro> MiBiblio;B1= new Libro();B2= new Libro();MiBiblio = new Contenedor<Libro>();MiBiblio.Add(B1);MiBiblio.Add(B2);MiBiblio.Add(“Harry Potter”);

Disco D1, D2;Contenedor<Disco> MiDisco;D1= new Disco();D2= new Disco();MiDisco = new Contenedor<Disco>();MiDisco.Add(D1);MiDisco.Add(D2);

Disco D1, D2;Contenedor<Disco> MiDisco;D1= new Disco();D2= new Disco();MiDisco = new Contenedor<Disco>();MiDisco.Add(D1);MiDisco.Add(D2);


Clases Genéricas (II)


• System.Collections.Generics


El espacio System.Collections.Generics

Imagen Tomada de “GuiaGuiaGuiaGuia EstudioEstudioEstudioEstudioC#C#C#C#”””” de R. Corchuelo, 2006


• Interfaz ICollection<T>� Define los miembros comunesde todas las estructuras de

datos que proporciona .NET• Propiedades

– int Count

– bool IsReadOnly

• Métodos– void Add(T obj)

– void Clear ()

– bool Contains (T obj)

– void CopyTo(T[] target, int index)– bool Remove (T obj)

– …


El espacio System.Collections.Generics (II)


• Interfaz IList<T>� Colecciones donde la posición es significativa� Métodos

• int IndexOf(T obj)• void Insert (int index, T obj)• void RemoveAt (int index)• …

• Interfaz IDictionary<T,Q>� Colección de datos identificados por unas claves que

deben ser únicas� Métodos

• Void Add(T key, Q value)• Bool ContainsKey (T key)• Bool Remove(T Key)• …


El espacio System.Collections.Generics (II)


1. POO con C #2. Algunas Clases útiles.3. Gestión de Errores y Excepciones4. El proyecto de hoy

Sesión 1.4.

Contenidos


ExceptionException

SystemExceptionSystemException

OutOfMemoryExceptionOutOfMemoryException

IOExceptionIOException

NullReferenceExceptionNullReferenceException

ApplicationExceptionApplicationException

3. Gestión de Errores y Excepciones

Control de Excepciones


•Control de Excepciones

3. Gestión de Errores y Excepciones

Control de Excepciones

try { try { try { try {

// Código optimista . } catch (} catch (} catch (} catch (System.ExceptionSystem.ExceptionSystem.ExceptionSystem.Exception ex1) { ex1) { ex1) { ex1) { // Codigo para gestionar la ex1} catch (} catch (} catch (} catch (System.ExceptionSystem.ExceptionSystem.ExceptionSystem.Exception ex2) { ex2) { ex2) { ex2) { // Codigo para gestionar la ex2} } } } …………finally { finally { finally { finally {

// // // // Código final aquí

} } } }


Definir Nuevas Excepciones3. Gestión de Errores y Excepciones

public class ValorNoValidoException :::: ExceptionExceptionExceptionException {

public ValorNoValidoException () {}

public ValorNoValidoException (string message) {}

public ValorNoValidoException (string message, System.Exception inner) {}

}


private int nombre;public int Nombre{

get { return nombre; }set {

if (nombre != null) nombre = value; else throw new ValorNoValidoException();

}}

}}}}


private int nombre;public int Nombre{

get { return nombre; }set {

if (nombre != null) nombre = value; else throw new ValorNoValidoException();

}}

}}}}


1. POO con C #2. Algunas Clases útiles.3. Gestión de Errores y Excepciones4. El proyecto de Hoy

Sesión 1.4.

Contenidos


• Proyecto de hoy: Versiones de la “Agenda”� Consiste en la realización de varias versiones de

un programa utilizando características cada vez más avanzadas del Lenguaje C#.

• V.1. Crear un programa que lea los datos referentes persona y los imprima por pantalla

• V.2. Crear una estructura para almacenar los datos de la persona.

• V.3. Crear una clase para almacenar los datos de la persona. El programa debe proporcionar mecanismos basados en arquitecturas de tres capas.

• V.4. Crear una matriz de objetos y proporcionar los mecanismos para la inserción, borrado y actualización de nuevos contactos en la agenda.

• V.5. Usar una clase de tipo colección para gestionar en Memoria la lista de alumnos. Usa Clases genéricas.

4. El proyecto de Hoy

Versiones de un programa

c# programación orientada a objetos

Documents