C sharp para contar (parte 2)

CHenry [chenry@hha.sld.cu]

BOXING AND UNBOXING.

class Test
{
  static void Main()
  {
    int i=123;
    object o=i; // BOXING
    int j=(int)o; // UNBOXING
  }  
}

Uso del boxing y unboxing:
Cuando una variable de tipo por valor necesita ser convertida a un tipo por referencia, un objeto box es creado para almacenar el valor, y el valor es copiado en este. Unboxing es simplemente lo contrario. Cuando el objeto box se "castea" a su tipo de valor original el valor es copiado en la apropiada variable.

El proceso de hacer “boxing” se explica imaginando la existencia de una clase T_Box para cada tipo por valor T.

class T_Box
{
  T value;
  T_Box(T t)
  {
//CONSTRUCTOR
    value = t;
  }
}
struct Point
{
  public int x, y;
  public Point(int x, int y)
  {
    this.x = x;
    this.y = y;
  }
}
Point p = new Point(10, 10);
object box = p;
p.x = 20;
Console.Write(((Point)box).x);

Declaración de constantes y variables.
class Test
{
  static void Main()
  {
    const int a = 1;
    const int b = 2, c = 3;
    int d;
    int e, f;
    int g = 4, h = 5;
    d = 4; e = 5; f = 6;
  }
}

Sentencias de control.
Las sentencias if, switch, while, do-while, for, break-continue, return, throw-try las trabaja igual que Java.

• Sentencia foreach:

La sentencia foreach enumera los elementos de una colección, ejecutando las sentencias para cada elemento de la colección.

using System;
using System.Collections;
class Test
{
  static void WriteList(ArrayList list)
  {
    foreach (object o in list)
    Console.WriteLine(o);
  }
  static void Main()
  {
    ArrayList list = new ArrayList();
    for (int i = 0; i < 10; i++)
    list.Add(i);
    WriteList(list);
  }
}

• Sentencia lock.

Parecido al synchronized de Java.
Una sentencia lock obtiene la exclusión-mútua para un objeto dado, ejecutando las sentencias y luego liberando el bloqueo.

La expresión lock debe contener un valor de un tipo por referencia, por tanto un objeto obtenido mediante “boxing” no es valido en una expresión lock. Una expresión lock de la forma:
lock (x) ...

System.CriticalSection.Enter(x);
try {...}
finally
{
  System.CriticalSection.Exit(x);
}

Esto es equivalente a: poner en situación crítica un objeto es usado y luego de ser usado sacarlo de la situación crítica.

La sentencia lock puede ser convenientemente usada para obtener la exclusión-mútua de los métodos estáticos de una clase, ejemplo:

class Cache
{
  public static void Add(object x)
  {
    lock (typeof(Cache)) {...}
  }
  public static void Remove(object x)
  {
    lock (typeof(Cache)) {...}
  }
}

Clases.

C# soporta solamente herencia simple, pero una clase puede implementar múltiples interfaces (igual a Java, la diferencia esta solo en la sintaxis). Una clase puede incluir: constantes, campos (variables u objetos), métodos, propiedades, indexers, eventos, operadores, constructores, destructores y declaraciones de tipos anidados.

Modificadores de clases:

• new: Es solo permitido en las clases anidadas, especifica que la clase oculta un miembro heredado con el mismo nombre.
• public, protected, internal y private: controlan el acceso de la clase, en dependencia del contexto donde la declaration de la clase ocurra algunos de estos modificadores no son permitidos.
• abstract: el modificador es usado para indicar que la clase esta incompleta, solo puede ser usada como base de otras clases, esta difiere de una clase no-abstracta en los siguientes aspectos:
• Una clase abstracta no puede ser instanciada, es un error tratar de usar el operador new.
• Pueden contener métodos abstractos y modificadores (no es un requerimiento).
• Una clase abstracta no puede ser sealed.

Toda clase que derive de una clase abstracta debe incluir la implementación de todos los métodos abstractos heredados.

abstract class A
{
  public abstract void F();
}
abstract class B: A
{
  public void G() {}
}

class C: B
{
  public override void F()
  {
// actual implementation of F
  }
}

• Sealead: El modificador es igual que el final de Java Se usa para “prevenir” la derivación de una clase. Ocurre error al tratar de heredar de una clase sealed. Una clase sealed no puede ser abstracta.
Nota: Este modificador es usado principalmente para impedir la derivación de una clase, pero aparte de esto se genera una especie de código especial, en particular debido a que de las clases sealed como no se puede derivar pueden transformarse las funciones “virtual” en invocaciones “no-virtual”.
P: A que programador se le ocurre ponerle “virtual” a una clase de la cual no se puede heredar????

• Cada miembro puede tener los siguientes tipos de acceso.
• public: miembros son accesible en todo el código.
• Protected: miembros son solo accesible para las clases derivadas (herederos).
• Internal: miembros son accedidos solo dentro del paquete .(igual al que pone Java por default).
• Protected internal: solo para las clases derivadas dentro del paquete.
• Private: solo la propia clase tiene acceso.

Nota: La clase base implícita de toda clase es object, esta a su vez no tiene clase base pues es igual que el object de Java.

La clase base debe ser como mínimo tan accesible como la clase que deriva de ella, seria un error que una clase public derivara de una clase private o con menos acceso que el public (internal).
Nota: Cuando una clase B deriva de una clase A es un error que A dependa de B.

Artículos relacionados