02.- CSharp
Anuncio
2. El lenguaje de
programación C#
Integración de Sistemas
Diseño e implementación con .NET
Introducción
En C# todo es un objeto
Todo hereda de System.Object
y
j
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
Los tipos primitivos sólo se tratan como objetos cuando la situación lo
requiere,
q
, mientras tanto p
pueden aplicárseles
p
optimizaciones
p
específicas
p
El hecho de que todos los tipos del lenguaje deriven de una clase
común, facilita enormemente el diseño de colecciones genéricas,
que pueden almacenar objetos de cualquier tipo
1
Hola Mundo
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
}
} Compilador C#
Ubicación Compilador C#
Sintaxis
C:\windows\Microsoft.NET\Framework\vn.n.nnn\csc.exe
\
\
\
\
\
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
2
Namespaces
Declaración:
namespace <NombreEspacio>
{
<Definición clases>
}
Anidación de namespaces válida
Referencia a namespaces externos
NmbEspacio1.NmbEspacio2.NmbClase
using
Alias: evitar conflictos entre namespaces
using <alias> = <NombreCompletoClase>;
Namespaces
using
using
i
using
using
using
System;
S
System.Collections.Generic;
t
C ll ti
G
i
System.Text;
System.Collections;
System.IO;
static void Main(string[] args)
{
string
username;
ArrayList namesCollection;
using SC = System.Collections;
using
i
SIO = S
System.IO;
t
IO
static void Main(string[] args)
{
string username;
string filename
SC.ArrayList
namesCollection;
filename = SIO.Path.Combine( ... );
¿A qué namespace pertenece?
3
Sistema de Tipos Unificado
Valor
Primitivos
int i;
Enumeraciones
enum State { Off, On }
Estructuras
struct Point { int x, y; }
Referencia
Raíz
object
String
St
g
string
st
g
Clases
class Foo : Bar, IFoo {...}
Interfaces
interface IFoo : IBar {...}
Arrays
string[] a = new string[10];
Sistema de Tipos Unificado
Dos tipos de conversiones
Implícitas
p
Ocurren automáticamente
Éxito asegurado
Sin pérdida de precisión
Explícitas
Requieren un cast
Pueden originar errores
Precisión puede perderse
int x = 123456;
long y = x;
short z = (short)x;
// implicit
// explicit
double d = 1.2345678901234;
float f = (float)d;
// explicit
long l = (long)d;
// explicit
4
Sistema de Tipos Unificado
Boxing
Reserva espacio
p
Copia valor
Unboxing
Chequea tipo dato
Copia valor
int i = 123;
object o = i;
// boxing
int j = (int) o; // unboxing
On the stack
On the heap
i
On the stack
(i boxed)
o
int
123
int i=123;
object o=i;
(i boxed)
o
123
123
j
int
object o=i;
On the heap
123
int j=(int) o;
Tipos predefinidos
C#
Reference
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();
5
Tipos predefinidos
Tipo
Descripción
SByte
Bytes con signo
Byte
Bytes sin signo
Int16
Enteros cortos con signo
UInt16
Enteros cortos sin signo
Int32
UInt32
Bits
Rango
Alias
[-128…127]
sbyte
8
[0…255]
byte
16
[-32.768…32.767]
short
16
[0…65.535]
ushort
Enteros normales
32
[-2.147.483.648…2.147.483.647]
int
Enteros normales sin signo
32
[0…4.294.967.295]
uint
8
[-9.223.372.036.854.775.808…
Int64
Enteros largos
long
64
9.223.372.036.854.775.807]
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
object
String
Cadenas de caracteres
Variable
Valor máximo determinado por
memoria
Object
Cualquier objeto
Variable
Cualquier objeto
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 método
Sufijos
L (long, ulong), U (int, uint), UL (ulong)
F (float), D (double), M (decimal)
Ejemplo
Foo(100L) llama al segundo método
6
Clases. Herencia
Sólo se admite herencia simple
Se admite implementación de múltiples 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 métodos, por defecto, no pueden redefinirse (son sealed).
Para poder redefinir un método
Definirlo como virtual
En la redefinición del método 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);
}
public static void Main()
{
// C
Creating
eat g a Supe
SuperClass
C ass instance
sta ce
SuperClass sc = new SuperClass();
/* Shows:
* Arguments: <Default arg1>
*/
Console.ReadLine();
}
} 7
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
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:
h
* Arguments: 1
* Arguments: 2
*/
Console.ReadLine();
}
8
Clases. Constructores estáticos
Permiten inicialización de código, que se realizará una única vez
para 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ámetros
Clases. Constructores estáticos
Llamada automática al acceder por primera vez a la clase
public
i 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() +
created );
" Instance created");
}
} 9
Clases. Destructores
Llamado automáticamente por Garbage Collector
public class LogManager
{
~LogManager()
{
logFile.WriteLine(System.DateTime.Now.ToString() +
" Instance Disposed");
logFile.Close();
}
}
Llamada a Garbage Collector: System.GC.Collect()
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
bli virtual
i t l b
bool
l E
Equals(object
l ( bj t o)
)
public virtual int GetHashCode()
public virtual string ToString()
protected object MemberWiseClone()
public System.Type GetType()
protected virtual void Finalize()
p
public static bool Equals(object o1, object o2)
protected static bool ReferenceEquals(object o1,
object o2)
10
Clases. Modificadores de acceso
Con respecto al acceso, los métodos de una clase pueden ser:
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:
protected internal:
Miembros accesibles desde el mismo assembly
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 evalúan en tiempo de compilación
Son implícitamente estáticas (error si se usa static explícitamente)
Ejemplo
public class MyClass
{
public const string
public const string
public const double
public const double
VERSION = "1.0.0";
URI = "http://" + "www.google.es";
PI = 3.14159265358979;
SIN = Math.Sin(PI); //ERROR
<<
<<...>>
>>
}
Ejemplo de acceso desde código externo
MyClass.URI
11
Clases. Campos de sólo lectura
Similares a las constantes, pero…
Se inicializan en tiempo
p de ejecución
j
((vs. compilación)
p
)
Evitan necesidad de recompilar clientes
Pueden ser estáticas o por instancia
Una vez inicializadas, no pueden modificarse
public class UserFacadeDelegate
{
private static readonly String connectionString =
Settings.Default.UserProfileDAOFactory_connectionString;
private static readonly String providerInvariantName =
Settings.Default.UserProfileDAOFactory_providerInvariantName;
private static readonly DbProviderFactory dbProviderFactory =
DbProviderFactories.GetFactory(providerInvariantName);
<<...>>
} Clases. Propiedades
Propiedades
Encapsulación con métodos getXXX / setXXX
Mezcla entre campo y método
Externamente son accedidas como un campo público
Internamente es posible asociar código a ejecutar en cada
asignación (set) o lectura (get) de su valor
12
Clases. Propiedades > Definición
public class UserProfileVO {
private String loginName;
private String encryptedPassword;
atributos privados
<<...>>
public String LoginName {
get { return loginName; }
set { loginName = value; }
}
public String EncryptedPassword {
get { return encryptedPassword; }
set { encryptedPassword = value; }
}
propiedades
<<...>>
}
Clases. Propiedades > Acceso
static void Main(string[] args)
{
UserProfileDetailsVO userProfileDetailsVO = <<...>>
<<
>>
UserProfileVO userProfileVO =
new UserProfileVO("jsmith", "7dj39jHT1d4gFl93",
userProfileDetailsVO);
//get
Console.WriteLine(userProfileVO.LoginName);
//set
userProfileVO.LoginName = "jsuarez";
} 13
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
Clases Abstractas
public abstract class AbstractSQLAccountDAO : IAccountDAO
{
public
bli abstract
b t
t List<AccountVO>
Li t A
tVO FindByUserIdentifier(
Fi dB U
Id tifi (
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)
{
<<...>>
}
} 14
Clases Sealed
Es una clase que no se puede extender
L clases
Las
l
sealed
l d no pueden
d ser abstractas
b t t
Todas las estructuras son sealed
¿Por qué "cerrar" una clase?
Para prevenir que sea extendida de forma no intencionada
Clases. Métodos
Redefinición de métodos: virtual & override
public
bli class
l
P d t
Product
{
public virtual String getReference()
{
return barCode;
}
}
public class Book : Product
{
public override String getReference()
{
return ISBN;
}
} 15
Clases. Métodos
Paso de parámetros
Tipos
p p
primitivos se p
pasan p
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;
}
}
Estructuras (struct)
Similares a las clases pero …
Requisitos de almacenamiento menores
P
Paso
por valor,
l no referencia
f
i
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
L mayoría
La
í d
de llos titipos bá
básicos
i
((excepto
t string
t i y object)
bj t)
implementados como structs
Mismos miembros que una clase
Modificadores de acceso válidos
private (defecto), internal o public
16
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 Enumeraciones
Estructuras con explicitación de elementos
Evitan uso excesivo de constantes (números mágicos)
Facilitan legibilidad del código
Sólo podrán contener campos públicos constantes y
estáticos
Internamente, los campos se tratarán como alguno de
l siguientes
los
i i t ti
tipos:
int, byte, sbyte, short, ushort, uint, long, ulong
17
Enumeraciones: ejemplo
Declaración
public enum MessageType : int {
INFO = 1,
WARNING = 2,
ERROR = 3
}
Uso
MessageType messageType = MessageType.WARNING;
Interfaces
Similar a la definición de un contrato
Pueden incluir métodos
métodos, propiedades,
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
18
Interfaces
Declaración
public interface IUserProfileDAO {
// Interface methods
void Create(…) { … }
void Delete(…) { … }
// Interface properties
UserProfile LastUser { get; set; }
}
Implementación
public class UserProfileDAO : IUserProfileDAO { … }
Operadores
Aritméticos
Asignación
+=, -=, *=, /=, %=, ++, --
Comparación
+ -,
+,
- *,
* /,
/ %
==, !=, <, >, <=, >=
Lógicos
&, &&, |, ||, ~, !, ^
19
Operadores
Obtención de información sobre tipos
typeof(Type t)
<expression> is <type>
sizeof(Type t)
as
Entrada / Salida por Consola
System.Console
Entrada
Salida
Console.Read();
Console.ReadLine();
Console.ReadKey();
Console.Write();
Console.WriteLine();
System.Diagnostics
Salida
Debug.WriteLine();
Debug.WriteLineIf();
Trace.WriteLine();
Trace.WriteLineIf();
20
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"));
Entrada / Salida por Consola: formato
Formatos predefinidos
Número
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
21
Sentencias
Condicionales
Control de Excepciones
if
try ...catch...finally
switch
throw
Iterativas
while
do
for
foreach
Otras
lock
using
Sentencias condicionales. if
Sintaxis General
if (condition)
<statementsIF>
else
<statementsELSE>
22
Sentencias condicionales. switch
Sintaxis General
¡Obligatorio incluir break al final de cada rama!
switch (i) {
case 1:
statements;
break;
case 2:
statements;
t t
t
break;
default:
statements;
break;
}
switch (str) {
case "ABC":
statements;
break;
case "XYZ":
statements;
t t
t
break;
default:
statements;
break;
}
Sentencias iterativas. while
Sintaxis General
while (condition) {
<statements>
}
Puede incluir instrucciones break y/o continue
23
Sentencias iterativas. do...while
Sintaxis General
do {
<statements>
} while(condition)
Puede incluir instrucciones break y/o continue
Sentencias iterativas. for
Sintaxis General
for (initialize-statement;
condition;
increment-statement)
{
statements;
}
Puede incluir instrucciones break y/o continue
24
Sentencias iterativas. foreach
Sintaxis General
foreach (<Type>
yp
<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);
} Sentencias. Gestión 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
ell acceso a una propiedad)
i d d)
Se proporcionan excepciones estándar
25
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
Bloque finally contiene código que se ejecutará
siempre
Sentencias. Gestión de Excepciones
Sentencia throw lanza una excepción
Una excepción
U
ió se representa
t como una iinstancia
t
i d
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
26
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");
} Sentencias. lock
Permite definir regiones críticas dentro de aplicaciones
g
multithreading
Previene la corrupción de datos
La sentencia lock proporciona exclusión mutua
Bloquea acceso a la instancia mientras no finalice la operación
Emplea la clase System.Threading.Monitor
27
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
Objetos que deben limpiarse una vez usados, deberían
p
la interfaz System.IDisposable
y
p
implementar
Ú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
28
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
} Colecciones
interface IEnumerable
{
IEnumerator GetEnumerator();
}
interface IEnumerator
{
object Current { get; }
bool MoveNext();
void Reset();
} 29
Colecciones: System.Collection
Clases
Interfaces
ArrayList
A
Li t
ICollection
IC ll ti
Hashtable
IComparer
DictionaryBase
IDictionary
SortedList
IEnumerable
Queue
IEnumerator
Stack
IList
Colecciones: ArrayList
[Serializable]
public class ArrayList : IList
IList,
ICollection, IEnumerable, ICloneable
Propiedades
Capacity
Count
Item[index] -- Indexer
30
Colecciones: ArrayList
Métodos
Add(object)
AddRange(Collection)
Clear()
Contains(object)
IndexOf(object)
Remove(object)
RemoveAt(int)
Sort()
Reverse()
GetEnumerator()
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);
} 31
Colecciones: Hashtable
Representa una colección de pares de clave y valor organizados en
función del código hash de la clave
[Serializable]
public class Hashtable : IDictionary, ICollection,
IEnumerable, ISerializable, IDeserializationCallback,
ICloneable
Propiedades
Count
IsFixedSize
IsReadOnly
Keys
Values
Colecciones: Hashtable
Métodos
Contains()
ContainsKey(object)
ContainsValue(object)
GetHash(object)
...
32
Colecciones: Hashtable
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("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);
}
} Generics
Característica de Common Language Runtime, que
permite q
p
que las clases,, 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
33
Generics
Ejemplo sin utilizar Generics
public class List
{
private object[] elements;
private int count = 0;
// array to store list elements
// number of elements in the list
<<...>>
public void Add(object element)
{
if (count == elements.Length)
{
Resize();
}
elements[count++]
l
t [
t ] = element;
l
t
}
/* Allows indexer access to class List */
public object this[int index]
{
get { return elements[index]; }
set { elements[index] = value; }
}
} Generics
Uso de la lista implementada sin Generics
List intList = new List();
intList.Add(1);
intList.Add(2);
intList.Add("Three");
// Argument is boxed
// Argument is boxed
// Should be an error
int i = (int)intList[0];
// Cast required 34
Generics
Implementación de la clase Lista utilizando Generics
public class List<ItemType>
{
private ItemType[] elements;
private int count = 0;
// array to store list elements
// number of elements in the list
<<...>>
public void Add(ItemType element)
{
if (count == elements.Length)
{
Resize();
}
elements[count++]
l
t [
t++] = element;
l
t
}
/* Allows indexer access to class List */
public ItemType this[int index]
{
get { return elements[index]; }
set { elements[index] = value; }
}
} Generics
Uso de la lista implementada utilizando Generics
List<int> intList = new List<int>();
intList.Add(1);
intList.Add(2);
//intList.Add("Three");
// No boxing
// No boxing
// Compile-time error
int i = intList[0];
// No cast required 35
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
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;
Dictionary<int, string> numberSpellings;
36
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);
37
