2.

El lenguaje de programacin C#
Integracin de Sistemas
Diseo e implementacin con .NET

Introduccin
Primer lenguaje orientado a componentes en la familia C/C++ Qu es un componente?
No slo clases y mtodos, tambin propiedades y eventos Mdulo independiente (desarrollo y reutilizacin) Granularidad mayor que los objetos
Puede incluir mltiples clases

Independiente del lenguaje Normalmente, el desarrollador y el usuario de un componente son totalmente independientes

Introduccin
En lenguajes "puristas" como Smalltalk o Lisp:
Todo es un objeto Problema: eficiencia reducida

En otros lenguajes como C++ o Java

No existe interaccin entre tipos primitivos (long) y objetos (Long) Se tratan de forma diferente por motivos de rendimiento

Introduccin
En C# todo es un objeto
Todo hereda de System.Object

Es posible declarar un tipo primitivo (long) y trabajar con l de forma eficiente. Adems, es posible asignarlo a un objeto y entonces ser tratado como tal
Incluye mecanismos transparentes de boxing y unboxing Los tipos primitivos slo se tratan como objetos cuando la situacin lo requiere, mientras tanto pueden aplicrseles optimizaciones especficas

El hecho de que todos los tipos del lenguaje deriven de una clase comn, facilita enormemente el diseo de colecciones genricas, que pueden almacenar objetos de cualquier tipo

