La inicialización del tipo Lazy (la traducción seria perezosa pero se refiere al hecho de crear un objeto hasta el momento de realmente utilizarlo aún y cuando el objeto sea instanciado en líneas anteriores) permite optimizar la manera en que creamos nuestros objetos.  En .Net. C# 4.0 se introduce la clase Lazy<T> que permite inicializar los objetos hasta que realmente los vayamos a utilizar, veamos el siguiente ejemplo:

class Program
{
    static void Main(string[] args)
    {
        Lazy<Prueba> f = new Lazy<Prueba>( );
        Console.WriteLine("Prueba es definida");
        if (!f.IsValueCreated) Console.WriteLine("Prueba aún no ha sido inicializada");
        Console.WriteLine("Prueba::ID=" + (f.Value as Prueba).ID);
        
        if (f.IsValueCreated) Console.WriteLine("Prueba ahora si está inicializada");
        Console.Read();
    }
} 

public class Prueba
{
    public int ID { get; set; }
    
    public Prueba()
    {
        Console.WriteLine("Prueba:: El constructor es llamado");
        ID = 1;
    }
}

La ejecución obtendría el siguiente resultado:

Prueba es definida
Prueba aún no ha sido inicializada
Prueba:: El constructor es llamado
Prueba::ID=1
Prueba ahora si está inicializada

Como podemos ver el objeto Prueba se crea sólo cuando f.Value es accesado.

C # 4.0 ha añadido dos nuevas características en relación con los parámetros que deberían contribuir a mejorar la productividad del desarrollador.  Parametros Opcionales y Parametros por nombre permitirá  nuevas maneras de resolver viejos problemas.

Parámetros opcionales

En el pasado, cuando queríamos crear métodos con un número variable de parámetros debiamos utilizar métodos sobrecargados. La sobrecarga es el proceso de creación de métodos con el mismo nombre pero de diferentes parámetros. Por ejemplo, digamos que tenemos un método denominado GetRandomNumber que cuenta con tres firmas de métodos diferentes:

01    static void Main(string[] args)
02    private static Random random = new Random();      
03     
04    public static int GetRandomNumber(int max)
05    {
06        return random.Next(max);
07    }
08     
09    public static int GetRandomNumber(int min, int max)
10    {
11        return random.Next(min, max);
12    }
13     
14    public static int GetRandomNumber()
15    {
16        return random.Next();
17    }

Con C # 4, ahora podemos consolidar estas en un método con parámetros opcionales. Los parámetros opcionales le permiten declarar e inicializar una variable dentro de la firma del método. Cualquier parámetro que tiene un valor por defecto asignado a ella puede ser excluido al invocar el método. Por lo tanto podemos consolidar nuestro código anterior:

01    private static Random random = new Random();
02     
03    public static int GetRandomNumber(int min = -1, int max = -1)
04    {           
05        if (min == -1 && max != -1)
06            return random.Next(max);
07        else if (min != -1 && max != -1)
08            return random.Next(min, max);
09        else
10            return random.Next();
11    }

El escenario clásico para el uso de parámetros opcionales surge cuando están interactuando con interfaces COM como la Automatización de Microsoft Office API. Si usted ha trabajado con las APIs de Office antes, entonces estoy seguro de que usted está familiarizado con el Type.Missing. Antes de C # 4.0, tendríamos que utilizar el siguiente código para dar formato a un rango de celdas con Excel:

1    var excel = new Microsoft.Office.Interop.Excel.Application();
2    excel.Workbooks.Add();
3    excel.Visible = true;
4     
5    var format = Microsoft.Office.Interop.Excel.XlRangeAutoFormat.xlRangeAutoFormatClassic1;
6     
7    excel.get_Range("B10", "B40").AutoFormat(format,
8       //y !6! Type.Missing
9       Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);

Este código parece un desperdicio debido al hecho de que tenemos que llenar en seis de los siete parámetros con Type.Missing. En C # 4.0, la llamada al método  AutoFormat se simplifica. Básicamente, se pueden prevenir todos los parámetros repetitivos como Type.Missing y solo especificar el primer parámetro, como en siguiente ejemplo:

excel.get_Range("B10", "B40").AutoFormat( format );

Parámetros con nombre

Named Parameters es la otra nueva característica en C # 4.0. Los parámetros con nombre son muy útiles en situaciones en las que es fácil olvidar el orden en el que los parámetros están especificados. Volviendo a mi primer ejemplo que tenía un generador de números aleatorios que tiene un valor mínimo y un valor máximo. Si por alguna razón se invirtieran el valor de los parámetros obviamente el resultado seria equivocados. Sin embargo, con Named Parameters podemos seleccionar los parámetros especificando el nombre del parámetro y el valor. Aquí está un ejemplo:

Console.WriteLine( GetRandomNumber( max : 100, min : 1 ) );