1

Ingeniería de Sistemas

Programación 3

Clase 1

Profesor David López F.

2

Conceptos de Estudio

•Programación orientada a objetos (C# y Visual Basic) • Encapsulación• Herencia• Polimorfismo

•Clases y objetos• Miembros de la Clase

• Campos• Propiedades • Métodos• Argumento por Valor• Constructores• Destructores• Eventos

• Clases Anidadas• Modificadores y Niveles de Acceso• Creación de Instancias de las Clases• Clases y Miembros Estáticos (Compartidos)• Tipos Anónimos

3

Conceptos de Estudio

•Herencia• Reemplazar miembros

•Interfaces•Genéricos•Delegados•Guía de Programación•Heap y Stack

4

Programación Orientada a Objetos (C# y Visual Basic)

Todos los lenguajes administrados de .NET Framework, como Visual Basic y C#, proporcionan plena compatibilidad con la programación orientada a objetos, incluidos la encapsulación, la herencia y el polimorfismo.La encapsulación significa que un grupo de propiedades, métodos y otros miembros relacionados se tratan como si de una sola unidad u objeto se tratase.Herencia describe la posibilidad de crear nuevas clases basadas en una clase existente.Polimorfismo significa que puede tener múltiples clases que se pueden utilizar de forma intercambiable, si bien cada clase implementa las mismas propiedades o los mismos métodos de maneras diferentes.http://msdn.microsoft.com/es-es/library/dd460654.aspx#Members

5

Programación Orientada a Objetos (C# y Visual Basic) - Encapsulación

La ENCAPSULACIÓN es la cualidad de unificar los datos y la forma de manipularlos, de esta forma podemos ocultar el funcionamiento de una clase y exponer solo los datos que manipula (mediante propiedades), así como proveer de medios para poder manipular dichos datos (mediante métodos). De esta forma solo exponemos al mundo exterior la información y la forma de manipularla, ocultando los detalles usados para manejar esos datos y, lo que es más importante, evitando que nadie manipule de una forma no controlada dicha información.

6

Programación Orientada a Objetos (C# y Visual Basic) - Herencia

La HERENCIA es la cualidad de poder crear nuevas clases (o tipos) basadas en otras clases, de forma que la nueva clase obtenga todas las características de la clase que ha heredado, tanto los datos que contiene como la forma de manipularlos, pudiendo añadir nuevas características e incluso cambiar el comportamiento de algunas de las incluidas en la clase base, (siempre que así se haya previsto). Mediante la herencia podemos crear de forma fácil una jerarquía de clases que comparten un mismo comportamiento básico pero que cada nueva generación puede tener (y de hecho tiene) un nuevo comportamiento.

7

Programación Orientada a Objetos (C# y Visual Basic) - Polimorfismo

El POLIMORFISMO es la cualidad de implementar de forma particular algunas de las características que tienen las clases, de forma que cuando necesitemos usarlas no nos preocupe la implementación interna que cada una tenga, lo que realmente nos interesa o nos debe importar es que podemos usar esas características e incluso podamos acceder a ellas de forma anónima... o casi.

8

Clases

En C#, una clase es un tipo de datos muy eficaz. Como las estructuras, las clases definen los datos y el comportamiento del tipo de datos. Los programadores pueden crear objetos que son instancias de una clase. A diferencia de las estructuras, las clases admiten herencia, que es una parte fundamental de la programación orientada a objetos. Para obtener más información, vea Herencia.http://msdn.microsoft.com/es-es/library/x9afc042%28v=vs.80%29.aspx

Los términos clase y objeto se usan a veces indistintamente pero, en realidad, las clases describen el tipo de los objetos, mientras que los objetos son instancias de clases que se pueden usar. Así, la acción de crear un objeto se denomina creación de instancias. Con la analogía de plano, una clase es un plano y un objeto es un edificio construido a partir de ese plano. http://msdn.microsoft.com/es-es/library/0b0thckt.aspx

9

Clases

using System;public class myCalc{

//Constructorpublic myCalc(int x){

result = x;}

//destructor~myCalc(){

result = 0;}

//Propiedades//Métodos

}

10

Struct

Tanto Visual Basic como C# también proporcionan una versión ligera de las clases denominadas estructuras, que resultan útiles cuando es necesario crear una matriz grande de objetos y no se desea usar demasiada memoria para ello.

http://msdn.microsoft.com/es-es/library/ah19swz4.aspx

Para definir una estructura: struct SampleStruct { }

11

Diferencia Struct y Class

A diferencia de una clase y fielmente a su espíritu de “ligereza”, una estructura no puede derivar de ningún tipo y ningún tipo puede derivar de ella, por estas razones sus miembros no pueden incluir modificadores relativos a herencia, aunque con una excepción: pueden incluir override para redefinir los miembros de System.Object. Otra diferencia entre las estructuras y las clases es que sus variables no almacenan referencias a zonas de memoria dinámica donde se encuentran almacenados objetos sino directamente referencian a objetos. Por ello se dice que las clases son tipos referencia y las estructuras son tipos valor, siendo posible tanto encontrar objetos de estructuras en pila (no son campos de clases) como en memoria dinámica (son campos de clases) http://www.clikear.com/manuales/csharp/c104.aspx

12

Diferencia Struct y Class

Una primera consecuencia de esto es que los accesos a miembros de objetos de tipos valor son mucho más rápidos que los accesos a miembros de pilas, ya que es necesario pasar por una referencia menos a la hora de acceder a ellos. Además, el tiempo de creación y destrucción de estructuras también es inferior. De hecho, la destrucción de los objetos almacenados en pila es prácticamente inapreciable ya que se realiza con un simple decremento del puntero de pila y no interviene en ella el recolector de basura. Otra consecuencia de lo anterior es que cuando se realicen asignaciones entre variables de tipos valor, lo que se va a copiar en la variable destino es el objeto almacenado por la variable fuente y no la dirección de memoria dinámica a la que apuntaba ésta.

13

Diferencia Struct y Class

struct Point{

public int x, y;

public Point(int x, int y) {

this.x = x;this.y = y;

}}Si usamos este tipo en un código como el siguiente: Point p = new Point (10, 10);Point p2 = p;p2.x = 100;Console.WriteLine(p.x);

14

Diferencia Struct y Class

Lo que se mostrará por pantalla será 10. Esto se debe a que el valor de x modificado es el de p2, que es como es una copia de p los cambios que se le hagan no afectarán a p. Sin embargo, si Punto hubiese sido definido como una clase entonces sí que se hubiese mostrado por pantalla 100, ya que en ese caso lo que se habría copiado en p2 habría sido una referencia a la misma dirección de memoria dinámica referenciada por p, por lo que cualquier cambio que se haga en esa zona a través de p2 también afectará a p.

De lo anterior se deduce que la asignación entre objetos de tipos estructuras es mucho más lenta que la asignación entre objetos de clases, ya que se ha de copiar un objeto completo y no solo una referencia. Para aliviar esto al pasar objetos de tipos estructura como parámetros, se da la posibilidad de pasarlos como parámetros por referencia (modificador ref) o parámetros de salida (out) en vez de como parámetros de entrada.

15

Diferencia Struct y Class

Todas las estructuras derivan implícitamente del tipo System.ValueType, que a su vez deriva de la clase primigenia System.Object. ValueType tiene los mismos miembros que su padre, y la única diferencia señalable entre ambos es que en ValueType se ha redefinido Equals() de modo que devuelva true si los objetos comparados tienen el mismo valor en todos sus campos y false si no. Es decir, la comparación entre estructuras con Equals() se realiza por valor.

Respecto a la implementación de la igualdad en los tipos definidos como estructuras, también es importante tener muy en cuenta que el operador == no es en principio aplicable a las estructuras que defina el programador. Si se desea que lo tenga ha de dársele explícitamente una redefinición al definir dichas estructuras.

16

Miembros de Clase

Cada clase puede tener distintos miembros de clase, entre los que se incluyen las propiedades que describen los datos de clase, los métodos que definen el comportamiento de la clase y los eventos que proporcionan comunicación entre distintos objetos y clases.

Propiedades y camposLos campos y propiedades representan información que contiene un objeto. Los campos se parecen a las variables ya que se pueden leer y establecer directamente.

17

Campos

Los campos se parecen a las variables ya que se pueden leer y establecer directamente.

Class SampleClass {

public string sampleField; }

18

Propiedades

Las propiedades tienen procedimientos get y set, que proporcionan un mayor control sobre la forma en que se establecen o devuelven los valores. Tanto C# como Visual Basic permiten crear un campo privado para almacenar el valor de propiedad o bien usar las denominadas propiedades de implementación automática que crean este campo en segundo plano automáticamente y proporcionan la lógica básica para los procedimientos de propiedad.

http://msdn.microsoft.com/es-es/library/ms228503.aspxhttp://msdn.microsoft.com/es-es/library/ms228368.aspx

19

Propiedadespublic string FullName {

get {

return this.name; } set {

this.name = value; }

}

Console.WriteLine("Nombre completo: " + worker.FullName);

worker.FullName = "Jayne Lafayette";

20

Propiedades - GetLa palabra clave get define un método de descriptor de acceso en una propiedad o indizador que recupera el valor de la propiedad o del elemento del indizador.

class TimePeriod{

private double _seconds;public double Seconds{

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

}}

Éste es un ejemplo de un descriptor de acceso get en una propiedad autoimplementada:

class TimePeriod2{ public double Hours { get; set; }}

21

Propiedades - SetLa palabra clave set define un método de descriptor de acceso en una propiedad o indizador que asigna el valor de la propiedad o del elemento del indizador.

class TimePeriod{

private double _seconds;public double Seconds{

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

}}

Éste es un ejemplo de un descriptor de acceso set en una propiedad autoimplementada:

class TimePeriod2{ public double Hours { get; set; }}

22

Métodos•Un método es una acción que un objeto puede realizar.•En la mayoría de los casos, un método se declara dentro de una definición de clase. Sin embargo, tanto Visual Basic como C# también admiten los métodos de extensión, que permiten agregar métodos a una clase existente fuera de la definición de la clase en sí. •Un método es un bloque de código que contiene una serie de instrucciones. Los programas hacen que las instrucciones se ejecuten mediante una llamada al método y la especificación de los argumentos de método necesarios. En C#, cada instrucción se ejecuta en el contexto de un método. El método Main es el punto de entrada de cada aplicación C# al que llama Common Language Runtime (CLR) cuando se inicia el programa. http://msdn.microsoft.com/es-es/library/ms173114.aspx

class SampleClass{ public int sampleMethod(string sampleParam) { // Insert code here }}

23

Métodosusing System;

public class myCalc{ public void displayResult() { Console.WriteLine("Result = {0}", result); } public void add(int x) { result = result + x; } public void subtract(int x) { result = result – x; } }

24

Firmas de Métodos

Los métodos se declaran en una clase o struct mediante la especificación del nivel de acceso como public o private, modificadores opcionales como abstract o sealed, el valor devuelto, el nombre del método y cualquier parámetro de método. Todos esos elementos constituyen la firma del método.

Un tipo de valor devuelto desde un método no forma parte de su firma a efectos de la sobrecarga de métodos. Sin embargo, sí forma parte de la firma del método a la hora de determinar la compatibilidad entre un delegado y el método al que apunta.

25

Métodos

Los parámetros del método se encierran entre paréntesis y se separan por comas. Los paréntesis vacíos indican que el método no requiere ningún parámetro. Esta clase contiene tres métodos:

abstract class Motorcycle{ // Anyone can call this. public void StartEngine() {/* Method statements here */ }

// Only derived classes can call this. protected void AddGas(int gallons) { /* Method statements here */ }

// Derived classes can override the base class implementation. public virtual int Drive(int miles, int speed) { /* Method statements here */ return 1; }

// Derived classes must implement this. public abstract double GetTopSpeed(); }

26

Acceso al MétodoLlamar a un método de un objeto es como obtener acceso a un campo. Después del nombre de objeto, agregue un punto, el nombre del método y paréntesis. Los argumentos se colocan entre paréntesis y separados por comas. Por tanto, se puede llamar a los métodos de la clase Motorcycle como en el ejemplo siguiente:

class TestMotorcycle : Motorcycle{ public override double GetTopSpeed() { return 108.4; }

static void Main() { TestMotorcycle moto = new TestMotorcycle(); moto.StartEngine(); moto.AddGas(15); moto.Drive(5, 20); double speed = moto.GetTopSpeed(); Console.WriteLine("My top speed is {0}", speed); }}

27

Acceso al Método

Los métodos de extensión permiten "agregar" métodos a los tipos existentes sin necesidad de crear un nuevo tipo derivado y volver a compilar o sin necesidad de modificar el tipo original. Los métodos de extensión constituyen un tipo especial de método estático, pero se les llama como si se tratasen de métodos de instancia en el tipo extendido. En el caso del código de cliente escrito en C# y Visual Basic, no existe ninguna diferencia aparente entre llamar a un método de extensión y llamar a los métodos realmente definidos en un tipo.

Los métodos de extensión más comunes son los operadores de consulta estándar de LINQ que agregan funcionalidad de consulta a los tipos System.Collections.IEnumerable y System.Collections.Generic.IEnumerable<T> existentes. Para usar los operadores de consulta estándar, primero inclúyalos en el ámbito con una directiva using System.Linq. Después, cualquier tipo que implemente IEnumerable<T> parecerá tener métodos de instancia como GroupBy, OrderBy, Average, etc. Puede ver estos métodos adicionales con la característica de finalización de instrucciones IntelliSense al escribir un "punto" después de una instancia de un tipo IEnumerable<T> como List<T> o Array. En el ejemplo siguiente se muestra cómo llamar al método de operador de consulta estándar OrderBy en una matriz de enteros. La expresión entre paréntesis es una expresión lambda. Muchos operadores de consulta estándar usan expresiones lambda como parámetros, pero no es obligatorio para los métodos de extensión. Para obtener más información, vea Expresiones lambda (Guía de programación de C#). http://msdn.microsoft.com/es-es/library/bb383977.aspx

28

Acceso al Método

class ExtensionMethods2 {

static void Main() { int[] ints = { 10, 45, 15, 39, 21, 26 }; var result = ints.OrderBy(g => g); foreach (var i in result) { System.Console.Write(i + " "); } } }//Output: 10 15 21 26 39 45

29

Métodos - Sobrecarga

Una clase puede tener varias implementaciones o sobrecargas del mismo método que se diferencian en el número de parámetros o de tipos de parámetro.

public int sampleMethod(string sampleParam) {}; public int sampleMethod(int sampleParam) {}

30

Métodos - Sobrecarga

public class ComplexNumber {

public ComplexNumber(){}public ComplexNumber(int number){}public void CalcularNumero(){}public void CalcularNumero(int number){}

}

31

Redefinición de Métodos

public abstract class Car{ public abstract void RemoveAllFuses(); public abstract void StartEngine();}

class Seat : Car{ public override void RemoveAllFuses() { } public override void StartEngine() { }}

class MyCar : Seat{ static void Main(string[] args) { MyCar c= new MyCar(); try { c.RemoveAllFuses(); } catch (Exception e) { System.Console.WriteLine(e.Message); } }}

32

Método Virtual

La palabra clave virtual se utiliza para modificar un método, propiedad, indizador o declaración de evento y permite reemplazar a cualquiera de estos en una clase derivada. En el siguiente ejemplo, cualquier clase que hereda este método puede reemplazarlo:

public virtual double Area() { return x * y; }

La implementación de un miembro virtual puede reemplazarse por un miembro de reemplazo de una clase derivada.

Cuando se invoca un método virtual, el tipo en tiempo de ejecución del objeto se comprueba para ver si existe un miembro de reemplazo. Se realiza una llamada al miembro de reemplazo que está en la clase de mayor derivación, el cual puede ser el miembro original, si no existe ninguna clase derivada que haya reemplazado el miembro.

33

Método Virtual

De forma predeterminada, los métodos son no virtuales. No se puede reemplazar un método no virtual.No puede utilizar el modificador virtual con los modificadores static, abstract, private u override.Las propiedades virtuales funcionan como los métodos abstractos, salvo en lo que se refiere a las diferencias en la sintaxis de las declaraciones e invocaciones.Es incorrecto utilizar el modificador virtual para una propiedad estática.Una propiedad virtual heredada se puede reemplazar en una clase derivada si se incluye una declaración de propiedad que use el modificador override.

http://msdn.microsoft.com/es-es/library/9fkccyh4%28v=vs.80%29.aspx

34

Método Virtualusing System;class TestClass {

public class Square {

public double x;// Constructor:public Square(double x) {this.x = x;}public virtual double Area() {return x*x; }

}

35

Método Virtualclass Cube: Square {

// Constructor:public Cube(double x): base(x) {}// Calling the Area base method:public override double Area() {return (6*(base.Area())); }

}public static void Main(){

double x = 5.2;Square s = new Square(x);Square c = new Cube(x);Console.WriteLine("Area of Square = {0:F2}", s.Area());Console.WriteLine("Area of Cube = {0:F2}", c.Area());

}}

36

Argumento por Valor

La palabra clave ref produce argumentos que se van a pasar por referencia. El efecto es que cualquier cambio que se realice en el parámetro dentro del método se reflejará en esa variable cuando se devuelva el control al método que realizó la llamada. Para utilizar un parámetro ref, la definición de método y el método de llamada deben utilizar explícitamente la palabra clave ref. http://msdn.microsoft.com/es-es/library/14akc2c7%28v=vs.80%29.aspx

Por ejemplo:

class RefExample {

static void Method(ref int i) { i = 44; } static void Main() {

int val = 0; Method(ref val); // val is now 44

} }

37

Argumento por Valor

Como se mostró anteriormente, el paso de tipos de valor por referencia es útil, pero ref también es útil para pasar los tipos de referencia. Esto permite a los métodos llamados modificar el objeto al que se refiere la referencia porque la propia referencia se pasa por referencia. El ejemplo siguiente muestra que cuando un tipo de referencia se pasa como parámetro ref, se puede cambiar el objeto mismo.

class RefRefExample{ static void Method(ref string s) { s = "changed"; } static void Main() { string str = "original"; Method(ref str); // str is now "changed" }}

38

Constructor

Los constructores son métodos de clase que se ejecutan automáticamente cuando se crea un objeto de un tipo determinado. Normalmente, los constructores inicializan los miembros de datos del nuevo objeto. Un constructor solo puede ejecutarse una vez cuando se crea una clase. Además, el código del constructor siempre se ejecuta antes que cualquier otro código en una clase. Sin embargo, puede crear varias sobrecargas del constructor de la misma forma que para cualquier otro método. http://msdn.microsoft.com/es-es/library/ace5hbzh.aspx

Para definir un constructor para una clase:

public class SampleClass{ public SampleClass() { // Add code here }}

39

Constructor

Cada vez que se crea una clase o struct, se llama a su constructor. Una clase o struct puede tener varios constructores que toman argumentos diferentes. Los constructores permiten al programador establecer valores predeterminados, limitar la creación de instancias y escribir código flexible y fácil de leer.

Si no proporciona un constructor para el objeto, C# creará uno de forma predeterminada que cree instancias del objeto y establezca las variables miembro en los valores predeterminados que se indican en: Tabla de valores predeterminados (Referencia de C#). Las clases y structs estáticos también pueden tener constructores.

40

Destructor

Los destructores se utilizan para destruir instancias de clases. En .NET Framework, el recolector de elementos no utilizados administra automáticamente la asignación y la liberación de memoria para los objetos administrados en la aplicación. Sin embargo, es posible que aún se necesiten destructores para limpiar cualquiera de los recursos no administrados creados por la aplicación. Solo puede haber un destructor para una clase. http://msdn.microsoft.com/es-es/library/66x5fx1b%28v=vs.80%29.aspx

class Car{ ~ Car() // destructor { // cleanup statements... }}

41

Destructor

Los destructores no se pueden definir en estructuras. Sólo se utilizan con clases.Una clase sólo puede tener un destructor.Los destructores no se pueden heredar ni sobrecargar.No se puede llamar a los destructores. Se invocan automáticamente.Un destructor no permite modificadores de acceso ni tiene parámetros.

El destructor llama implícitamente al método Finalize en la case base del objeto. Por lo tanto, el código de destructor anterior se traduce implícitamente a:protected override void Finalize(){ try { // cleanup statements... } finally { base.Finalize(); }}

42

Eventos

Cuando ocurre algo interesante, los eventos habilitan una clase u objeto para notificarlo a otras clases u objetos. La clase que envía (o genera) el evento recibe el nombre de publicador y las clases que reciben (o controlan) el evento se denominan suscriptores. Para obtener más información sobre los eventos y la forma en que se generan y controlan, vea Controlar y provocar eventos.

La palabra clave event se utiliza para declarar un evento en una clase de editor.

Para declarar un evento en una clase, use la palabra clave event (Referencia de C#). Para generar un evento, invoque al delegado de eventos. Para suscribirse a un evento, use el operador +=; para anular la suscripción de un evento, use el operador -=.

El ejemplo siguiente muestra cómo declarar y generar un evento que utiliza EventHandler como tipo de delegado subyacente. Para obtener el ejemplo de código completo que muestra también cómo utilizar el tipo de delegado genérico EventHandler<TEventArgs> y cómo suscribirse a un evento y crear un método de control de eventos, vea Cómo: Publicar eventos que cumplan las directrices de .NET Framework (Guía de programación de C#). http://msdn.microsoft.com/es-es/library/8627sbea.aspx

43

Eventos

public class SampleEventArgs{

public SampleEventArgs(string s) { Text = s; }public String Text {get; private set;} // readonly

}public class Publisher{

// Declare the delegate (if using non-generic pattern).public delegate void SampleEventHandler(object sender, SampleEventArgs e);// Declare the event.public event SampleEventHandler SampleEvent;// Wrap the event in a protected virtual method// to enable derived classes to raise the event.protected virtual void RaiseSampleEvent(){

// Raise the event by using the () operator.if (SampleEvent != null)

SampleEvent(this, new SampleEventArgs("Hello"));}

}

44

Clases Anidadas

Una clase definida dentro de otra se denomina anidada. De forma predeterminada, una clase anidada es privada.

class Container{ class Nested { // Add code here. }}

Para crear una instancia de la clase anidada, use el nombre de la clase contenedora seguido de un punto y seguido, a continuación, del nombre de la clase anidada:

Container.Nested nestedInstance = new Container.Nested()

45

Modificadores y Niveles de Acceso

Todas las clases y miembros de clase pueden especificar el nivel de acceso que proporcionan a otras clases mediante los modificadores de acceso. Están disponibles los siguientes modificadores de acceso:

46

Public

La palabra clave public es un modificador de acceso para tipos y miembros de tipos. El acceso de tipo public corresponde al nivel de acceso menos restrictivo. No existen restricciones para obtener acceso a los miembros públicos, como en el siguiente ejemplo:

http://msdn.microsoft.com/es-es/library/yzh058ae%28v=vs.80%29.aspx

En el siguiente ejemplo, se declaran dos clases, Point y MainClass. El acceso a los miembros públicos x e y de Point se realiza directamente desde MainClass.

47

Public

// protected_public.cs// Public accessusing System;class Point{ public int x; public int y;}

class MainClass{ static void Main() { Point p = new Point(); // Direct access to public members: p.x = 10; p.y = 15; Console.WriteLine("x = {0}, y = {1}", p.x, p.y); }}

48

Public

Resultado:

x = 10, y = 15 Si se cambia el nivel de acceso de public a private o protected, se aparecerá el siguiente mensaje de error:'Point.y' is inaccessible due to its protection level.

49

Private

La palabra clave private es un modificador de acceso de miembros. El acceso de tipo private corresponde al nivel de acceso más restrictivo. Los miembros privados sólo son accesibles dentro del cuerpo de la clase o estructura en la que se declaran.

Los tipos anidados del mismo cuerpo también pueden tener acceso a esos miembros privados.Hacer referencia a un miembro privado fuera de la clase o estructura en la que se declara produce un error de compilación.

http://msdn.microsoft.com/es-es/library/st6sy9xe%28v=vs.80%29.aspx

EjemploEn este ejemplo, la clase Employee contiene dos miembros de datos privados, name y salary. Como miembros privados, sólo pueden tener acceso a ellos los métodos miembro; por tanto, hay que agregar los métodos públicos denominados GetName y Salary para permitir el acceso controlado a los miembros privados. Se tiene acceso al miembro name a través del método público y se tiene acceso al miembro salary a través de una propiedad pública de sólo lectura. (Vea Propiedades (Guía de programación de C#) para obtener más información.)

50

Private

// private_keyword.csusing System;class Employee{ private string name = "FirstName, LastName"; private double salary = 100.0;

public string GetName() { return name; }

public double Salary { get { return salary; } }}

51

Private

class MainClass{ static void Main() { Employee e = new Employee();

// The data members are inaccessible (private), so // then can't be accessed like this: // string n = e.name; // double s = e.salary;

// 'name' is indirectly accessed via method: string n = e.GetName();

// 'salary' is indirectly accessed via property double s = e.Salary; }}

52

Protected

La palabra clave protected es un modificador de acceso a miembros. Un miembro protegido es accesible dentro de su clase y por clases derivadas. http://msdn.microsoft.com/es-es/library/bcd5672a%28v=vs.80%29.aspx

Un miembro protegido de una clase base es accesible en una clase derivada sólo si el acceso se realiza a través del tipo de la clase derivada.

Por ejemplo, considere el siguiente segmento de código:

// protected_keyword.csusing System;class A{ protected int x = 123;}

53

Protected

class B : A{ static void Main() { A a = new A(); B b = new B();

// Error CS1540, because x can only be accessed by // classes derived from A. // a.x = 10; // OK, because this class derives from A. b.x = 10; }}

54

Protected

Resultado:

La instrucción a.x =10 genera un error, ya que A no se deriva de B.Los miembros de una estructura no se pueden proteger, ya que la estructura no se puede heredar.

55

Protected

Resultado:

La instrucción a.x =10 genera un error, ya que A no se deriva de B.Los miembros de una estructura no se pueden proteger, ya que la estructura no se puede heredar.

56

Internal

La palabra clave internal es un modificador de acceso para tipos y miembros de tipos. Los tipos o miembros internos sólo son accesibles dentro de los archivos del mismo ensamblado.http://msdn.microsoft.com/es-es/library/7c5ka91b%28v=vs.80%29.aspx

Un uso habitual del acceso de tipo interno se da en el desarrollo basado en componentes, ya que permite a un grupo de componentes cooperar de manera privada sin estar expuesto al resto del código de la aplicación. Por ejemplo, una estructura para crear interfaces gráficas de usuario podría proporcionar clases Control y Form que cooperan mediante miembros con acceso de tipo internal. Como estos miembros son internos, no están expuestos al código que utiliza la estructura.

Si se hace referencia a un tipo o miembro con acceso interno fuera del ensamblado en el que se definió, produce un error.

El método internal virtual puede reemplazarse en algunos lenguajes, como en el Lenguaje intermedio de Microsoft (MSIL) textual mediante Ilasm.exe, aunque no se pueda reemplazar utilizando C#.

57

Internal

Este ejemplo contiene dos archivos, Assembly1.cs y Assembly2.cs. El primer archivo contiene una clase base interna, BaseClass. En el segundo archivo, un intento de crear instancias BaseClass generará un error.

// Assembly1.cs// compile with: /target:libraryinternal class BaseClass { public static int intM = 0;}

58

Internal

// Assembly1_a.cs// compile with: /reference:Assembly1.dllclass TestAccess { static void Main() { BaseClass myBase = new BaseClass(); // CS0122 }}

59

Internal

En este ejemplo, utilice los mismos archivos que utilizó en el ejemplo anterior y cambie el nivel de accesibilidad de BaseClass a public. Además cambie el nivel de accesibilidad del miembro IntM a internal. En este caso, puede crear instancias de la clase, pero no puede tener acceso al miembro interno.

// Assembly2.cs// compile with: /target:librarypublic class BaseClass { internal static int intM = 0;}

60

Internal

// Assembly2_a.cs// compile with: /reference:Assembly1.dllpublic class TestAccess { static void Main() { BaseClass myBase = new BaseClass(); // Ok. BaseClass.intM = 444; // CS0117 }}

61

Accesibilidad a Class y Struct

Las clases y struct declarados directamente en un espacio de nombres (es decir, que no se anidan dentro de otras clases o structs) pueden ser públicos o internos. Si no se especifica un modificador de acceso, internal es el valor predeterminado.

Los miembros de struct, incluyendo clases y structs anidados, pueden declararse como públicos, internos o privados. Los miembros de clase (incluyendo clases y structs anidados) pueden ser públicos, internos protegidos, protegidos, internos o privados. El nivel de acceso para los miembros de clase y los miembros de struct, incluyendo clases y structs anidados, es privado de forma predeterminada. No se puede obtener acceso a tipos anidados privados desde fuera del tipo contenedor.

Las clases derivadas no pueden tener mayor accesibilidad que sus tipos base. En otras palabras, no puede tener una clase pública B que se derive de una clase interna A. Si se permitiera, A se haría pública, porque se puede obtener acceso a todos los miembros internos o protegidos de A desde la clase derivada.

62

Creación de Instancias de las Clases - Objetos

Para crear un objeto, debe crear una o varias instancias de una clase.

SampleClass sampleObject = new SampleClass();

Una vez creadas las instancias de una clase, puede asignar valores a las propiedades y los campos de la instancia, así como invocar métodos de clase.

// Set a property value.sampleObject.sampleProperty = "Sample String";// Call a method.sampleObject.sampleMethod();

// Set a property value.SampleClass sampleObject = new SampleClass { FirstProperty = "A", SecondProperty = "B" };

63

Objetos

using System;public class myCalc{

myCalc mC = new myCalc(90);mC.displayResult();mC.add(45);mC.displayResult();mC.subtract(35);mC.displayResult();mC.subtract(110);mC.displayResult();

}

64

Clases y Miembros Estáticos (Compartidos)

Las clases estáticas (compartidas) de C# y los módulos de Visual Basic solamente tienen miembros estáticos (compartidos) y no se pueden crear instancias de los mismos. Además, los miembros estáticos (compartidos) tampoco pueden tener acceso a las propiedades, los campos o los métodos no estáticos (no compartidos).

65

Clases y Miembros Estáticos (Compartidos)

Utilice el modificador static para declarar un miembro estático, que pertenece al propio tipo en vez de a un objeto específico. El modificador static puede utilizarse con clases, campos, métodos, propiedades, operadores, eventos y constructores, pero no puede utilizarse con indizadores, destructores o tipos que no sean clases.http://msdn.microsoft.com/es-es/library/98f28cdx.aspx

static class CompanyEmployee{

public static void DoSomething() { /*...*/ }public static void DoSomethingElse() { /*...*/ }

}

66

Clases y Miembros Estáticos (Compartidos)

Una declaración de constante o tipo constituye, implícitamente, un miembro estático. No se puede hacer referencia a un miembro estático por medio de una instancia. En vez de ello, se debe hacer referencia por medio del nombre de tipo. Por ejemplo, considere la siguiente clase:

public class MyBaseC{

public struct MyStruct{

public static int x = 100;}

}

67

Clases y Miembros Estáticos (Compartidos)

Para referirse al miembro estático x, use el nombre completo, MyBaseC.MyStruct.x, a menos que el miembro sea accesible desde el mismo ámbito:

Console.WriteLine(MyBaseC.MyStruct.x);

68

Clases y Miembros Estáticos (Compartidos)

Mientras que una instancia de una clase contiene una copia independiente de todos los campos de instancia de la clase, sólo existe una copia de cada campo estático.

No es posible utilizar this para hacer referencia a descriptores de acceso de propiedades o métodos static.

Si la palabra clave static se aplica a una clase, todos los miembros de la clase deben ser estáticos.

Las clases y las clases estáticas pueden tener constructores estáticos. Se llama a los constructores estáticos en algún momento comprendido entre el inicio del programa y la creación de instancias de la clase.

69

Tipos Anónimos

Los tipos anónimos ofrecen un modo útil de encapsular un conjunto de propiedades de solo lectura en un único objeto sin tener que definir antes un tipo de forma explícita. El compilador genera el nombre de tipo y no está disponible en el nivel de código fuente. El compilador deduce el tipo de cada propiedad. Para crear tipos anónimos, use el operador new junto con un inicializador de objeto.En el ejemplo siguiente se muestra un tipo anónimo que se inicializa con dos propiedades denominadas Amount y Message.http://msdn.microsoft.com/es-es/library/bb397696.aspx

var v = new { Amount = 108, Message = "Hello" };

// Rest the mouse pointer over v.Amount and v.Message in the following// statement to verify that their inferred types are int and string.Console.WriteLine(v.Amount + v.Message);

70

Herencia

La herencia permite crear una nueva clase que reutiliza, extiende y modifica el comportamiento que se define en otra clase. La clase cuyos miembros se heredan se denomina clase base y la clase que hereda esos miembros se denomina clase derivada. Sin embargo, todas las clases de C# y Visual Basic heredan implícitamente de la clase Object que admite la jerarquía de clases .NET y proporciona servicios de bajo nivel a todas las clases.

Los lenguajes administrados de .NET Framework no admiten la herencia múltiple, es decir, solo se puede especificar una clase base para una clase derivada.

71

Herencia

Para heredar de una clase base:class DerivedClass:BaseClass{}

De forma predeterminada, todas las clases se pueden heredar. Sin embargo, puede especificar si una clase no se debe usar como clase base o bien crear una clase que solo se pueda usar como clase base.

Para especificar que una clase no se puede usar como clase base:http://msdn.microsoft.com/es-es/library/88c54tsw.aspx

public sealed class A { }

Para especificar que una clase se puede usar solo como clase base y no se pueden crear instancias de esta:http://msdn.microsoft.com/es-es/library/sf985hc5.aspx

public abstract class B { }

72

Herencia

Las clases pueden heredar de otra clase. Para conseguir esto, se coloca un signo de dos puntos después del nombre de la clase al declarar la clase y se denomina la clase de la cual se hereda (la clase base) después del signo de dos puntos, del modo siguiente:http://msdn.microsoft.com/es-es/library/ms173149%28v=vs.80%29.aspx

public class A{ public A() { }}public class B : A{ public B() { }}

73

Reemplazar MiembrosDe forma predeterminada, una clase derivada hereda todos los miembros de su clase base. Si desea cambiar el comportamiento del miembro heredado, debe invalidarlo. Es decir, se puede definir una nueva implementación del método, la propiedad o el evento en la clase derivada. Los siguientes modificadores se utilizan para controlar cómo se reemplazan propiedades y métodos:

74

Reemplazar Miembros - Virtual

La palabra clave virtual se utiliza para modificar un método, propiedad, indizador o declaración de evento y permite invalidar cualquiera de estos elementos en una clase derivada.

http://msdn.microsoft.com/es-es/library/9fkccyh4.aspx

La implementación de un miembro virtual puede reemplazarse por un miembro de reemplazo de una clase derivada.

75

Reemplazar Miembros - VirtualCuando se invoca un método virtual, el tipo en tiempo de ejecución del objeto se comprueba para ver si existe un miembro de reemplazo. Se realiza una llamada al miembro de reemplazo que está en la clase de mayor derivación, el cual puede ser el miembro original, si no existe ninguna clase derivada que haya reemplazado el miembro.

De forma predeterminada, los métodos son no virtuales. No se puede reemplazar un método no virtual.

No puede utilizar el modificador virtual con los modificadores static, abstract, private u override.

En el ejemplo siguiente, se muestra una propiedad virtual:

76

Reemplazar Miembros - Virtualclass TestClass{ public class Dimensions { public const double PI = Math.PI; protected double x, y; public Dimensions() { } public Dimensions(double x, double y) { this.x = x; this.y = y; }

public virtual double Area() { return x * y; } }

77

Reemplazar Miembros - Virtual

public class Circle : Dimensions { public Circle(double r) : base(r, 0) { }

public override double Area() { return PI * x * x; } }

class Sphere : Dimensions { public Sphere(double r) : base(r, 0) { }

78

Reemplazar Miembros - Virtual public override double Area() { return 4 * PI * x * x; } }

class Cylinder : Dimensions { public Cylinder(double r, double h) : base(r, h) { }

public override double Area() { return 2 * PI * x * x + 2 * PI * x * y; } }

79

Reemplazar Miembros - Virtual

static void Main() { double r = 3.0, h = 5.0; Dimensions c = new Circle(r); Dimensions s = new Sphere(r); Dimensions l = new Cylinder(r, h); // Display results: Console.WriteLine("Area of Circle = {0:F2}", c.Area()); Console.WriteLine("Area of Sphere = {0:F2}", s.Area()); Console.WriteLine("Area of Cylinder = {0:F2}", l.Area()); } } /* Output: Area of Circle = 28.27 Area of Sphere = 113.10 Area of Cylinder = 150.80 */

80

Reemplazar Miembros - OverrideEl modificador override es necesario para ampliar o modificar la implementación abstracta o virtual de un método, propiedad, indizador o evento heredado.

http://msdn.microsoft.com/es-es/library/ebca9ah3.aspx

Un método override proporciona una nueva implementación de un miembro que se hereda de una clase base. El método invalidado por una declaración override se conoce como método base invalidado. El método base reemplazado debe tener la misma firma que el método override. Para obtener más información sobre la herencia, vea Herencia (Guía de programación de C#).

No se puede reemplazar un método estático o no virtual. El método base reemplazado debe ser virtual, abstract u override.

81

Reemplazar Miembros - OverrideUna declaración override no puede cambiar la accesibilidad del método virtual. El método override y el método virtual deben tener el mismo modificador de nivel de acceso.

No se pueden usar los modificadores new, static o virtual para modificar un método override.

Una declaración de propiedad de invalidación debe especificar exactamente el mismo modificador de acceso, tipo y nombre que la propiedad heredada, y la propiedad invalidada debe ser virtual, abstract u override.

El siguiente ejemplo define una clase base denominada Employee y una clase derivada denominada SalesEmployee. La clase SalesEmployee incluye una propiedad adicional, salesbonus, e invalida el método CalculatePay para tenerlo en cuenta.

82

Reemplazar Miembros - Overrideclass TestOverride{ public class Employee { public string name;

// Basepay is defined as protected, so that it may be // accessed only by this class and derrived classes. protected decimal basepay;

// Constructor to set the name and basepay values. public Employee(string name, decimal basepay) { this.name = name; this.basepay = basepay; }

// Declared virtual so it can be overridden. public virtual decimal CalculatePay() { return basepay; } }

83

Reemplazar Miembros - Override // Derive a new class from Employee. public class SalesEmployee : Employee { // New field that will affect the base pay. private decimal salesbonus;

// The constructor calls the base-class version, and // initializes the salesbonus field. public SalesEmployee(string name, decimal basepay, decimal salesbonus) : base(name, basepay) { this.salesbonus = salesbonus; }

// Override the CalculatePay method // to take bonus into account. public override decimal CalculatePay() { return basepay + salesbonus; } }

84

Reemplazar Miembros - Overridestatic void Main() { // Create some new employees. SalesEmployee employee1 = new SalesEmployee("Alice", 1000, 500); Employee employee2 = new Employee("Bob", 1200);

Console.WriteLine("Employee4 " + employee1.name + " earned: " + employee1.CalculatePay()); Console.WriteLine("Employee4 " + employee2.name + " earned: " + employee2.CalculatePay()); }}/* Output: Employee4 Alice earned: 1500 Employee4 Bob earned: 1200*/

85

Reemplazar Miembros - AbstractEl modificador abstract indica que el elemento objeto de la modificación tiene una implementación incompleta o que le falta una implementación. El modificador abstract se puede usar con clases, métodos, propiedades, indizadores y eventos. Use el modificador abstract en una declaración de clase para indicar que la clase sólo se puede utilizar como clase base de otras clases. Los miembros que están marcados como abstractos o que se incluyen en una clase abstracta, deben ser implementados por clases derivadas de la clase abstracta.Las clases de tipo abstract presentan las siguientes características: •No se pueden crear instancias de una clase abstracta.

•Una clase abstracta puede contener descriptores de acceso y métodos abstractos.

•No se puede modificar una clase abstracta con el modificador sealed (Referencia de C#) porque los dos modificadores tienen significados opuestos. El modificador sealed evita la herencia de una clase y el modificador abstract requiere la herencia de una clase.

86

Reemplazar Miembros - Abstract•Una clase no abstracta derivada de una clase abstracta debe incluir implementaciones reales de todos los descriptores de acceso y métodos abstractos heredados.

•Utilice el modificador abstract en una declaración de método o propiedad para indicar que el método o la propiedad no contienen implementación.

•Los métodos abstractos presentan las siguientes características:

•Un método abstracto es, implícitamente, un método virtual.

•Las declaraciones de métodos abstractos sólo se permiten en clases abstractas.

87

Reemplazar Miembros - Abstract

•Debido a que una declaración de método abstracto no proporciona una implementación, no existe cuerpo del método; la declaración de método finaliza simplemente con un punto y coma y sin llaves ({ }) después de la firma. Por ejemplo:

public abstract void MyMethod();

La implementación la proporciona un método de reemplazooverride (Referencia de C#), que es miembro de una clase no abstracta.

•Utilizar los modificadores static o virtual en una declaración de método abstracto produce un error.

88

Reemplazar Miembros - AbstractLas propiedades abstractas funcionan como los métodos abstractos, salvo las diferencias en la sintaxis de las declaraciones y llamadas. Es incorrecto utilizar el modificador abstract para una propiedad estática. Una propiedad abstracta heredada se puede reemplazar en una clase derivada si se incluye una declaración de propiedad que utilice el modificador override. Una clase abstracta debe proporcionar implementaciones para todos los miembros de la interfaz. Una clase abstracta que implementa una interfaz podría asignar los métodos de la interfaz a métodos abstractos. Por ejemplo:

interface I{ void M();}abstract class C : I{ public abstract void M();}

89

Reemplazar Miembros - AbstractEn este ejemplo, la clase DerivedClass se deriva de una clase abstracta BaseClass. La clase abstracta contiene un método abstracto, AbstractMethod, y dos propiedades abstractas, X y Y.

abstract class BaseClass // Abstract class{

protected int _x = 100;protected int _y = 150;public abstract void AbstractMethod(); // Abstract methodpublic abstract int X { get; }public abstract int Y { get; }

}

90

Reemplazar Miembros - Abstractclass DerivedClass : BaseClass{

public override void AbstractMethod(){

_x++;_y++;

}

public override int X // overriding property{

get{

return _x + 10;}

}

91

Reemplazar Miembros - Abstractpublic override int Y // overriding property{

get{

return _y + 10;}

}

static void Main(){

DerivedClass o = new DerivedClass();o.AbstractMethod();Console.WriteLine("x = {0}, y = {1}", o.X, o.Y);

}}// Output: x = 111, y = 161

92

Reemplazar Miembros - Abstract

En el ejemplo anterior, si intenta crear una instancia de la clase abstracta mediante una instrucción como la siguiente:

BaseClass bc = new BaseClass(); // Error

se obtendrá un error que indica que el compilador no puede crear una instancia de la clase abstracta 'BaseClass'.

93

Reemplazar Miembros - New

Cuando se utiliza como modificador, la palabra clave new oculta explícitamente un miembro heredado de una clase base. Cuando oculta un miembro heredado, la versión derivada del miembro reemplaza a la versión de la clase base. Aunque puede ocultar miembros sin utilizar el modificador new, el resultado es una advertencia. Si utiliza new para ocultar explícitamente un miembro, suprime esta advertencia y documenta el hecho de que la versión derivada está concebida como un reemplazo.

Para ocultar un miembro heredado, declárelo en la clase derivada con el mismo nombre y modifíquelo con el modificador new.

Vea el siguiente ejemplo:

94

Reemplazar Miembros - New

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

En este ejemplo, DerivedC.Invoke oculta BaseC.Invoke. El campo x no se ve afectado porque no lo oculta un nombre similar.

95

Reemplazar Miembros - NewLa ocultación de nombres por medio de la herencia toma una de las siguientes formas:

Constante, campo, propiedad o tipo introducido en una clase o struct que oculta todos los miembros de la clase base con el mismo nombre.

Método introducido en una clase o struct que oculta propiedades, campos y tipos, con el mismo nombre, en la clase base. También oculta todos los métodos de la clase base con la misma firma.

Indizador introducido en una clase o struct que oculta todos los indizadores de la clase base con la misma firma.Es un error utilizar new y override en el mismo miembro porque los dos modificadores tienen significados mutuamente excluyentes. El modificador new crea un nuevo miembro con el mismo nombre y oculta el miembro original. El modificador override amplía la implementación de un miembro heredado.

Si se utiliza el modificador new en una declaración que no oculta un miembro heredado, se genera una advertencia.

96

Reemplazar Miembros - NewEn este ejemplo, una clase anidada oculta una clase que tiene el mismo nombre en la clase base. El ejemplo muestra cómo utilizar el modificador new para eliminar el mensaje de advertencia y cómo obtener acceso a los miembros de la clase oculta mediante sus nombres completos.

public class BaseC { public class NestedC { public int x = 200; public int y; }}public class DerivedC : BaseC { // Nested type hiding the base type members. new public class NestedC { public int x = 100; public int y; public int z; }

97

Reemplazar Miembros - Newstatic void Main() { // Creating an object from the overlapping class: NestedC c1 = new NestedC();

// Creating an object from the hidden class: BaseC.NestedC c2 = new BaseC.NestedC();

Console.WriteLine(c1.x); Console.WriteLine(c2.x); }}/*Output:100200*/

98

InterfacesLas interfaces, como las clases, definen un conjunto de propiedades, métodos y eventos. Pero de forma contraria a las clases, las interfaces no proporcionan implementación. Se implementan como clases y se definen como entidades separadas de las clases. Una interfaz representa un contrato, en el cual una clase que implementa una interfaz debe implementar cualquier aspecto de dicha interfaz exactamente como esté definido.

http://msdn.microsoft.com/es-es/library/dd460654.aspx#Inheritance

Para definir una interfaz:

interface ISampleInterface{ void doSomething();}

99

Interfaces

Para implementar una interfaz en una clase:

class SampleClass : ISampleInterface{ void ISampleInterface.SampleMethod() { // Method implementation. }}

100

Interfaces

Una interfaz contiene solo las firmas de métodos, propiedades, eventos o indizadores. Una clase o struct que implementa la interfaz debe implementar los miembros de la interfaz que se especifican en la definición de interfaz.

En el ejemplo siguiente, la clase ImplementationClass debe implementar un método denominado SampleMethod que no tenga ningún parámetro y devuelva void.

http://msdn.microsoft.com/es-es/library/87d83y5b.aspx http://msdn.microsoft.com/es-es/library/ms173156.aspx

101

Interfacesinterface ISampleInterface{ void SampleMethod();}

class ImplementationClass : ISampleInterface{ // Explicit interface member implementation: void ISampleInterface.SampleMethod() { // Method implementation. }

static void Main() { // Declare an interface instance. ISampleInterface obj = new ImplementationClass();

// Call the member. obj.SampleMethod(); }}

102

GenéricosLas clases, las estructuras, las interfaces y los métodos de .NET Framework pueden escribir parámetros que definen los tipos de objetos que estos pueden almacenar o usar. El ejemplo más común de elementos genéricos es una colección, donde se puede especificar el tipo de objetos que se va a almacenar en una colección.

Para definir una clase genérica:

Public class SampleGeneric<T> { public T Field;}

103

GenéricosPara crear una instancia de una clase genérica:

SampleGeneric<string> sampleObject = new SampleGeneric<string>(); sampleObject.Field = "Sample string";

http://msdn.microsoft.com/es-es/library/ms172192.aspx

104

GenéricosLos tipos genéricos se agregaron a la versión 2.0 del lenguaje C# y Common Language Runtime (CLR). Estos tipos agregan el concepto de parámetros de tipo a .NET Framework, lo cual permite diseñar clases y métodos que aplazan la especificación de uno o más tipos hasta que el código de cliente declara y crea una instancia de la clase o del método. Por ejemplo, mediante la utilización de un parámetro de tipo genérico T, se puede escribir una clase única que otro código de cliente puede utilizar sin generar el costo o el riesgo de conversiones en tiempo de ejecución u operaciones de conversión boxing, como se muestra a continuación:

http://msdn.microsoft.com/es-es/library/512aeb7t.aspx

105

Genéricos

// Declare the generic class.public class GenericList<T>{ void Add(T input) { }}class TestGenericList{ private class ExampleClass { } static void Main() { // Declare a list of type int. GenericList<int> list1 = new GenericList<int>();

// Declare a list of type string. GenericList<string> list2 = new GenericList<string>();

// Declare a list of type ExampleClass. GenericList<ExampleClass> list3 = new GenericList<ExampleClass>(); }}

106

Genéricos - VentajasLos tipos genéricos proporcionan la solución a una limitación de las versiones anteriores de Common Language Runtime y del lenguaje C#, en los que se realiza una generalización mediante la conversión de tipos a y desde el tipo base universal Object. Con la creación de una clase genérica, se puede crear una colección que garantiza la seguridad de tipos en tiempo de compilación.

Las limitaciones del uso de clases de colección no genéricas se pueden demostrar escribiendo un breve programa que utilice la clase de colección ArrayList de la biblioteca de clases base de .NET Framework. ArrayList es una clase de colección muy conveniente, que se puede utilizar sin modificar para almacenar tipos de referencia o tipos de valor.

http://msdn.microsoft.com/es-es/library/b5bx6xee.aspx

// The .NET Framework 1.1 way to create a list:System.Collections.ArrayList list1 = new System.Collections.ArrayList();list1.Add(3);list1.Add(105);

System.Collections.ArrayList list2 = new System.Collections.ArrayList();list2.Add("It is raining in Redmond.");list2.Add("It is snowing in the mountains.");

107

DelegadosUn delegado es un tipo que define una firma de método y que puede proporcionar una referencia a cualquier método con una firma compatible. Puede invocar (o llamar) al método a través del delegado. Los delegados se utilizan para pasar métodos como argumentos a otros métodos.

Los controladores de eventos no son más que métodos que se invocan a través de delegados. Para obtener más información sobre el uso de delegados en el control de eventos, vea Eventos y delegados.

Para crear un delegado:

public delegate void SampleDelegate(string str);

108

DelegadosPara crear una referencia a un método que coincida con la firma especificada por el delegado:

class SampleClass{ // Method that matches the SampleDelegate signature. public static void sampleMethod(string message) { // Add code here. } // Method that instantiates the delegate. void SampleDelegate() { SampleDelegate sd = sampleMethod; sd("Sample string"); }}

109

DelegadosUn delegado es un tipo que define una firma de método. Al crear instancias de un delegado, puede asociar su instancia con cualquier método mediante una firma compatible. Puede invocar (o llamar) al método a través de la instancia de delegado. Los delegados se utilizan para pasar métodos como argumentos a otros métodos. Los controladores de eventos no son más que métodos que se invocan a través de delegados. Cree un método personalizado y una clase como un control de Windows podrá llamar al método cuando se produzca un determinado evento. En el siguiente ejemplo se muestra la declaración de un delegado:

public delegate int PerformCalculation(int x, int y);

http://msdn.microsoft.com/es-es/library/ms173171.aspx http://msdn.microsoft.com/es-es/library/ms173172.aspx

110

DelegadosCualquier método de cualquier clase o struct accesible que coincida con la firma del delegado, la cual está compuesta por los parámetros y el tipo de valor devuelto, puede asignarse al delegado. El método puede ser un método estático o un método de instancia. Esto permite el cambio mediante programación de las llamadas a métodos y la incorporación de nuevo código en las clases existentes. Si conoce la firma del delegado, puede asignar su propio método.

En el contexto de la sobrecarga de métodos, la firma de un método no incluye el valor devuelto. Sin embargo, en el contexto de los delegados, la firma sí incluye el valor devuelto. En otras palabras, un método debe tener el mismo valor devuelto que el delegado.

Esta capacidad para hacer referencia a un método como parámetro hace que los delegados sean idóneos para definir métodos de devolución de llamada. Por ejemplo, una referencia a un método que compara dos objetos se puede pasar como argumento a un algoritmo de ordenación. Dado que el código de comparación está en un procedimiento independiente, el algoritmo de ordenación se puede escribir de manera más general.

111

DelegadosLos delegados tienen las propiedades siguientes:

•Los delegados son similares a los punteros a función de C++, pero poseen seguridad de tipos. •Los delegados permiten pasar los métodos como parámetros. •Los delegados pueden utilizarse para definir métodos de devolución de llamada. •Los delegados pueden encadenarse; por ejemplo, se puede llamar a varios métodos en un solo evento. •No es necesario que los métodos coincidan exactamente con la firma de delegado. Para obtener más información, vea Utilizar varianza en delegados (C# y Visual Basic). •La versión 2.0 de C# introdujo el concepto de métodos anónimos, los cuales permiten pasar bloques de código como parámetros en lugar de utilizar métodos definidos independientemente. C# 3.0 introdujo las expresiones lambda como una manera más concisa de escribir bloques de códigos insertados. Tanto los métodos anónimos como las expresiones lambda (en ciertos contextos) se compilan como tipos delegados. En conjunto, estas características se conocen ahora como funciones anónimas.

112

DelegadosLos tipos de delegados se derivan de la clase Delegate en .NET Framework. Los tipos de delegados son sealed (no se pueden derivar) y no es posible derivar clases personalizadas de Delegate. Puesto que el delegado con instancias es un objeto, puede pasarse como parámetro o asignarse a una propiedad. Esto permite que un método acepte un delegado como parámetro y llame al delegado posteriormente. Esto se conoce como devolución de llamada asincrónica y constituye un método común de notificación de un llamador cuando ha finalizado un proceso largo. Cuando se utiliza un delegado de esta forma, no es necesario que el código que utiliza el delegado conozca la implementación del método que se está utilizando. La funcionalidad es similar a la encapsulación que proporcionan las interfaces. Para obtener más información, vea Cuándo se utilizan delegados en lugar de interfaces (Guía de programación de C#). Otro uso común de devoluciones de llamada es definir un método de comparación personalizado y pasar ese delegado a un método de ordenación. Esto permite al código del llamador ser parte del algoritmo de ordenación.

113

Delegados

El método del ejemplo siguiente utiliza el tipo Del como parámetro:

public void MethodWithCallback(int param1, int param2, Del callback) {

callback("The number is: " + (param1 + param2).ToString()); }

114

DelegadosA continuación, se puede pasar el delegado creado anteriormente a ese método:

MethodWithCallback(1, 2, handler);

y recibir el resultado siguiente en la consola:The number is: 3 Al utilizar el delegado como abstracción, MethodWithCallback no es necesario llamar a la consola directamente; es decir, el delegado no se tiene que diseñar pensando en una consola. Lo que MethodWithCallback hace es simplemente preparar una cadena y pasarla a otro método. Esto es especialmente eficaz, puesto que un método delegado puede utilizar cualquier número de parámetros. Cuando se crea un delegado para contener un método de instancia, el delegado hace referencia tanto a la instancia como al método. Un delegado no conoce el tipo de instancia a parte del método que éste contiene, de modo que un delegado puede hacer referencia a cualquier tipo de objeto siempre que exista un método en dicho objeto que coincida con la firma del delegado. Cuando se crea un delegado para contener un método estático, éste sólo hace referencia al método.

115

DelegadosConsidere las siguientes declaraciones:

public class MethodClass { public void Method1(string message) { }

public void Method2(string message) { } }

116

DelegadosJunto con el método estático DelegateMethod que se mostró previamente, ahora tenemos tres métodos que la instancia de Del puede contener.Un delegado puede llamar a más de un método cuando se invoca. Esto se denomina multidifusión. Para agregar un método adicional a la lista de métodos del delegado (lista de invocación), simplemente es necesario agregar dos delegados mediante los operadores de suma o de asignación de suma ('+' o '+='). Por ejemplo:

MethodClass obj = new MethodClass();Del d1 = obj.Method1;Del d2 = obj.Method2;Del d3 = DelegateMethod;

//Both types of assignment are valid.Del allMethodsDelegate = d1 + d2;allMethodsDelegate += d3;

117

DelegadosEn este momento, allMethodsDelegate contiene tres métodos en su lista de invocación: Method1, Method2 y DelegateMethod. Los tres delegados originales, d1, d2 y d3 no cambian. Cuando se invoca a allMethodsDelegate, se llama a los tres métodos por orden. Si el delegado utiliza parámetros de referencia, ésta a su vez se pasa secuencialmente a cada uno de los tres métodos y todos los cambios efectuados por un método son visibles para el siguiente método. Cuando alguno de los métodos produce una excepción que no se detecta dentro del método, esa excepción se pasa al llamador del delegado y no se llama a ninguno de los métodos siguientes de la lista de invocación. Si el delegado tiene un valor devuelto y/o fuera de los parámetros, devuelve el valor devuelto y los parámetros del último método invocado. Para quitar un método de la lista de invocación, utilice el operador de resta o de asignación de resta ('-' o '-='). Por ejemplo:

//remove Method1allMethodsDelegate -= d1;

// copy AllMethodsDelegate while removing d2Del oneMethodDelegate = allMethodsDelegate - d2;

118

Delegados

Puesto que los tipos de delegados se derivan de System.Delegate, los métodos y las propiedades definidos por esa clase se pueden llamar en el delegado. Por ejemplo, para buscar el número de métodos en la lista de invocación de un delegado, puede escribir:

int invocationCount = d1.GetInvocationList().GetLength(0);

119

DelegadosLos delegados con más de un método en su lista de invocación derivan de MulticastDelegate, que es una subclase de System.Delegate. El código anterior funciona en ambos casos porque las dos clases admiten GetInvocationList. Los delegados de multidifusión se utilizan ampliamente en el control de eventos. Los objetos de origen de eventos envían notificaciones de eventos a objetos de destinatario registrados para recibir ese evento. Para registrar un evento, el destinatario crea un método diseñado para controlar el evento, a continuación crea un delegado para dicho método y pasa al delegado al origen de eventos. El origen llama al delegado cuando se produce el evento. Luego el delegado llama al método de control de eventos del destinatario y entrega los datos del evento. El origen de eventos define el tipo de delegado para un evento dado. Para obtener más información, vea Eventos (Guía de programación de C#). La comparación de delegados de dos tipos distintos asignados en tiempo de compilación producirá un error de compilación. Si las instancias de delegado son estáticamente del tipo System.Delegate, se permite la comparación, pero se devolverá false en tiempo de ejecución.

120

DelegadosPor ejemplo:

delegate void Delegate1();delegate void Delegate2();

static void method(Delegate1 d, Delegate2 e, System.Delegate f){ // Compile-time error. //Console.WriteLine(d == e);

// OK at compile-time. False if the run-time type of f // is not the same as that of d. System.Console.WriteLine(d == f);}

121

Heap y Stack

122

Guía de Programación

http://msdn.microsoft.com/es-es/library/67ef8sbd.aspx

123

Gracias por la Atención!