(2010 03 04) 02 CSharp PDF

Integracin de Sistemas
El lenguaje de programacin C#
Parte II. Diseo e implementacin de aplicaciones Web con .NET
Indice
Introduccin Compilador C# Namespaces Sistema de tipos unificado Tipos predefinidos Clases Estructuras (struct) Enumeraciones Interfaces Operadores Entrada / Salida por Consola Sentencias Colecciones Generics Anexo I. Documentacin XML en .NET
Curso 2009 - 2010
Introduccin
C# es un lenguage OO usado para desarrollar aplicaciones en la plataforma .NET Diseado 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 lgica de negocio en lugar de detalles de programacin de bajo nivel
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 (se ilustra ms adelante) Los tipos primitivos slo se tratan como objetos cuando la situacin lo requiere, mientras tanto pueden aplicrseles optimizaciones especficas
Curso 2009 - 2010
Introduccin
Hola Mundo
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. using System; namespace Es.UDC.DotNet.CSharpTutorial { /* * Class HelloWorld * Description: simple C# example */ class HelloWorld { #region Test code. Uncomment for testing // entry point public static void Main() { Console.WriteLine("Hello World!"); Console.ReadLine(); } #endregion } }
Introduccin
Hola Mundo
La lnea "using System;" significa que accederemos a miembros del namespace System Static es un modificador que indica que se trata de un mtodo de clase Main() es lo que es denomina el punto de entrada de la aplicacin
Necesita del modificador static para evitar que para llamarlo haya que crear algn objeto de la clase donde se haya definido.
C# es sensible a las maysculas

Los mtodos y nombres de clases siguen sitxis PascalCase (e.g., FindByUserIdentifier()) Los atributos siguen sitxis camelCase (e.g., firstName)
Curso 2009 - 2010
Introduccin
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
Introduccin
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)
Curso 2009 - 2010
Compilador C#
Los archivos C# tienen extensin .cs 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
Todo esto se puede hacer desde el Visual Studio
Namespaces
Declaracin:
namespace <NombreEspacio> { <Definicin clases> }
Anidacin de namespaces vlida

NmbEspacio1.NmbEspacio2.NmbEspacio3;
Referencia a namespaces externos

using
Alias: evitar conflictos entre namespaces

using <alias> = <NombreCompletoClase>;
Curso 2009 - 2010
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

Tipos valor y referencia
Valor
Primitivos Enumeraciones Estructuras int i; enum State { Off, On } struct Point { int x, y; }
Referencia
Raz String Clases Interfaces Arrays object string class Foo : Bar, IFoo {...} interface IFoo : IBar {...} string[] a = new string[10];
Curso 2009 - 2010

Boxing & Unboxing
Los tipos valor (struct, enum, int) pueden ser convertidos en tipos referencia (y viceversa) de forma automtica mediante Boxing (y Unboxing) Boxing:
Encapsulacin de tipo valor en tipo referencia Ej: la siguiente sentencia envuelve el valor 3 en un objeto
object obj = 3;
Unboxing
Proceso inverso al boxing. Tratamiento de tipo referencia como tipo valor Ej.: la siguiente sentencia desenvuelve el valor
int x = (int) obj;

Boxing & Unboxing
Boxing
Reserva espacio Copia valor en ese espacio
int i = 123; object o = i; int j = (int)o; Pila (stack) i 123 o
// boxing // unboxing Montn (heap)
Unboxing Chequea tipo dato Desenvuelve el valor
(i boxed) int 123
j 123
Curso 2009 - 2010
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
Curso 2009 - 2010
Tipos predefinidos
Sufijos
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
Clases
Las clases C# son similares a las clases Java C# permite los siguientes miembros de clase (entre otros)
Constructores Destructores Campos Propiedades Mtodos
Curso 2009 - 2010
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); } public static void Main() { // Creating a SuperClass instance SuperClass sc = new SuperClass(); /* Shows: * Arguments: <Default arg1> */ Console.ReadLine(); } }
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); } }
Curso 2009 - 2010
10
Clases
Constructores
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(); }
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 Equivalente a bloque static de Java
Curso 2009 - 2010
11
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.DateTime.Now.ToString() + " Instance created"); } }
Clases
Destructores
Llamado automticamente por Garbage Collector
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
Curso 2009 - 2010
12
Clases
Campos constantes
Se evalan en tiempo de compilacin Son implcitamente estticas (error si se usa static explcitamente) Ejemplo
public public public public const const const const string string double double VERSION = "1.0.0"; URI = "http://" + "www.google.es"; PI = 3.14159265358979; UNO = Math.Cos(0); //ERROR
Ejemplo de acceso desde cdigo externo:

