Novedades en el lenguaje .Net 3 – Tipos inferidos

Segunda parte de las novedades en los lenguajes C# y VB.NET del .Net 3. Consultar la primera parte : Inicialización de objetos

Continua llegint

Anuncis

Alliberar recursos no manegats amb IDisposable

Amb .Net tenim recursos manegats i recursos no manegats. Els primers son els que gestiona el CLR mentre que els altres son externs al .Net i per tant no els gestiona el CLR. El CLR és el responsable de crear les classes i també destruir-les, demanant al Garbage Collection que escombri de la memòria totes aquelles referències que ja no s’utilitzen.

Amb els recursos no manegats trobem connexions a les bases de dades, connexions a xarxes, descriptors de fitxers i altres, com per exemple, el DispatcherTimer que amb WPF si no tanquem el rellotge aquest deixa vius els objectes que recullen l’event Tick.

IDisposable es la interfície que permet implementar el mètode Dispose. Aquest és el mètode estàndard amb .Net per alliberar els recursos manualment. Tenim els destructors de les classes que poden alliberar els recursos però aquest només és cridat per el GC i aquí perdem el control de quan pot passar això, ja que, és el SO qui determinarà si el GC pot escombrar o no.

Per implementar IDisposable existeix un patró que sempre hem de seguir.

// Design pattern for a base class.
public class Base: IDisposable
{
    private bool disposed = false;
    //Implement IDisposable.
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Free other state (managed objects).
            }
            // Free your own state (unmanaged objects).
            // Set large fields to null.
            disposed = true;
        }
    }
    // Use C# destructor syntax for finalization code.
    ~Base()
    {
        // Simply call Dispose(false).
        Dispose (false);
    }
}
// Design pattern for a derived class.
public class Derived: Base
{
    private bool disposed = false;
    protected override void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Release managed resources.
            }
            // Release unmanaged resources.
            // Set large fields to null.
           // Call Dispose on your base class.
            disposed = true;
        }
        base.Dispose(disposing);
    }
    // The derived class does not have a Finalize method
    // or a Dispose method without parameters because it inherits
    // them from the base class.
}

Aquesta informació la pots trobar a Implementing Finalize and Dispose to Clean Up Unmanaged Resources

GC.SuppressFinalize demana al GC que no executi el destructor per aquesta classe ja que la alliberació s’ha fet manual. Per tant, ja veus que el destructor d’una classe allibera els recursos quan nosaltres no ho hem fet manualment. I per què no es fa sempre així? Doncs perquè el GC ha de fer dues passades quan es troba un destructor i això fa més lent el procés de neteja.

Novedades en los lenguajes .Net 3 – Inicialización de objetos

Ahora puedes crear una instancia de una clase y asignar valores a las propiedades publicas en una sola instrucción.

C#
Person p = new Person {FirstName=”Jon”,
LastName=”Smith”,Age=32}
Vb.Net
Dim p as New Person With {.FirstName=”Jon”,
.LastName=”Smith”,
.Age=32}

Como puedes ver los parámetros del constructor están después de Person como si creases una instancia de una clase.

C#
Person p = new Person(...) {FirstName=”Jon”,
LastName=”Smith”,
Age=32}
Vb.Net
Dim p as New Person(...) With {.FirstName=”Jon”,
.LastName=”Smith”,
.Age=32}

Llista d’usuaris agrupats per grups

Sempre he dit que el Sharepoint és una eina molt potent que permet compartir documentació i experiències entre persones d’un mateix grup de treball. A part, ens deixa programar petites aplicacions (web parts) totalment integrats al Sharepoint i ara totalment des del Visual Studio 2010 per templates.

Sense necessitat de programar podem crear vistes de totes les diferents llistes que hi ha dins el Sharepoint, amb aquestes vistes podem veure informació diferent per cada element de les llistes. També podem ampliar la informació que hi ha en cada element creant noves columnes.

