Integración de Sistemas
Curso 2008 - 2009 1
El lenguaje de programación C#
Integración de SistemasIntegración de SistemasParte II. Diseño e implementación de aplicaciones Web con .NET
Indice
Introducción Operadores
Compilador C#
Namespaces
Sistema de tipos unificado
Tipos predefinidos
Clases
p
Entrada / Salida por Consola
Sentencias
Colecciones
Generics
Anexo I. Documentación XML en NET
Estructuras (struct)
Enumeraciones
Interfaces
.NET
Integración de Sistemas
Curso 2008 - 2009 2
Introducción
C# es un lenguage OO usado para desarrollar aplicaciones en la plataforma NETplataforma .NET
Diseñado por Microsoft para combinar la potencia de C/C++, Java y la productividad de Visual Basic
El objetivo de C# (y de la plataforma .NET) es reducir el tiempo de desarrollo
Permitiendo a los desarrolladores invertir su tiempo trabajando en la lógica de negocio en lugar de detalles de programación de bajo nivelg g p g j
Introducción
En C# todo es un objetoTodo hereda de System.Object
Es posible declarar un tipo primitivo (long) y trabajar con él de forma eficiente. Además, es posible asignarlo a un objeto y entonces será tratado como tal
Incluye mecanismos transparentes de boxing y unboxing (se ilustra más adelante)
L ti i iti ól t t bj t d l it ió lLos tipos primitivos sólo se tratan como objetos cuando la situación lo requiere, mientras tanto pueden aplicárseles optimizaciones específicas
Integración de Sistemas
Curso 2008 - 2009 3
IntroducciónHola Mundo
1. using System;2. namespace Es.UDC.DotNet.CSharpTutorial 3. {4. /*5. * Class HelloWorld6. * Description: simple C# example7. */8. class HelloWorld 9. {10. #region Test code. Uncomment for testing11. // entry point12. public static void Main() 13 {13. {14. Console.WriteLine("Hello World!");15. Console.ReadLine();16. }17. #endregion18. }19. }
IntroducciónHola Mundo
La línea "using System;" significa que accederemos a miembros del namespace Systemnamespace System
Static es un modificador que indica que se trata de un método de clase
Main() es lo que es denomina el punto de entrada de la aplicaciónNecesita del modificador static para evitar que para llamarlo haya que crear algún objeto de la clase donde se haya definido.
C# es sensible a las mayúsculasLos métodos y nombres de clases siguen sitáxis PascalCase (e.g., FindByUserIdentifier(…))y g ( g , y ( ))
Los atributos siguen sitáxis camelCase (e.g., firstName)
Integración de Sistemas
Curso 2008 - 2009 4
Introducción
Sólo se admite herencia simple
Se admite implementación de múltiples interfacespublic class ClaseBase { … }
public interface IInterfaz { … }
public class ClaseDerivada : ClaseBase, IInterfaz { … }
Para evitar que una clase se pueda extender se indica con: sealed
Los métodos, por defecto, no pueden redefinirse (son sealed).Los métodos, por defecto, no pueden redefinirse (son sealed).
Para poder redefinir un métodoDefinirlo como virtual
En la redefinición del método indicar override
IntroducciónLa 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)
Integración de Sistemas
Curso 2008 - 2009 5
Compilador C#
Los archivos C# tienen extensión .cs
Ubicación Compilador C#Ubicación 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:librería.dll
Por defecto se referencia a mscorlib.dll.
/main:clase
⇒ Todo esto se puede hacer desde el Visual Studio
Namespaces
Declaración:namespace <NombreEspacio> {
<Definición clases>}
Anidación de namespaces válidaNmbEspacio1.NmbEspacio2.NmbEspacio3;
Referencia a namespaces externosusing
Alias: evitar conflictos entre namespacesusing <alias> = <NombreCompletoClase>;
Integración de Sistemas
Curso 2008 - 2009 6
Namespaces
using SC = System.Collections;i SIO S t IO
using System;i S t C ll ti G i using SIO = System.IO;
static void Main(string[] args){string username;string filename
SC.ArrayList namesCollection;
filename = SIO.Path.Combine( ... );
using System.Collections.Generic;using System.Text;using System.Collections;using System.IO;
static void Main(string[] args){string username;ArrayList namesCollection;
¿A qué namespace pertenece?
Sistema de Tipos UnificadoTipos valor y referencia
ValorPrimitivos i t iPrimitivos int i;
Enumeraciones enum State { Off, On }
Estructuras struct Point { int x, y; }
ReferenciaRaíz object
String stringString string
Clases class Foo : Bar, IFoo {...}
Interfaces interface IFoo : IBar {...}
Arrays string[] a = new string[10];
Integración de Sistemas
Curso 2008 - 2009 7
Sistema de Tipos UnificadoBoxing & Unboxing
Los tipos valor (struct, enum, int…) pueden ser convertidos en tipos referencia (y viceversa) de forma automática mediante Boxing (y (y ) g (yUnboxing)
Boxing: Encapsulación de tipo valor en tipo referencia
Ej: la siguiente sentencia “envuelve” el valor 3 en un objeto
object obj = 3;
UnboxingProceso inverso al boxing. Tratamiento de tipo referencia como tipo valor
Ej.: la siguiente sentencia “desenvuelve” el valor
int x = (int) obj;
Tipos predefinidos
C# Reference object stringReference object, string
Signed sbyte, short, int, long
Unsigned byte, ushort, uint, ulong
Character char
Floating-point float, double, decimal
Logical bool
Importante: realmente se trata de alias a tipos proporcionados por el sistema
int es un alias a System.Int32
Válido: int entero = 100; entero.ToString();
Integración de Sistemas
Curso 2008 - 2009 8
Tipos predefinidosTipo Descripción Bits Rango Alias
SByte Bytes con signo 8 [-128…127] sbyte
Byte Bytes sin signo 8 [0…255] byte
Int16 Enteros cortos con signo 16 [-32.768…32.767] short
UInt16 Enteros cortos sin signo 16 [0…65.535] ushort
Int32 Enteros normales 32 [-2.147.483.648…2.147.483.647] int
UInt32 Enteros normales sin signo 32 [0…4.294.967.295] uint
Int64 Enteros largos 64[-9.223.372.036.854.775.808…
9.223.372.036.854.775.807]long
UInt64 Enteros largos sin signo 64 [0…18.446.744.073.709.551.615] ulong
Single Reales con 7 dígitos 32 [±1,5×10-45…±3,4×1038] float
Double Reales de 15-16 dígitos 64 [±5,0×10-324 …± 1,7×10308] double
Decimal Reales de 28-29 dígitos significativos 128 [±1,0×10-28 …± 7,9×1028] decimal
Boolean Valores lógicos 32 true, false bool
Char Caracteres Unicode 16 [‘\u0000’, ‘\uFFFF’] char
String Cadenas de caracteres Variable Valor máximo determinado por memoria string
Object Cualquier objeto Variable Cualquier objeto object
Tipos predefinidosSufijos
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 método
S fSufijos
L (long, ulong), U (int, uint), UL (ulong)
F (float), D (double), M (decimal)
Ejemplo
Foo(100L) llama al segundo método
Integración de Sistemas
Curso 2008 - 2009 9
Clases
Las clases C# son similares a las clases Java
C# permite los siguientes miembros de clase (entre otros)Constructores
Destructores
Campos
Propiedades
Métodos
ClasesConstructores
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); }
public static void Main() public static void Main() { // Creating a SuperClass instance SuperClass sc = new SuperClass(); /* Shows: * Arguments: <Default arg1> */ Console.ReadLine(); } }
Integración de Sistemas
Curso 2008 - 2009 10
ClasesConstructores
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); } }
ClasesConstructores
Ejemplo public 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.ReadLine(); }
Integración de Sistemas
Curso 2008 - 2009 11
ClasesConstructores estáticos
Permiten inicialización de código, que se realizará una única vez para la clasepara la clase
Garantizan la ejecución antes de:
La creación de la primera instancia de la clase
El acceso a cualquier miembro estático
Un único constructor estático por clase
No pueden tener parámetrosNo pueden tener parámetros
Equivalente a bloque static de Java
ClasesConstructores estáticos
Llamada automática 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.DateTime.Now.ToString() + " Instance created"); } }
Integración de Sistemas
Curso 2008 - 2009 12
ClasesDestructores
Llamado automáticamente por Garbage Collector
Llamada a Garbage Collector: System GC Collect()
public class LogManager { ~LogManager() { logFile.WriteLine(System.DateTime.Now.ToString() + " Instance Disposed"); logFile.Close(); } }
Llamada a Garbage Collector: System.GC.Collect()No garantiza borrado de memoria
Los destructores no se heredan
ClasesCampos constantes
Se evalúan en tiempo de compilaciónSon implícitamente estáticas (error si se usa staticexplícitamente)Ejemplo
Ej l d d d ódi t
public const string VERSION = "1.0.0";public const string URI = "http://" + "www.google.es";public const double PI = 3.14159265358979;public const double UNO = Math.Cos(0); //ERROR
Ejemplo de acceso desde código externo:
MyClass.URI
Integración de Sistemas
Curso 2008 - 2009 13
ClasesCampos de sólo lectura
Similares a las constantes, pero…
Se inicializan en tiempo de ejecución (vs. compilación)p j ( p )
Evitan necesidad de recompilar clientes
Pueden ser estáticas o por instancia
Una vez inicializadas, no pueden modificarse
public readonly double UNO = Math.Cos(0);public static readonly double CERO = Math.Sin(0);
ClasesProperties
Frecuentemente, en una clase, declaramos un atributo como privado y proporcionamos métodos GetXXX / SetXXX para accederprivado y proporcionamos métodos GetXXX / SetXXX para acceder a él. Es un tipo de encapsulación.
Buena práctica de programación
Los atributos no son accesibles desde fuera de la clase
Es necesario utilizar los métodos GetXXX / SetXXX
.NET proporciona un mecanismo para encapsular atributos, d i d P tidenominado Properties
Integración de Sistemas
Curso 2008 - 2009 14
ClasesProperties
Ej. Encapsulación sin properties. Definición:
/* Traditional Encapsultation Without Properties */ class CircleWithGetSet { private double radius; public double GetRadius() { return radius; } public void SetRadius(double radius) { this.radius = radius; } << ... >> }
ClasesProperties
Ej. Encapsulación sin properties. Acceso:
public static void Main() { CircleWithGetSet circle = new CircleWithGetSet(); // Set circle.SetRadius(1); // Get Console.WriteLine("Radius: " + circle.GetRadius()); }
Integración de Sistemas
Curso 2008 - 2009 15
ClasesProperties
Ej. Encapsulación con properties. Definición:
/* Encapsulating Type State with Properties */ class CircleWithProperties { private double radius; public double Radius { get { return radius; } /* NOTE: 'value' is a C# reserved word. */ set { radius = value; } } << ... >> }
ClasesProperties
Ej. Encapsulación con properties. Acceso:
public static void Main(){ CircleWithProperties circle = new CircleWithProperties(); // Set circle.Radius = 1; // Get Console.WriteLine("Radius: " + circle.Radius); }
Integración de Sistemas
Curso 2008 - 2009 16
ClasesProperties
Una “propiedad” puede ser de sólo lectura / sólo escritura. Basta con definir únicamente el accessor get / setcon definir únicamente el accessor get / set
Son “PascalCase”
Externamente son accedidas como si de un campo público se tratase, pero internamente es posible asociar código a ejecutar en cada asignación o lectura de su valor
ClasesProperties
C# 3.0 incorpora Automatic PropertiesNo es necesario declarar explícitamente el atributo privado ni las operaciones de asignación y retorno
El compilador los generará automáticamente
Para el ejemplo anterior, bastaría escribir:
public string Radius { get; set; }
Es obligatorio definir ambos métodos de acceso (accessors) get / set. Sin embargo pueden construirse properties de sólo lectura / solo escritura utilizando el modificador de acceso private
public string Radius { private get; set; }
Integración de Sistemas
Curso 2008 - 2009 17
ClasesProperties
Para ejemplo más complejos, debemos utilizar las propiedades “tradicionales”tradicionales
Atajo: En VS, sobre el atributo privado:
Refactor > Encapsulate Field ⇒ Genera gódigo base, que podemos completar
public double Radius { private get { return radius; } set { if (value < 0) { this.radius = 0; } else { this.radius = value; } } }
ClasesProperties
Es posible definir propiedades abstractas
Y también en Interfaces
public abstract class AnAbstractClass { public abstract string AbstractProp { get; set; } << ... >> }
public interface IAnInterface { public string APropertie { get; set; } << ... >> }
Integración de Sistemas
Curso 2008 - 2009 18
ClasesMétodos
Redefinición de métodos: virtual & override
public class Product { public virtual String GetReference() { return barCode; } } public class Book : Product { public override String GetReference() { return ISBN; } }
ClasesMétodos
Modificadores de accesoprivate:private:
Sólo código 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:
Mi b ibl d d l i l d i d d l l lMiembros accesibles desde el mismo assembly o clases derivadas de la clase que lo contiene (protected + internal)
public:
No hay restricciones de acceso
Integración de Sistemas
Curso 2008 - 2009 19
Clases Abstractas
Una clase abstracta no puede ser instanciada
Está pensada para ser usada como clase base
Puede contener métodos abstractos y no abstractos
Similar a una interfaz
No puede ser sealed
Todo método definido como abstract es implícitamente virtual
Clases Abstractas
public abstract class AbstractSQLAccountDAO : IAccountDAO{
bli b t t Li t<A tVO> Fi dB U Id tifi ( public abstract List<AccountVO> FindByUserIdentifier( DbConnection connection, DbTransaction transaction, long userIdentifier, int startIndex, int count); <<...>>
}
public class CCSqlServerAccountDAO : AbstractSQLAccountDAO { public override List<AccountVO> FindByUserIdentifier( DbConnection connection, DbTransaction transaction, long userIdentifier, int startIndex, int count) { <<...>> } }
Integración de Sistemas
Curso 2008 - 2009 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
Estructuras (struct)
Similares a las clases pero …
Requisitos de almacenamiento menores
Paso por valor, no referencia
No pueden extender ningún tipo (heredan directamente de System.ValueType)
Ningún tipo puede heredar de ellas
Pensadas para light weight objects
Uso más eficiente de la memoria
Ejemplos: Complex, Point, Color
La mayoría de los tipos básicos (excepto string y object) implementados como structs
Integración de Sistemas
Curso 2008 - 2009 21
Estructuras (struct)
Mismos miembros que una clase
Modificadores de acceso válidos
private (defecto), internal o public
Estructuras (struct) public struct Point { private int x, y;
public Point(int x int 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
Integración de Sistemas
Curso 2008 - 2009 22
Enumeraciones
Estructuras con explicitación de elementos
Evitan uso números mágicos
Facilitan legibilidad del código
Participan en el mecanismo de comprobación de tipos
Sólo podrán contener campos públicos constantes y estáticos
El tipo por defecto de las constantes que forman una enumeración es int, aunque puede dárseles cualquier otro tipo básico entero: , q p q p
int, byte, sbyte, short, ushort, uint, long, ulong
Enumeraciones: ejemplo
Declaración
Uso
public enum MessageType : int{
INFO = 1,WARNING = 2,ERROR = 3
}
MessageType messageType = MessageType WARNING;MessageType messageType = MessageType.WARNING;
Integración de Sistemas
Curso 2008 - 2009 23
Interfaces
Similar a la definición de un contrato
Pueden incluir métodos, propiedades, eventos
No pueden incluir operadores, constructores o destructores.
Cualquier implementación 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 implementación
Interfaces
Declaración
Implementación
public interface IUserProfileDAO{
// Interface methodsvoid Create(...);void Delete(...);// Interface propertiesUserProfile LastUser { get; set; }
}
public class UserProfileDAO : IUserProfileDAO { }
Integración de Sistemas
Curso 2008 - 2009 24
Operadores
Aritméticos+, -, *, /, %
Asignación+=, -=, *=, /=, %=, ++, --
Comparación==, !=, <, >, <=, >=
Ló iLógicos&, &&, |, ||, ~, !, ^
Operadores
Obtención de información sobre tipos
typeof(Type t)
Obtiene el objeto System.Type para un tipo
<expression> is <type>
Type t = typeof(SampleClass);// Alternatively, you could use// SampleClass obj = new SampleClass();// Type t = obj.GetType();
as
Similar a proceso de casting, pero devuelve null en lugar de InvalidCastException
Integración de Sistemas
Curso 2008 - 2009 25
Entrada / Salida por Consola
System.Console
EntradaConsole.Read();
Console.ReadLine();
Console.ReadKey();
SalidaConsole.Write();
Console.WriteLine();
Opción 1
Entrada / Salida por ConsolaSalida con formato
Console.Write("Text {n0:format}", var0);
n0 representa las variables (comienzan en 0)
format representa el formato (ver sgte. diapositiva)
Ej:
Console.Write("Current Balance: {0:C}.", balance)
Opción 2
Console.Write("Text " + var0.ToString("format"))
Si no se especifica formato, puede obviarse la llamada a ToString()
Ej:
Console.Write("Current Balance: " + balance.ToString("C"));
Integración de Sistemas
Curso 2008 - 2009 26
Entrada / Salida por ConsolaSalida con formato
Formatos predefinidos
Número
C MonedaD DecimalF Punto FijoP PorcentajeH Hexadecimal
Fecha
S Short DateD Long Datet Short timeT Long TimeF Full DateH Hexadecimal F Full Date
Sentencias
Condicionales Control de Excepcionesif
switch
Iterativaswhile
do
ptry ...catch...finally
throw
Otraslock
for
foreach
using
Integración de Sistemas
Curso 2008 - 2009 27
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;
switch (str) {case "ABC":statements;break;
case "XYZ":statements;
break;default:statements;break;
}
break;default:statements;break;
}
Integración de Sistemas
Curso 2008 - 2009 28
Sentencias iterativas. while
Sintaxis General
while (condition) {
<statements>
}
Puede incluir instrucciones break y/o continuey
Sentencias iterativas. do...while
Sintaxis General
do {
<statements>
} while(condition)
Puede incluir instrucciones break y/o continuey
Integración de Sistemas
Curso 2008 - 2009 29
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" }; // Print the days of the week foreach (string day in daysOfWeek){ Console.WriteLine(day); }
Integración de Sistemas
Curso 2008 - 2009 30
Sentencias. Gestión de Excepciones
Las excepciones son los mecanismos C# para gestionar errores inesperadosinesperados
Mejor que devolver valor de estadoNo 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)acceso a una propiedad)
Se proporcionan excepciones estándar
Sentencias. Gestión de Excepciones
Sentencia try...catch...finally
Bloque try contiene código que podría lanzar una excepción
Bloque catch gestiona la excepción
Puede haber varios bloques catch para gestionar diferentes tipos de excepciones
Bl ti ódi j t á iBloque finally contiene código que se ejecutará siempre
Integración de Sistemas
Curso 2008 - 2009 31
Sentencias. Gestión de Excepciones
Sentencia throw lanza una excepción
Una excepción se representa como una instancia de System.Exception o una clase derivada
Contiene información sobre la excepción
Propiedades
Message
StackTrace
InnerException
Es posible relanzar una excepción, o capturarla y lanzar otra
Sentencias. Gestión 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"); }
Integración de Sistemas
Curso 2008 - 2009 32
Sentencias. using
Objetos que deben limpiarse una vez usados, deberían implementar la interfaz System IDisposablela interfaz System.IDisposable
Único método: Dispose()
Sentencia using permite crear una instancia, emplearla y asegurar que tras ello el método Dispose() se llama
Similar a bloque finally en la gestión de excepciones
Sentencias. usingpublic class MyResource : IDisposable { public void MyResource() {
// Acquire valuable resource // Acquire valuable resource } public void Dispose() { // Release valuable resource } public void DoSomething() { // Do something } } } <<...>> static void Main() { using (MyResource r = new MyResource()) { r.DoSomething(); } // r.Dispose() is called }
Integración de Sistemas
Curso 2008 - 2009 33
Colecciones
interface IEnumerable {{ IEnumerator GetEnumerator(); } interface IEnumerator { object Current { get; } bool MoveNext(); void Reset(); }
Colecciones: System.Collection
Clases InterfacesClasesArrayList
Hashtable
DictionaryBase
SortedList
Queue
InterfacesICollection
IComparer
IDictionary
IEnumerable
IEnumeratorQueue
Stack
IEnumerator
IList
Integración de Sistemas
Curso 2008 - 2009 34
Colecciones: ArrayList
[Serializable]
public class ArrayList : IList, ICollection, IEnumerable, ICloneable
Propiedades
Capacity
Count
Item[index] -- Indexer
Colecciones: ArrayList
MétodosAdd(object)
AddRange(Collection)
Clear()
Contains(object)
IndexOf(object)
Remove(object)
RemoveAt(int)
Sort()
Reverse()
GetEnumerator()
Integración de Sistemas
Curso 2008 - 2009 35
Colecciones: ArrayList
ArrayList months = new ArrayList(); // Populate ArrayList... months.Add("January"); <<...>> months.Add("December"); // Access data with IEnumerator... IEnumerator enumerator = months.GetEnumerator(); while (enumerator.MoveNext()) { Console.WriteLine(enumerator.Current); }} // Access data with foreach foreach (String month in months) { Console.WriteLine(month); }
Colecciones: Hashtable
Representa una colección de pares de clave y valor organizados en función del código hash de la clavedel código hash de la clave
[Serializable]
public class Hashtable : IDictionary, ICollection, IEnumerable, ISerializable, IDeserializationCallback, ICloneable
Propiedades
Count
IsFixedSizeIsFixedSize
IsReadOnly
Keys
Values
Integración de Sistemas
Curso 2008 - 2009 36
Colecciones: Hashtable
Métodos
Contains()
ContainsKey(object)
ContainsValue(object)
GetHash(object)
...
Colecciones: Hashtable
Ejemplobli l Lpublic class Languages
{ private static readonly Hashtable LANGUAGES = new Hashtable(); private static readonly ArrayList LANGUAGES_en = new ArrayList(); private static readonly ArrayList LANGUAGES_es = new ArrayList(); // static constructors initializes hashtable values static Languages() { // ArrayLists stores the ListBox information LANGUAGES_en.Add(new ListItem("English", "en")); LANGUAGES_en.Add(new ListItem("Spanish", "es")); LANGUAGES_es.Add(new ListItem("Inglés", "en")); LANGUAGES_es.Add(new ListItem("Español", "es")); //Key: "en" Value: ArrayList with english information LANGUAGES.Add("en", LANGUAGES_en); //Key: "es" Value: ArrayList with spanish information LANGUAGES.Add("es", LANGUAGES_es); } }
Integración de Sistemas
Curso 2008 - 2009 37
Generics
Característica de Common Language Runtime, que permite que las clases estructuras interfaces y métodos tengan parámetros de tipoclases, estructuras, interfaces y métodos tengan parámetros de tipo genérico para los tipos de datos que almacenan y manipulan
Los tipos genéricos son una forma de tipos parametrizados
Generics
Ejemplo sin utilizar Genericspublic class List { private object[] elements; // array to store list elements private int count = 0; // number of elements in the list <<...>> public void Add(object element) { if (count == elements.Length) { Resize(); } elements[count++] = element; } /* Allows indexer access to class List */ public object this[int index] { get { return elements[index]; } set { elements[index] = value; } } }
Integración de Sistemas
Curso 2008 - 2009 38
Generics
Uso de la lista implementada sin Generics
List intList = new List(); intList.Add(1); // Argument is boxed intList.Add(2); // Argument is boxed intList.Add("Three"); // Should be an error int i = (int)intList[0]; // Cast required
Generics
Implementación de la clase Lista utilizando Genericspublic class List<ItemType>{ private ItemType[] elements; // array to store list elements private int count = 0; // number of elements in the list <<...>> public void Add(ItemType element) { if (count == elements.Length) { Resize();
} } elements[count++] = element; } /* Allows indexer access to class List */ public ItemType this[int index] { get { return elements[index]; } set { elements[index] = value; } } }
Integración de Sistemas
Curso 2008 - 2009 39
Generics
Uso de la lista implementada utilizando Generics
List<int> intList = new List<int>(); intList.Add(1); // No boxing intList.Add(2); // No boxing //intList.Add("Three"); // Compile-time error int i = intList[0]; // No cast required
Generics
¿Por qué utilizar Generics?
Comprobación de tipos en tiempo de compilación
Rendimiento (no boxing, no downcasts)
Reduce la complejidad del código
Integración de Sistemas
Curso 2008 - 2009 40
Generics
Los tipos genéricos pueden aplicarse a
Clases, estructuras, interfaces, …
class Dictionary<KeyType, ValueType> {...}struct Pair<FirstType, SecondType> {...}interface IComparer<T> {...}
<< ... >>
Dictionary<string, Customer> customerLookupTable;Dictionary<string, List<Order>> orderLookupTable;y g, pDictionary<int, string> numberSpellings;
Generics
Los tipos genéricos pueden aplicarse a … y métodos
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);
Integración de Sistemas
Curso 2008 - 2009 41
DOCUMENTACIÓN XM EN NETAnexo IDOCUMENTACIÓN XML EN .NET
Documentación XML en .NET
Comentarios XML que emplean conjunto de etiquetas predefinidas Etiquetas de uso genéricoEtiquetas de uso genérico
<summary> <remarks> <see> <seealso> <permission>
Etiquetas relativas a excepciones<exception>
Etiquetas relativas a métodos<param> <paramref> <returns>
Etiquetas relativas a formatoq<example> <code> <c> <para>
Etiquetas relativas a propiedades<value>
Integración de Sistemas
Curso 2008 - 2009 42
Etiquetas XMLEtiquetas de uso genérico
<summary>
Indica un resumen sobre el significado del elemento al que precedeIndica un resumen sobre el significado del elemento al que precedeSe puede emplear junto con la etiqueta <remarks> para añadir información complementaria sobre el propio elemento.
///<summary>/// Esta clase es de muestra para la documentación///</summary>///<remarks> Esta clase no realiza ninguna acción, sólo /// sirve de muestra</remarks>public class Documentacion{
public Documentacion(){
// TODO: Add constructor logic here}
}
Etiquetas XMLEtiquetas de uso genérico
<see>
Indica hipervínculos a otros elementos de la documentaciónIndica hipervínculos a otros elementos de la documentación
<seealso>
Indica un elemento cuya documentación guarda relación con la del elemento al que precede
Ambas etiquetas carecen de contenido y el nombre del elemento al que remiten se indica en su atributo cref.
/// <summary>/// Muestra por la salida estándar el mensaje ¡Hola!./// Si no sabe como se escribe en pantalla puede consultar la/// documentación del método <see cref="System.Console.WriteLine"/>./// </summary>/// <seealso cref="System.Console"/>public static void Saluda(){
Console.WriteLine("¡Hola!");}
Integración de Sistemas
Curso 2008 - 2009 43
Etiquetas XMLEtiquetas de uso genérico
<permission>
Indica qué permiso necesita un elemento para poder funcionar
Atributo cref suele usarse para indicar el tipo del permiso.
/// <summary> Método para guardar en disco </summary>/// <permission /// cref="System.Security.Permissions.FileIOPermission">/// Debe de tener permisos de escritura en la /// ruta especificada /// </permission>public void SaveSomething(String path){ ... }p g g p
Etiquetas XMLEtiquetas relativas a excepciones
<exception>
E ifi é i d d i ét dEspecifica qué excepciones se pueden producir en un método
/// <exception cref="ConfigurationErrorsException"> Se produce esta /// excepción cuando el parámetro especificado no está definido/// </exception>public String GetParameter(String paramName){
try{
String paramValue = ConfigurationManager.AppSettings["nombreParametro"];
<< ... >>
NOTA: para el desarrollo de la práctica, consideraremos el uso de esta etiqueta obligatorio
<< ... >>}catch (ConfigurationErrorsException ex){
throw ex;}
}
Integración de Sistemas
Curso 2008 - 2009 44
Etiquetas XMLEtiquetas relativas a métodos
<param>
Documenta el significado de un parámetro de un método
<paramref>
Referencia a parámetros de métodos
<returns>
Especifica el valor de retorno de un método
/// <summary>/// Método que muestra por pantalla un texto con un determinado color/// </summary>/// <param name="texto"> Texto a mostrar </param>/// <param name="color">/// Color con el que mostrar el <paramref name="texto"/> indicado/// </param>/// <returns> Indica si el método se ha ejecutado con éxito o no </returns>Boolean MuestraTexto(string texto, Color color) { ... }
Etiquetas XMLEtiquetas relativas a formato
<example>
Ejemplo sobre cómo usar el elemento al que precede
<code>
Se emplea dentro de etiquetas <example>
Delimita textos que han de ser considerados fragmentos de código fuente
<c>
Indica que el texto dentro de una descripción debe ser marcado como código
<para>
Ayuda a separar la sección que se esté escribiendo en párrafos.
Integración de Sistemas
Curso 2008 - 2009 45
Etiquetas XMLEtiquetas relativas a formato
///<summary>/// <para>Crea una nueva instancia de la clase Cliente</para>/// <para>Otro parrafo</para>///</summary>///<example> Ejemplo de cómo realizar la instancia del objeto/// <c>Cliente</c>/// <code>/// Cliente objCliente = new Cliente();/// </code>///</example>
Etiquetas XMLEtiquetas relativas a propiedades
<value>
En el caso de las propiedades este elemento proporciona una descripción delEn el caso de las propiedades, este elemento proporciona una descripción del valor que se está estableciendo o recuperando
/// <summary>/// Almacena la edad de una persona./// </summary>/// <value> Edad de la persona representada </value>public int Edad{
set { edad = value; }get { return edad; }
}