Capítulo 1 (Fundamentos del Framework)–Parte 2

Lección 3 – Construyendo clases
Una clase es un tipo de datos muy eficaz. Como las estructuras, las clases definen métodos y propiedades. Se 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.

Que es la herencia?
La herencia nos permite heredar de la clase padre, muchas propiedades y métodos útiles, los cuales también podemos sobrescribir, por ejemplo, si mi clase hereda ToString(), se puede sobrescribir este método, para que en el momento en que se imprima mi clase, imprima lo que nosotros definamos.
Ejemplo de clase Jefe que hereda de Empleado



Que es una Interface?
Las interfaces son un contrato, es similar a una clase base abstracta. define un conjunto de métodos (sin su implementación) y propiedades, que todos aquellos que hereden de ésta deberían de implementar. Una interfaz puede llegar a heredar de otra interfaz.


Interfaces más comunes
 

IComparable: define un método llamado CompareTo que permite comparar instancias de la clase que implementa esta interface. Es fundamental para poder ordenar instancias ya que para poder ordenar un conjunto de objetos es necesario poder compararlos entre sí.

IDisposable: define un método Dispose() que se utiliza para liberar recursos. Las clases que sean muy grandes o que trabajen con recursos que requieran ser liberados (unmanaged resources) deben implementar esta interface para asegurar la liberación de los recursos utilizados.

IConvertible: define métodos para convertir una clase en int, decimal, DateTime, boolean, etc. Para implementar esta interface es común utilizar la clase Convert que permite realizar conversiones estándar de un tipo a otro.

ICloneable: define el método Clone() que retorna una copia del objeto actual. Hay dos formas de clonar: • Shallow copy: realiza una copia superficial; si  un objeto tiene referencias a otros objetos entonces realiza una copia de las referencias (no genera nuevos objetos). Se realiza utilizando el método MemberwiseClone() que recorre todas las variables de estado y las copia. • Deep copy: realiza una copia completa del objeto, clonando las variables de estado de tipo Reference. Para ello requiere que todas las variables de estados sean ICloneable.

IEquatable: define el método Equals(T) donde T es el tipo de la clase que implementa dicha interface. A diferencia del método Equals(object) que todas las clases heredan de object, este método utiliza Generics por lo que no requiere un casting para hacer la comparación ya que la comparación se realiza únicamente en objetos del mismo tipo.

IFormattable: define el método ToString(string, IFormatProvider) para convertir un objeto en un string. Da muchísima más flexibilidad que el método ToString() definido en la clase object ya que formatea el string utilizando el objeto de tipo IFormatProvider que podría indicar el formato para establecer la cantidad de decimales y en la cultura podría indicar si se trabaja con la cultura actual o con otra. Ejemplo: obj.ToString(“0.00”, CultureInfo.CurrentCulture);

Que son las clases parciales?
Especificando una clase como parcial permite dividir su definición en dos o más archivos de código fuente. Cada archivo de código fuente contiene una parte de la definición de clase y todas las partes se combinan cuando se compila la aplicación.


Genericos
Permiten definir un tipo sin especificar detalles. Cuando se trabaja con colecciones (Collections), es más óptimo que trabajar con lista de Objects, reduce la cantidad de errores en tiempo de ejecución por problemas de casteo (evita el casteo).

Uso de constraints (Restricciones)
Se usan para limitar los tipos que se pueden usar en los generics, para especificar que requerimientos debe cumplir.

Soportan 4 tipos:

Interface.	Permite solo tipos que implementen interfaces específicas para usar tus generics.
Base class.	Permite solo tipos que concuerden o hereden de una clase base específica.
Constructor.	Requiere que los tipos que usen tu generics implementen un constructor menos parametrizado.
Reference or value type.	Requiere que los tipos que usen tu generics sean una referencia o un tipo de valor.

Ejemplo:

Esto quiere decir que el parámetro solo pueden ser aquellos tipos que implementen Ifantasma.

Que son los Eventos?
Es un mensaje enviado por un objeto en señal de que a ocurrido una acción, la cual pudo ser causada por una interacción, un clic de mouse, o puede ser hecha por otro programa. El object que levanta el evento es llamado el Event sender, mientras que el objeto que captura el evento, es llamado receptor de evento (event receiver).

Que son los Delegados?
Es una clase que almacena una referencia a un método. Es equivalente a un puntero a una función de tipo seguro (type-safe).Muchas veces es utilizado para señalar un evento a un objeto. Para utilizarlo, se debe de asociar el evento con el manejador del evento.
Un ejemplo de cómo definir un delegado de nombre Deleg cuyos objetos puedan almacenar métodos que devuelvan un string y tomen como parámetro un int es:


Como responder a un evento
Se crea un método que responda al evento, debe coincidir con la firma del delegado.

Y un manejador de eventos (event handler) que indique cual método recibirá el evento.


Que son los Atributos?
Describen tipos, métodos o propiedades que pueden ser consultadas programáticamente usando una técnica llamada Reflexion. Derivan de System.Attribute y son especificados usando [].
Sus usos comunes:

• Especificar qué privilegios de seguridad requiere una clase
  
• Especificar privilegios de seguridad que permitan reducir el riesgo de seguridad.
  
• Declarar capacidades, ej. soporta serializacion.
  
• Describir el assembly con un título, descripción o notificación de copyright.

Ejemplo:
Para que una clase sea serializable se le debe añadir [Serializable],


Que es el Type Forwarding?
Type Forwarding es un atributo que permite mover un tipo a de un assembly, a otro assembly, de tal forma que no se deba recompilar los clientes que consuman el primer assembly.
Solo funciona con componentes referenciados por aplicaciones existentes
Ejemplo:


Lección 4- conversión entre tipos
Las conversiones de tipo nos permiten que una expresión de un tipo sea tratada como una expresión de otro, las conversiones pueden ser implícitas (widening) o explícitas (narrowing), estas últimas pueden fallar si el valor que se va a convertir excede el tamaño del tipo al que se va a cambiar.

Por ejemplo la conversión de un tipo int a long es implícita, sin embargo la conversión de un tipo long a un tipo int es explícita, esto debido a que un int puede ser expresado en formato long sin que haya perdida de datos, pero si intentamos convertir un numero long a int puede haber perdida de precisión y se necesita una conversión explícita, es como una forma de obligarnos a demostrar que estamos conscientes de que existe esa perdida.

Formas de realizar conversiones:

• System.Convert, entre tipos que implementan IConvertible
• tipo.ToString
• tipo.Parse
• tipo.TryParse y type.TryParseExact, convierte de string a un tipo base, retorna false si no es posible.

Que es boxing y unboxing?
Boxing: es transformar un tipo por valor a un tipo por referencia. Por ejemplo: de Point (un punto con coordenadas x e y ) a object.

Unboxing: se transforma tipo por referencia a un tipo por valor. Ejemplo: object a Point.




....................................................................................................................................................
Bajar esta capítulo en formato PDF                                                               Codigo Ejemplo
....................................................................................................................................................