Però no em deixa de sorprendre que no es pugui treure una llista tant i tant elemental com és la dels usuaris agrupats per els seus grups d’una manera ràpida i senzilla. Parlo del Sharepoint 2007, no ho he comprovat amb el Sharepoint 2010.

Sí es pot fer programant un web part com el que es diu en aquesta pàgina.

Però és demanar molt que faci una llista tant bàsica un programa tant complet com és el Sharepoint? Amb tot el què ja fa?

Genéricos

Los genéricos es un concepto que aparece en la versión 2.0 del Framework .Net y lo explico en todos los cursos que imparto porque ha tomado más y más importancia con las siguientes versiones del framework.

Una clase, o método o interface es genérica cuando el tipo es independiente de la implementación.

Los problemas sin genéricos

Para entender mejor el problema utilizamos listas como Stack que se encuentra dentro del espacio de nombres System.Collections.

Sin los genéricos el tipo object es el que utilizamos para indicar que una de estas lista puede contener cualquier tipo. Pero muchas veces las listas, cuando las estamos utilizando, son de un solo tipo. Lista de enteros, lista de strings, lista de Personas,….

Boxing/Unboxing: Es el nombre que tiene cuando un tipo debe reconvertirse en otro en tiempo de ejecución. Esto es lo que nos pasa en las listas sin genéricos.

//boxing
s.Push( 10 );
//unboxing
int i = (int)s.Pop();

Existe aún otro problema denominado No Type safety. Significa que nuestra lista puede contener cualquier tipo de datos y se escapa de nuestro control, en tiempo de compilación, de cualquier error producido por un programador.

//No type safety
Stack s = new Stack();
s.Push( 10 );
s.Push( "Hello" );

 

La solución de los Genéricos

Si continuamos hablando de listas, estas se encuentran en el espacio de nombre System.Collections.Generic.

Crear una clase genérica implica indicar un tipo, el tipo no sabemos cual va a ser ya que se indicará en el momento de utilizar nuestra clase genérica, por tanto debemos dar un nombre a ese tipo, normalmente se usa T.

public class Stack<T> {
 …
 public void Push( T item ) { ... }
 public T Pop() { ... }
}

El tipo T se substituye en tiempo de compilación por el tipo que indicamos en la declaración.

Stack<int> s = new Stack<int>();
s.Push( 10 );
s.Push( 20 );
int i = s.Pop();

De este modo tenemos solucionado el No Type Safety, el Boxing y el Unboxing ya que es el compilador quien comprobará que el tipo que insertamos en nuestra pila sea el mismo tipo en el que hemos declarado nuestro Stack genérico.

//Error de compilación
s.Push( “Hello” )

En el siguiente ejemplo te muestro como podemos utilizar la T en toda la clase:

public class Stack<T> : IEnumerable<T> {
 private List dataItems = new List();
 
 public void Push( T item ) 
 { 
  dataItems.Insert( 0, item ); 
 }
 
 public T Pop() { 
  T retVal = dataItems[0];
  dataItems.RemoveAt(0);
  return retVal;
 }
}

Conclusión

Los genéricos es un concepto introducido en la versión 2.0 del .Net Framework que sirven para desacoplar el tipo de la implementación. Mi recomendación es que empieces a utilizar las listas genéricas que encontrarás en el espacio de nombres System.Collections.Generic. Mejora en rendimiento y en robustez tus aplicaciones con los genéricos.

El meu bloc per més gent

Vaig començar aquest bloc amb la intenció d’escriure totes aquelles coses que estan relacionades directament amb la meva feina i que penso que son interessants per aquells  que com jo es dediquen a la formació, programació o consultoria.

Vaig començar el febrer d’aquest mateix any i després de passar més de 6 mesos escrivint sobre diferents matèries: Microsoft .Net, ASP.NET, Silverlight, WCF, Winforms, WPF, Sharepoint i formació, penso que ha arribat el moment de pensar que potser el meu bloc ha d’arribar a més gent. És per això que a partir d’avui escriuré les entrades en Català i Castellà alternativament.

A veure com funciona.