Hola Mundo
using System; /* Class HelloWorld Description: simple C# example */ class HelloWorld { // entry point public static void Main() { Console.WriteLine("Hello World"); } }

Compilador C#
Ubicacin Compilador C#
C:\windows\Microsoft.NET\Framework\vn.n.nnn\csc.exe

Sintaxis
csc [opciones] fich1.cs [, fich2.cs]

Opciones
/out:ficheroSalida /t:winexe /t:library /r:librera.dll
Por defecto se referencia a mscorlib.dll.

/main:clase

Estructura
Namespaces
Tipos, Namespaces

Declaracin de tipos
Clases, estructuras, interfaces, enumeraciones y delegados

Miembros
Constantes, atributos, mtodos, propiedades, ndices, eventos, operadores, constructores, destructores

Namespaces
Declaracin:
namespace <NombreEspacio> { <Definicin clases> }

Anidacin de namespaces vlida

NmbEspacio1.NmbEspacio2.NmbClase

Referencia a namespaces externos

using

Alias: evitar conflictos entre Namespaces

using <alias> = <NombreCompletoClase>;

Namespaces
using using using using using System; System.Collections.Generic; System.Text; System.Collections; System.IO; using SC = System.Collections; using SIO = System.IO;

static void Main(string[] args) { string username; ArrayList namesCollection;

static void Main(string[] args) { string username; string filename SC.ArrayList namesCollection;

filename = SIO.Path.Combine( ... );

A qu namespace pertenece?

Sistema de Tipos Unificado

Valor
Variables contienen datos Valor nulo no permitido

Referencia
Variables contienen referencias a objetos Valor nulo permitido

int i = 123; string s = "Hello world";

i s

123 "Hello world"

Sistema de Tipos Unificado

Valor
Primitivos Enumeraciones Estructuras int i; enum State { Off, On } struct Point { int x, y; }

Referencia
Raz String Clases Interfaces Arrays Delegados object string class Foo : Bar, IFoo {...} interface IFoo : IBar {...} string[] a = new string[10]; delegate void Empty();

Sistema de Tipos Unificado

Dos tipos de conversiones
Implcitas
Ocurren automticamente xito asegurado Sin prdida de precisin

Explcitas
Requieren un cast Pueden originar errores Precisin puede perderse

Sistema de Tipos Unificado

Dos tipos de conversiones
int x = 123456; long y = x; short z = (short)x; double d = 1.2345678901234; float f = (float)d; long l = (long)d;

// implicit // explicit

// explicit // explicit

Sistema de Tipos Unificado

Cmo se tratan polimrficamente los tipos por valor y por referencia?
Como se convierte de int (tipo valor) a objeto Int32 (tipo referencia)?

Boxing
Slo aplicable a tipos valor

Sistema de Tipos Unificado

Boxing
Reserva espacio Copia valor

Unboxing
Chequea tipo dato Copia valor
int i = 123; object o = i; // boxing int j = (int) o; // unboxing

On the stack i 123 int i=123; o object o=i;

On the heap

On the stack o object o=i;

On the heap (i boxed) int 123

(i boxed) int 123

j 123 int j=(int) o;

Sistema de Tipos Unificado

En ltima instancia todos los tipos derivan de la clase Object Conversiones implcitas desde cualquier tipo al tipo Object
object

Stream

Hashtable

int

double

MemoryStream

FileStream

Tipos predefinidos
C#
Reference Signed Unsigned Character Floating-point Logical object, string sbyte, short, int, long byte, ushort, uint, ulong char float, double, decimal bool

Importante: realmente se trata de alias a tipos proporcionados por el sistema

int es un alias a System.Int32 Vlido: int entero = 100; entero.ToString();

Tipos predefinidos
Tipo SByte Byte Int16 UInt16 Int32 UInt32 Int64 UInt64 Single Double Decimal Boolean Char String Object Descripcin
Bytes con signo Bytes sin signo Enteros cortos con signo Enteros cortos sin signo Enteros normales Enteros normales sin signo Enteros largos Enteros largos sin signo Reales con 7 dgitos Reales de 15-16 dgitos Reales de 28-29 dgitos significativos Valores lgicos Caracteres Unicode Cadenas de caracteres Cualquier objeto

Bits
8 8 16 16 32 32 64 [-128127] [0255]

Rango

Alias sbyte byte short ushort int uint long

[-32.76832.767] [065.535] [-2.147.483.6482.147.483.647] [04.294.967.295] [-9.223.372.036.854.775.808 9.223.372.036.854.775.807]

64 32 64 128 32 16 Variable Variable

[018.446.744.073.709.551.615] [1,510-453,41038] [5,010-324 1,710308] [1,010-28 7,91028] true, false [\u0000, \uFFFF] Valor mximo determinado por memoria Cualquier objeto

ulong float double decimal bool char string object

Tipos predefinidos
Problema:
public static void Foo(int x){...} public static void Foo(long x){...} Llamada Foo(100)?

Tipo del literal entero es el primero que permita almacenarlo: int,

uint, long, ulong Foo(100) llama al primer mtodo

Sufijos
L (long, ulong), U (int, uint), UL (ulong) F (float), D (double), M (decimal)

Ejemplo
Foo(100L) llama al segundo mtodo

Tipos predefinidos: Arrays

Almacenamiento de elementos del mismo tipo en un bloque contiguo de memoria Son tipos por referencia Deriva de System.Array Zero-based Pueden ser multidimensionales
Length: nmero total de elementos (considerando todas las dimensiones) Rank: obtiene el nmero de dimensiones

10

Tipos predefinidos: Arrays

Declaracin
int[] coord;

Reserva de Espacio
int[] coord = new int[9];

Inicializacin
int[] coord = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; int[] coord = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

Acceso y Asignacin
coord[0] = 100;

Tipos predefinidos: Arrays

Arrays Multidimensionales
Rectangulares
int[,] matR = new int[2,3];

Pueden inicializarse de manera declarativa

int[,] matR = new int[2,3] { {1,2,3}, {4,5,6} };

Escalonados (Jagged)
Un array de arrays
int[][] matJ = new int[2][];

Deben inicializarse proceduralmente (no de forma declarativa)

11

Tipos predefinidos: Arrays

Mtodos estticos de System.Array
void Sort(array) void Reverse(array) int IndexOf(array, object) int LastIndexOf(array, object) object Find(array, condition) object[ ] FindAll(array, condition) bool TrueForAll(array, condition)

Clases
Herencia Modificadores de acceso
private internal protected protected internal public

Miembros de una clase

Constantes, campos, propiedades, mtodos, indizadores, eventos, constructores, destructores Miembros estticos e instancias

Operadores

12

Clases. Herencia
Slo se admite herencia simple Se admite implementacin de mltiples interfaces
public class ClaseBase { } public interface IInterfaz { } public class ClaseDerivada : ClaseBase, IInterfaz { }

Para evitar que una clase se pueda extender se indica con: sealed Los mtodos, por defecto, no pueden redefinirse (son sealed). Para poder redefinir un mtodo
Definirlo como virtual En la redefinicin del mtodo indicar override

Clases. Constructores
Llamadas entre constructores: this
class SuperClass { private string argument1; public SuperClass() : this("<Default arg1>") { } public SuperClass(string arg1) { this.argument1 = arg1; Console.WriteLine("Arguments: " + argument1); } }

SuperClass sc = new SuperClass();

// Creating a SuperClass instance

Salida: Arguments: <Default arg1>

13

Clases. Constructores
Llamadas a la clase base: base
class ChildClass : SuperClass { private string argument2; public ChildClass() : this("<Default arg2>") { } public ChildClass(string arg2) { this.argument2 = arg2; Console.WriteLine("Arguments: " + argument2); } public ChildClass(string arg1, string arg2) : base(arg1) { this.argument2 = arg2; Console.WriteLine("Arguments: " + argument2); } }

Clases. Constructores
Ejemplo
static void Main() { SuperClass sc = new SuperClass(); /* Shows: * Arguments: <Default arg1> */ ChildClass cc = new ChildClass(); /* Shows: * Arguments: <Default arg1> * Arguments: <Default arg2> */ ChildClass cc2 = new ChildClass("1", "2"); /* Shows: * Arguments: 1 * Arguments: 2 */ Console.Read(); }

14

Clases. Constructores estticos

Permiten inicializacin de cdigo, que se realizar una nica vez para la clase Garantizan la ejecucin antes de:
La creacin de la primera instancia de la clase El acceso a cualquier miembro esttico

Un nico constructor esttico por clase No pueden tener parmetros

Clases. Constructores estticos

Llamada automtica al acceder por primera vez a la clase
public class LogManager { private static FileStream logFile; // Static Constructor opens the file static LogManager() { logFile = File.Open("logFile.dat", FileMode.Create); } public LogManager() { logFile.WriteLine(System.Date.Now + "Instance created"); } }

15

Clases. Destructores
Llamado automticamente por Garbage Collector
public class LogManager { ~LogManager() { logFile.WriteLine(System.Date.Now + "Instance Disposed"); logFile.Close();; } }

Llamada a Garbage Collector: System.GC.Collect()

No garantiza borrado de memoria

Los destructores no se heredan

La clase System.Object
Todos los tipos heredan de System.Object
public virtual bool Equals(object o) public virtual int GetHashCode() public virtual string ToString() protected object MemberWiseClone() public System.Type GetType() protected virtual void Finalize() public static bool Equals(object o1, object o2) protected static bool ReferenceEquals(object o1, object o2)

16

Clases. Modificadores de acceso

Con respecto al acceso, los mtodos de una clase pueden ser:
private:
Slo cdigo dentro de la misma clase contenedora tiene acceso a un miembro privado.

protected:
Miembros accesibles desde la clase que los contiene o desde clases derivadas de sta

internal:
Miembros accesibles desde el mismo assembly

protected internal:
Miembros accesibles desde el mismo assembly o clases derivadas de la clase que lo contiene (protected + internal)

public:
No hay restricciones de acceso

Clases. Constantes
Constantes Se evalan en tiempo de compilacin Son implcitamente estticas (error si se usa static explcitamente)

Ejemplo
public class MyClass { public public public // The public ... } const string VERSION = "1.0.0"; const string URI = "http://" + "www.google.es"; const double PI = 3.14159265358979; expression being assigned to SIN must be constant const double SIN = Math.Sin(PI); //ERROR

17

Clases. Campos de slo lectura

Similares a las constantes, pero
Se inicializacin en tiempo de ejecucin (vs. compilacin)
Evitan necesidad de recompilar clientes

Pueden ser estticas o por instancia

Una vez inicializadas, no pueden modificarse

public class MyClass { public static readonly double d1 = Math.Sin(Math.PI); public readonly string s1; public MyClass(string s) { s1 = s; } }

Clases. Propiedades
Propiedades
Encapsulacin con mtodos getXXX / setXXX

Mezcla entre campo y mtodo

Externamente son accedidas como un campo pblico Internamente es posible asociar cdigo a ejecutar en cada asignacin (set) o lectura (get) de su valor

18

Clases. Propiedades > Definicin

public class UserProfileVO { private String loginName; private String encryptedPassword; <<...>> public String LoginName { get { return loginName; } set { loginName = value; } }

atributos privados

propiedades
public String EncryptedPassword { get { return encryptedPassword; } set { encryptedPassword = value; } } <<...>> }

Clases. Propiedades > Acceso

static void Main(string[] args) { UserProfileDetailsVO userProfileDetailsVO = ... UserProfileVO userProfileVO = new UserProfileVO("jsmith", "7dj39jHT1d4gFl93", userProfileDetailsVO); //get System.Console.Write(userProfileVO.LoginName); //set userProfileVO.LoginName = jsuarez"; }

19

Clases Abstractas
Una clase abstracta no puede ser instanciada Est pensada para ser usada como clase base Puede contener mtodos abstractos y no abstractos Similar a una interfaz No puede ser sealed

Clases Abstractas
public abstract class Product { public abstract String getReference(); }

public class Book : Product { public override String getReference() { return ISBN; } }

20

Clases Sealed
Es una clase que no se puede extender Las clases sealed no pueden ser abstractas Todas las estructuras son sealed Por qu "cerrar" una clase?
Para prevenir que sea extendida de forma no intencionada Optimizacin de cdigo
Las llamadas a mtodos virtual pueden resolverse en tiempo de compilacin

Clases. Mtodos
Redefinicin de mtodos: virtual & override
public class Product { public virtual String getReference() { return barCode; } } public class Book: Product { public override String getReference() { return ISBN; } }

21

Clases. Mtodos
Paso de parmetros
Tipos primitivos se pasan por valor
Para pasar por referencia: ref
public class Util { public void Swap(ref int x, ref int y) { int temp; temp = x; x = y; y = temp; } }

Clases. Mtodos
Paso de parmetros
Nmero variable de parmetros: params

public class Util { public static void printf(string fmt, params object[] args) {} } object[] args = {Texto, 100} Util.printf(%s %d, args);

22

Indexers
Un indexer permite a una instancia comportarse como un array virtual Permite sobrecarga (e.g. indexado por int y por string) Puede ser de slo lectura, slo escritura o lectura/escritura
public class ListBox : Control { private string[] items; public string this[int index] { get { return items[index]; } set { items[index] = value; Repaint(); } } } <<...>> ListBox listBox = new ListBox(); listBox[0] = "hello"; Console.WriteLine(listBox[0]);

Estructuras (struct)
Similares a las clases pero
Requisitos de almacenamiento menores Paso por valor, no referencia No pueden extender ningn tipo (heredan directamente de System.ValueType) Ningn tipo puede heredar de ellas

Pensadas para light weight objects

Uso ms eficiente de la memoria Ejemplos: Complex, Point, Color La mayora de los tipos bsicos (excepto string y object) implementados como structs

Mismos miembros que una clase Modificadores de acceso vlidos

private (defecto), internal o public

23

Estructuras (struct)
public struct Point { private int x, y; public Point(int x, int y) { this.x = x; this.y = y; } public int X { get { return x; } set { x = value; } } public int Y { get { return y; } set { y = value; } } } <<...>> Point p = new Point(2,5); p.X += 100; int px = p.X; // px = 102

Clases vs. Estructuras

sp

10 20

cp 10 20

CPoint

24

Clases vs. Estructuras. Similitudes

Ambas son tipos que pueden ser definidos por el usuario Ambas pueden implementar mltiples interfaces Ambas pueden contener
Datos
campos, constantes, eventos, arrays

Funciones
mtodos, propiedades, indexers, operadores, constructores

Definiciones de tipos
clases, estructuras, enumeraciones, interfaces, delegados

Clases vs. Estructuras. Diferencias

Clase
Referencia Puede heredar desde cualquier tipo no-sealed Puede tener destructor El usuario puede definir un constructor vaco (sin parmetros) Valor No puede heredar (hereda nicamente de System.ValueType) No puede tener destructor El usuario no puede definir un constructor vaco (sin parmetros)

Estructura

25

Enumeraciones
Estructuras con explicitacin de elementos
Evitan uso excesivo de constantes (nmeros mgicos) Facilitan legibilidad del cdigo

Slo podrn contener campos pblicos constantes y estticos

Internamente, los campos se tratarn como alguno de los siguientes tipos:

int, byte, sbyte, short, ushort, uint, long, ulong

Enumeraciones: ejemplo
Declaracin
public enum MessageType : int { INFO = 1, WARNING = 2, ERROR = 3 }

Uso
MessageType messageType = MessageType.WARNING;

26

Enumeraciones
Dado que los valores de una enumeracin son enteros, ser posible tratarlos como operandos:
==, !=, <, >, <=, >=, +, -, ^, &, |, ~, ++, --

Ejemplo:
if (message > MessageType.INFO) { }

Interfaces
Similar a la definicin de un contrato
Pueden incluir mtodos, propiedades, indexers, eventos No pueden incluir operadores, constructores o destructores. Cualquier implementacin de la interfaz debe dar soporte a todas las partes del contrato Miembros de una interfaz son por defecto public y abstract

Proporcionan polimorfismo
Diferentes clases y estructuras pueden implementar la misma interfaz

No contienen implementacin

27

Interfaces
Declaracin
public interface IUserProfileDAO { // Interface methods void Create() { } void Delete() { }

// Interface properties UserProfile LastUser { get; set; } }

Implementacin
public class UserProfileDAO : IUserProfileDAO { }

Interfaces. Herencia multiple

Clases y estructuras pueden heredar de mltiples interfaces Interfaces pueden heredar de mltiples interfaces

interface IControl { void Paint(); } interface IListBox: IControl { void SetItems(string[] items); } interface IComboBox: ITextBox, IListBox { }

28

Delegados
Tipo referencia

Define la firma de un mtodo Una vez instanciado, almacena uno o ms mtodos

Esencialmente: puntero a una funcin OO

Convenio para los eventos del framework

Delegados
/* Declare */ delegate double Del(double x);

static void DemoDelegates() { // Instantiate Del delInst = new Del(Math.Sin);

// Invoke double x = delInst(1.0); }

29

Operadores
Aritmticos
+, -, *, /, % checked vs. unchecked

Asignacin
+=, -=, *=, /=, %=, ++, --

Comparacin
==, !=, <, >, <=, >=

Lgicos
&, &&, |, ||, ~, !, ^

Operadores. Sobrecarga
public class Complex { private float img; private float real; public Complex (float real, float img) { } public float Img { ..} override public string ToString() { if ( img >= 0 ) return real + "+" + img +"i"; else return real + " " + img + "i"; } public static Complex operator + (Complex a, Complex b) { return new Complex(a.real + b.real, a.img + b.img); } } <<...>> Complex a; Complex b; Complex c = a + b;

30

Entrada / Salida por Consola

System.Console
Entrada
Console.Read(); Console.ReadLine(); Console.ReadKey();
ConsoleKeyInfo.Key ConsoleKey ConsoleKeyInfo.Modifiers ConsoleModifiers

Salida
Console.Write(); Console.WriteLine();

Entrada / Salida por Consola: formato

Console.Write(Text {n0:format}, var0)

Console.Write(Current Balance: {0:C}., balance)

Sintaxis: <object>.ToString(format)

long balance = 1000; // Muestra la cantidad en el formato de moneda adecuado Console.Write(balance.ToString("C"));

31

Entrada / Salida por Consola: formato

Formatos predefinidos

Nmero
C D F P H Moneda Decimal Punto Fijo Porcentaje Hexadecimal

Fecha
S D t T F Short Date Long Date Short time Long Time Full Date

Sentencias
Condicionales
if switch

Control de Excepciones
try ...catch...finally throw

Iterativas
while do for foreach

Otras
checked, unchecked lock using

32

Sentencias condicionales. if
Sintaxis General
if (condition) <statementsIF> else <statementsELSE>

Sentencias condicionales. switch

Sintaxis General
Obligatorio incluir break al final de cada rama!
switch (i) { case 1: statements; break; case 2: statements; break; default: statements; break; } switch (str) { case ABC: statements; break; case XYZ: statements; break; default: statements; break; }

33

Sentencias iterativas. while

Sintaxis General
while (condition) { <statements> }

Puede incluir instrucciones Break y/o Continue

Sentencias iterativas. do...while

Sintaxis General
do { <statements> } while(condition)

Puede incluir instrucciones Break y/o Continue

34

Sentencias iterativas. for

Sintaxis General
for (initialize-statement; condition; increment-statement) { statements; }

Puede incluir instrucciones Break y/o Continue

Sentencias iterativas. foreach

Sintaxis General
foreach (<Type> <e> in <collection>) { <statements> }

Ejemplo
String[] daysOfWeek = { "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" };

// Muestra por pantalla los das de la semana foreach (string s in daysOfWeek) { Console.WriteLine(s); }

35

Sentencias. Gestin de Excepciones

Las excepciones son los mecanismos C# para gestionar errores inesperados Mejor que devolver valor de estado
No pueden ser ignoradas No tienen porque gestionarse en el punto en el que ocurren Pueden usarse incluso donde no se devuelven valores (e.g. en el acceso a una propiedad) Se proporcionan excepciones estndar

Sentencias. Gestin de Excepciones

Sentencia try...catch...finally Bloque try contiene cdigo que podra lanzar una excepcin Bloque catch gestiona la excepcin
Puede haber varios bloques catch para gestionar diferentes tipos de excepciones

Bloque finally contiene cdigo que se ejecutar siempre

36

Sentencias. Gestin de Excepciones

Sentencia throw lanza una excepcin Una excepcin se representa como una instancia de System.Exception o una clase derivada
Contiene informacin sobre la excepcin Propiedades
Message StackTrace InnerException

Es posible relanzar una excepcin, o capturarla y lanzar otra

Sentencias. Gestin de Excepciones

try { Console.WriteLine("try"); throw new Exception("Message"); } catch (ArgumentNullException e) { Console.WriteLine("Caught null argument"); } catch (Exception e) { Console.WriteLine("catch"); Console.WriteLine("Message: " + e.Message); Console.WriteLine("StackTrace: " + e.StackTrace); } finally { Console.WriteLine("finally"); }

37

Sentencias. checked & unchecked

Permiten controlar excepciones por overflow
operaciones aritmticas para tipos enteros conversiones de tipos

checked fuerza la comprobacin de errores por overflow

unchecked evita la comprobacin de errores por overflow (defecto) Uso:

checked(expression) checked{sentences]

Sentencias. lock
Permite definir regiones crticas dentro de aplicaciones multithreading
Previene la corrupcin de datos

La sentencia lock proporciona exclusin mutua

Bloquea acceso a la instancia mientras no finalice la operacin Emplea la clase System.Threading.Monitor

38

Sentencias. lock
public class CheckingAccount { decimal balance; public void Deposit(decimal amount) { lock (this) { balance += amount; } } public void Withdraw(decimal amount) { lock (this) { balance -= amount; } } }

Sentencias. using
C# incluye gestin automtica de memoria (Garbage Collector)
Elimina la mayora de problemas de gestin de memoria

Problema: finalizacin no determinista

No existe seguridad o garanta acerca de cuando se llama a los destructores de clase

39

Sentencias. using
Objetos que deben limpiarse una vez usados, deberan implementar la interfaz System.IDisposable
nico mtodo: Dispose()

Sentencia using permite crear una instancia, emplearla y asegurar que tras ello el mtodo Dispose() se llama
Similar a bloque finally en la gestin de excepciones

Sentencias. using
public class MyResource : IDisposable { public void MyResource() { // Acquire valuble resource } public void Dispose() { // Release valuble resource } public void DoSomething() { ... } } <<...>> using (MyResource r = new MyResource()) { r.DoSomething(); } // r.Dispose() is called

40

Colecciones
interface IEnumerable { IEnumerator GetEnumerator(); }

interface IEnumerator { object Current {get; } bool MoveNext(); void Reset(); }

Colecciones: System.Collection
Clases
ArrayList Hashtable DictionaryBase SortedList Queue Stack

Interfaces
ICollection IComparer IDictionary IEnumerable IEnumerator IList

41

Colecciones: ArrayList
[Serializable] public class ArrayList : IList, ICollection, IEnumerable, ICloneable

Propiedades
Capacity Count Item[index] -- Indexer

Colecciones: ArrayList
Mtodos
Add(object) AddRange(Collection) Clear() Contains(object) IndexOf(object) Remove(object) RemoveAt(int) Sort() Reverse() GetEnumerator()

42

Colecciones: ArrayList
Ejemplo
ArrayList a = new ArrayList(); SampleFileManager.ReadSamples(a); IEnumerator enumerador = a.GetEnumerator();

while (enumerador.MoveNext()) { Console.WriteLine(enumerador.Current); }

Colecciones: Hashtable
Representa una coleccin de pares de clave y valor organizados en funcin del cdigo hash de la clave
[Serializable] public class Hashtable : IDictionary, ICollection, IEnumerable, ISerializable, IDeserializationCallback, ICloneable

Propiedades
Count IsFixedSize IsReadOnly Keys Values

43

Colecciones: Hashtable
Mtodos
Contains() ContainsKey(object) ContainsValue(object) GetHash(object) ...

Colecciones: Hashtable
Ejemplo
public class Languages { private static readonly Hashtable LANGUAGES; private static readonly ArrayList LANGUAGES_en = new ArrayList(); static Languages() { LANGUAGES_en.Add(new ListItem("English", "en")); LANGUAGES_en.Add(new ListItem("Spanish", "es")); LANGUAGES = new Hashtable(); LANGUAGES.Add("en", LANGUAGES_en); LANGUAGES.Add("es", LANGUAGES_es); } }

44

Generics
Caracterstica de Common Language Runtime, que permite que las clases, estructuras, interfaces y mtodos tengan parmetros de tipo genrico para los tipos de datos que almacenan y manipulan
Los tipos genricos son una forma de tipos parametrizados

Generics
Ejemplo sin utilizar Generics
public class List { private object[] elements; private int count; public void Add(object element) { if (count == elements.Length) Resize(count * 2); elements[count++] = element; } public object this[int index] { get { return elements[index]; } set { elements[index] = value; } } public int Count { get { return count; } } }

45

Generics
Uso de la lista implementada sin Generics
List intList = new List(); intList.Add(1); intList.Add(2); intList.Add("Three"); int i = (int)intList[0]; // Argument is boxed // Argument is boxed // Should be an error // Cast required

Generics
Implementacin de la clase Lista utilizando Generics
public class List<ItemType> { private ItemType[] elements; private int count; public void Add(ItemType element) { if (count == elements.Length) Resize(count * 2); elements[count++] = element; } public ItemType this[int index] { get { return elements[index]; } set { elements[index] = value; } } public int Count { get { return count; } } }

46

Generics
Uso de la lista implementada utilizando Generics
List<int> intList = new List<int>(); intList.Add(1); intList.Add(2); intList.Add("Three"); int i = intList[0]; // No boxing // No boxing // Compile-time error // No cast required

Generics
Por qu utilizar Generics?
Comprobacin de tipos en tiempo de compilacin Rendimiento (no boxing, no downcasts) Reduce la complejidad del cdigo

47

Generics
Los tipos genricos pueden aplicarse a
Clases, estructuras, interfaces, delegados
class Dictionary<KeyType, ValueType> {...} struct Pair<FirstType, SecondType> {...} interface IComparer<T> {...} delegate ResType Func<ArgType, ResType>(ArgType arg); << ... >> Dictionary<string, Customer> customerLookupTable; Dictionary<string, List<Order>> orderLookupTable; Dictionary<int, string> numberSpellings;

Generics
Los tipos genricos pueden aplicarse a
y mtodos
class Array { public static T[] Create<T>(int size) { return new T[size]; } public static void Sort<T>(T[] array) { ... } } << ... >> string[] names = Array.Create<string>(3); names[0] = "Jones"; names[1] = "Anderson"; names[2] = "Williams"; Array.Sort(names);

48

Generics
Restricciones
Una clase base, varias interfaces, new() Se indica con la clausula where
interface IComparable { int CompareTo(object obj); } class Dictionary<K, V> { public void Add(K key, V value) { << ... >> switch (((IComparable)key).CompareTo(x)) { << ... >> } } }

Generics
Restricciones
Una clase base, varias interfaces, new() Se indica con la clausula where
interface IComparable { int CompareTo(object obj); } class Dictionary<K, V> where K: IComparable { public void Add(K key, V value) { << ... >> switch (key.CompareTo(x)) { << ... >> } } }

49

Generics
Restricciones
Una clase base, varias interfaces, new() Se indica con la clausula where
interface IComparable<T> { int CompareTo(T obj); } class Dictionary<K, V> : IDictionary<K, V> where K: IComparable<K>, V: IKeyProvider<K>, V: IPersistable, V: new() { << ... >> }

Eventos
Gestin de eventos es un estilo de programacin dnde un objeto notifica a otro que algo de inters ha ocurrido
Es un modelo de programacin edicin-suscripcin

Los eventos permiten vincular un cdigo a la funcionalidad de un componente creado de forma independiente Los eventos son un tipo de mecanismo de callback

50

Eventos
Los eventos son idneos para las interfaces de usuario
El usuario hace algo (hace click en un botn, mueve el ratn, cambia un valor, etc.) y el programa reacciona en consecuencia

Muchos otros usos, e.g.

Programar eventos basados en tiempo Notificar operaciones asncronas completadas Notificar que se ha recibido un e-mail Notificar que se ha iniciado una sesin Web

Eventos
C# tiene soporte nativo para eventos Est basado en delegados Un evento es en esencia un campo que contiene un delegado Sin embargo, un usuario de una clase nicamente puede registrar delegados
Slo puede ejecutar += y -= No pueden invocar al delegado del evento

51

Eventos. Ejemplo: Component-Side

Define la firma del evento como un delegado
public delegate void EventHandler(object sender, EventArgs e);

Define el evento y la lgica de activacin

public class Button { public event EventHandler Click; protected void OnClick(EventArgs e) { // This is called when button is clicked if (Click != null) Click(this, e); } }

Eventos. Ejemplo: User-Side

Define y registra el gestor del evento
public class MyForm : Form { Button okButton; static void OkClicked(object sender, EventArgs e) { ShowMessage("You pressed the OK button"); } public MyForm() { okButton = new Button(); okButton.Caption = "OK"; okButton.Click += new EventHandler(OkClicked); } }

52