MyClass.URI
Clases
Campos de slo lectura
Similares a las constantes, pero
Se inicializan en tiempo de ejecucin (vs. compilacin)
Evitan necesidad de recompilar clientes
Pueden ser estticas o por instancia Una vez inicializadas, no pueden modificarse
public readonly double UNO = Math.Cos(0); public static readonly double CERO = Math.Sin(0);
Curso 2009 - 2010
13
Clases
Properties
Frecuentemente, en una clase, declaramos un atributo como privado y proporcionamos mtodos GetXXX / SetXXX para acceder a l. Es un tipo de encapsulacin.
Buena prctica de programacin Los atributos no son accesibles desde fuera de la clase Es necesario utilizar los mtodos GetXXX / SetXXX
.NET proporciona un mecanismo para encapsular atributos, denominado Properties
Clases
Properties
Ej. Encapsulacin sin properties. Definicin:
/* Traditional Encapsultation Without Properties */ class CircleWithGetSet { private double radius; public double GetRadius() { return radius; } public void SetRadius(double radius) { this.radius = radius; } << ... >> }
Curso 2009 - 2010
14
Clases
Properties
Ej. Encapsulacin sin properties. Acceso:
public static void Main() { CircleWithGetSet circle = new CircleWithGetSet(); // Set circle.SetRadius(1); // Get Console.WriteLine("Radius: " + circle.GetRadius()); }
Clases
Properties
Ej. Encapsulacin con properties. Definicin:
/* 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; } } << ... >> }
Curso 2009 - 2010
15
Clases
Properties
Ej. Encapsulacin con properties. Acceso:
public static void Main() { CircleWithProperties circle = new CircleWithProperties(); // Set circle.Radius = 1; // Get Console.WriteLine("Radius: " + circle.Radius); }
Clases
Properties
Una propiedad puede ser de slo lectura / slo escritura. Basta con definir nicamente el accessor get / set Son PascalCase Externamente son accedidas como si de un campo pblico se tratase, pero internamente es posible asociar cdigo a ejecutar en cada asignacin o lectura de su valor
Curso 2009 - 2010
16
Clases
Properties
C# 3.0 incorpora Automatic Properties
No es necesario declarar explcitamente el atributo privado ni las operaciones de asignacin y retorno
El compilador los generar automticamente
Para el ejemplo anterior, bastara escribir:

public string Radius { get; set; }
Es obligatorio definir ambos mtodos de acceso (accessors) get / set. Sin embargo pueden construirse properties de slo lectura / solo escritura utilizando el modificador de acceso private
public string Radius { private get; set; }
Clases
Properties
Para ejemplo ms complejos, debemos utilizar las propiedades tradicionales
Atajo: En VS, sobre el atributo privado:
Refactor > Encapsulate Field Genera gdigo base, que podemos completar
public double Radius { private get { return radius; } set { if (value < 0) { this.radius = 0; } else { this.radius = value; } } }
Curso 2009 - 2010
17
Clases
Properties
Es posible definir propiedades abstractas
public abstract class AnAbstractClass { public abstract string AbstractProp { get; set; } << ... >> }
Y tambin en Interfaces
public interface IAnInterface { public string APropertie { get; set; } << ... >> }
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; } }
Curso 2009 - 2010
18
Clases
Mtodos
Modificadores de acceso
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
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; } }
Curso 2009 - 2010
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 Todo mtodo definido como abstract es implcitamente virtual
Clases Abstractas
public abstract class AbstractSQLAccountDAO : IAccountDAO { 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) { <<...>> } }
Curso 2009 - 2010
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 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
Curso 2009 - 2010
21
Mismos miembros que una clase Modificadores de acceso vlidos
private (defecto), internal o public
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
Curso 2009 - 2010
22
Enumeraciones
Estructuras con explicitacin de elementos
Evitan uso nmeros mgicos Facilitan legibilidad del cdigo Participan en el mecanismo de comprobacin de tipos
Slo podrn contener campos pblicos constantes y estticos El tipo por defecto de las constantes que forman una enumeracin es int, aunque puede drseles cualquier otro tipo bsico entero:
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;
Curso 2009 - 2010
23
Interfaces
Similar a la definicin de un contrato
Pueden incluir mtodos, propiedades, 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
Interfaces
Declaracin
public interface IUserProfileDAO { // Interface methods void Create(...); void Delete(...); // Interface properties UserProfile LastUser { get; set; } }
Implementacin
public class UserProfileDAO : IUserProfileDAO { }
Curso 2009 - 2010
24
Operadores
Aritmticos
+, -, *, /, %
Asignacin
+=, -=, *=, /=, %=, ++, --
Comparacin
==, !=, <, >, <=, >=
Lgicos
&, &&, |, ||, ~, !, ^
Operadores
Obtencin de informacin sobre tipos
typeof(Type t)
Obtiene el objeto System.Type para un tipo
Type t = typeof(SampleClass); // Alternatively, you could use // SampleClass obj = new SampleClass(); // Type t = obj.GetType();
<expression> is <type> as
Similar a proceso de casting, pero devuelve null en lugar de InvalidCastException
Curso 2009 - 2010
25
Entrada / Salida por Consola

System.Console
Entrada
Console.Read(); Console.ReadLine(); Console.ReadKey();
Salida
Console.Write(); Console.WriteLine();

Salida con formato
Opcin 1
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)
Opcin 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"));
Curso 2009 - 2010
26

Salida con 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
lock using
Curso 2009 - 2010
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; break; default: statements; break; } switch (str) { case "ABC": statements; break; case "XYZ": statements; break; default: statements; break; }
Curso 2009 - 2010
28
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)
Curso 2009 - 2010
29
Sentencias iterativas. for

Sintaxis General
for (initialize-statement; condition; increment-statement) { statements; }
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); }
Curso 2009 - 2010
30
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

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
Curso 2009 - 2010
31

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

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"); }
Curso 2009 - 2010
32
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
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; } } }
Curso 2009 - 2010
33
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 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 }
Curso 2009 - 2010
34
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
Curso 2009 - 2010
35
Colecciones: ArrayList
[Serializable] public class ArrayList : IList, ICollection, IEnumerable, ICloneable
Propiedades
Capacity Count Item[index] -- Indexer
Mtodos
Add(object) AddRange(Collection) Clear() Contains(object) IndexOf(object) Remove(object) RemoveAt(int) Sort() Reverse() GetEnumerator()
Curso 2009 - 2010
36
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 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
Curso 2009 - 2010
37
Mtodos
Contains() ContainsKey(object) ContainsValue(object) GetHash(object) ...
Ejemplo
public 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("Ingls", "en")); LANGUAGES_es.Add(new ListItem("Espaol", "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); } }
Curso 2009 - 2010
38
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 = 0; <<...>> 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; } } } // array to store list elements // number of elements in the list
Curso 2009 - 2010
39
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 = 0; <<...>> 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; } } } // array to store list elements // number of elements in the list
Curso 2009 - 2010
40
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
Curso 2009 - 2010
41
Generics
Los tipos genricos 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; 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);
Curso 2009 - 2010
42
Anexo I
DOCUMENTACIN XML EN .NET
Documentacin XML en .NET

Comentarios XML que emplean conjunto de etiquetas predefinidas Etiquetas de uso genrico
<summary> <remarks> <see> <seealso> <permission>
Etiquetas relativas a excepciones

<exception>
Etiquetas relativas a mtodos

<param> <paramref> <returns>
Etiquetas relativas a formato

<example> <code> <c> <para>
Etiquetas relativas a propiedades

<value>
Curso 2009 - 2010
43
Etiquetas XML
Etiquetas de uso genrico
<summary>
Indica un resumen sobre el significado del elemento al que precede Se puede emplear junto con la etiqueta <remarks> para aadir informacin complementaria sobre el propio elemento.
///<summary> /// Esta clase es de muestra para la documentacin ///</summary> ///<remarks> Esta clase no realiza ninguna accin, slo /// sirve de muestra</remarks> public class Documentacion { public Documentacion() { // TODO: Add constructor logic here } }
Etiquetas XML
<see>
Indica hipervnculos a otros elementos de la documentacin
<seealso>
Indica un elemento cuya documentacin guarda relacin 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 estndar el mensaje Hola!. /// Si no sabe como se escribe en pantalla puede consultar la /// documentacin del mtodo <see cref="System.Console.WriteLine"/>. /// </summary> /// <seealso cref="System.Console"/> public static void Saluda() { Console.WriteLine("Hola!"); }
Curso 2009 - 2010
44
Etiquetas XML
<permission>
Indica qu permiso necesita un elemento para poder funcionar Atributo cref suele usarse para indicar el tipo del permiso.
/// <summary> Mtodo 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){ ... }
Etiquetas XML
Etiquetas relativas a excepciones
<exception>
Especifica qu excepciones se pueden producir en un mtodo
/// <exception cref="ConfigurationErrorsException"> Se produce esta /// excepcin cuando el parmetro especificado no est definido /// </exception> public String GetParameter(String paramName) { try { String paramValue = ConfigurationManager. AppSettings["nombreParametro"]; << ... >> } catch (ConfigurationErrorsException ex) { throw ex; } }
NOTA: para el desarrollo de la prctica, consideraremos el uso de esta etiqueta obligatorio
Curso 2009 - 2010
45
Etiquetas XML
Etiquetas relativas a mtodos
<param>
Documenta el significado de un parmetro de un mtodo
<paramref>
Referencia a parmetros de mtodos
<returns>
Especifica el valor de retorno de un mtodo
/// <summary> Mtodo 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 mtodo se ha ejecutado con xito o no </returns> Boolean MuestraTexto(string texto, Color color) { ... }
Etiquetas XML
<example>
Ejemplo sobre cmo usar el elemento al que precede
<code>
Se emplea dentro de etiquetas <example> Delimita textos que han de ser considerados fragmentos de cdigo fuente
<c>
Indica que el texto dentro de una descripcin debe ser marcado como cdigo
<para>
Ayuda a separar la seccin que se est escribiendo en prrafos.
Curso 2009 - 2010
46
Etiquetas XML
///<summary> /// <para>Crea una nueva instancia de la clase Cliente</para> /// <para>Otro parrafo</para> ///</summary> ///<example> Ejemplo de cmo realizar la instancia del objeto /// <c>Cliente</c> /// <code> /// Cliente objCliente = new Cliente(); /// </code> ///</example>
Etiquetas XML
Etiquetas relativas a propiedades
<value>
En el caso de las propiedades, este elemento proporciona una descripcin del valor que se est estableciendo o recuperando
/// <summary> /// Almacena /// </summary> /// <value> Edad public int Edad { set { edad = get { return } la edad de una persona. de la persona representada </value>
value; } edad; }
Curso 2009 - 2010
47

(2010 03 04) 02 CSharp PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

(2010 03 04) 02 CSharp PDF

Transféré par

Droits d'auteur :

Formats disponibles

Integracin de Sistemas

Curso 2009 - 2010

Curso 2009 - 2010

C# es sensible a las maysculas

Curso 2009 - 2010

Curso 2009 - 2010

Todo esto se puede hacer desde el Visual Studio

Anidacin de namespaces vlida

Referencia a namespaces externos

Alias: evitar conflictos entre namespaces

Curso 2009 - 2010

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

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

Sistema de Tipos Unificado

Curso 2009 - 2010

Sistema de Tipos Unificado

int x = (int) obj;

Sistema de Tipos Unificado

int i = 123; object o = i; int j = (int)o; Pila (stack) i 123 o

// boxing // unboxing Montn (heap)

Unboxing Chequea tipo dato Desenvuelve el valor

(i boxed) int 123

Curso 2009 - 2010

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

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

ulong float double decimal bool char string object

Curso 2009 - 2010

Curso 2009 - 2010

Curso 2009 - 2010

Curso 2009 - 2010

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

Los destructores no se heredan

Curso 2009 - 2010

Ejemplo de acceso desde cdigo externo:

Curso 2009 - 2010

.NET proporciona un mecanismo para encapsular atributos, denominado Properties

Curso 2009 - 2010

Curso 2009 - 2010

Curso 2009 - 2010

Para el ejemplo anterior, bastara escribir:

Curso 2009 - 2010

Curso 2009 - 2010

Curso 2009 - 2010

Curso 2009 - 2010

Pensadas para light weight objects

Curso 2009 - 2010

Point p = new Point(2, 5); p.X += 100; int px = p.X; // px = 102

Curso 2009 - 2010

Curso 2009 - 2010

Curso 2009 - 2010

Curso 2009 - 2010

Entrada / Salida por Consola

Entrada / Salida por Consola

Curso 2009 - 2010

Entrada / Salida por Consola

Curso 2009 - 2010

Sentencias condicionales. switch

Curso 2009 - 2010

Sentencias iterativas. while

while (condition) { <statements> }

Puede incluir instrucciones break y/o continue