C# – Caracteristicas en .NET 3.0 y .NET 3.5

En esta primer entrada vamos a comentar algunas de las nuevas características en el lenguaje C# que surgieron con la salida del framework .NET 3.0 y siguieron en el 3.5. Algunas tal vez ya la conozcan y las usen a diario, pero hay otras que por ahí esté tan familiarizados y si es bueno recordarlas:

  • Variables de tipos implícitos
  • Objects initializers
  • Tipos Anónimos
  • Extension Methods
  • Expresiones Lambda

Todas ellas tienen como principal objetivo minimizar, simplificar y optimizar el código que escribimos y permitir hacer una lectura más simple de lo que codificamos.

Variables de tipos implícitos

Supongamos que creamos una clase que se llame de la siguiente forma (esto es habitual en los proyectos, y no quiere decir que sea incorrecto):

EstaEsMiClaseConElNombreMuyPeroMuyLargo miClase = new EstaEsMiClaseConElNombreMuyPeroMuyLargo();

Por suerte podemos hacer lo mismo pero utilizando variables de tipos implícitos:

var miClase = new EsteEsMiClaseConElNombreMuyPeroMuyLargo();

El compilador internamente se encargará de averiguar que tipo de dato es. Como podemos ver se hace más simple la lectura del código y nuestra instancia sigue siendo tipada.

Otros ejemplo validos:

var numero = 1;
var palabra = "Sebis";

Objects initializers

Es una forma de inicializar los objetos con sus propiedades, aunque no hallamos definido un constructor.

Supongamos que tenemos definida la siguiente clase:

class Persona
{
    public int Edad {get; set; }
    public string Nombre {get; set; }
}

Podríamos inicializar nuestro objeto de la siguiente forma:

var nuevaPersona = new Persona() { Nombre = "Sebis", Edad = 10 };

Tipos Anónimos

Los tipos anónimos ofrecen un modo útil de encapsular un conjunto de propiedades de sólo lectura en un único objeto sin tener que definir el tipo de forma explícita. Por lo tanto siempre va a existir una única instancia. Es el compilador es el crea una nueva clase de tipo anónimo e inicializa sus propiedades.

Por ejemplo vamos a declarar un tipo anónimo que tiene dos propiedades:

var nuevoProducto = new { Nombre = "Producto X", Precio = 10.50, Stock = 10 };

Luego podemos acceder a sus propiedades:

string nombre = nuevoProducto.Nombre;

Extension Methods

Es una forma de hacer algo parecido a una  “Herencia”, en el cual podemos extender métodos de una clase.

Supongamos que tenemos definida la siguiente clase:

sealed class Producto
{
    public int Cantidad { get; set; }
    public int Precio { get; set; }
}

En este caso el modificador de acceso sealed no me permite extender la clase Producto (es modificador de acceso es muy común en la clases de la librería .NET). Lo que necesito es un método que me calcule el total. Una opción es crear un método al cual le paso como parámetro una instancia de la clase y me retorne el precio.

Como primer paso crearíamos una clase “Helpers”, en este caso ProductoHelpers, donde escribiríamos el/los método/s que queremos extender:

static class ProductoHelpers
{
    public static int CalcularTotalProducto(Producto producto)
   {
        return producto.Precio * producto.Cantidad;
   }
}

Luego creariamos nuestro producto y calcularíamos el total:

var producto = new Producto { Cantidad = 2, Precio = 10 };
int total = ProductoHelpers.CalcularTotalProducto(producto);

Lo que podemos hacer es extender nuestro método a la clase Producto. Para esto anteponemos this al tipo de dato que queremos extender, en el parámetro de nuestro método:

static class ProductoHelpers
{
    public static int CalcularTotalProducto(this Producto producto)
   {
        return producto.Precio * producto.Cantidad;
   }
}

Por lo tanto ahora podemos calcular el total simplemente invocando el método desde nuestra instancia:

int total = producto.CalcularTotalProducto();

Aclaración: un método de extensión afecta tanto a la clase que se le indica como a todas las clases que heredan de ésta.

Expresiones Lambda

El objetivo es reducir la complejidad cuando se trabaja con colecciones de datos. Este característica ya la usamos cuando trabajamos con LINQ.

Supongamos que tenemos una lista de productos:

var productos = new List<Producto>();
productos.Add(new Producto(){ Cantidad = 0, Precio = 10, Nombre="Lector CD"});
productos.Add(new Producto() { Cantidad = 10, Precio = 15, Nombre = "Lector DVD" });
productos.Add(new Producto() { Cantidad = 0, Precio = 20, Nombre = "Grabadora CD / DVD" });

Para recuperar los productos sin stock , podríamos utilizar la siguiente expresión lambda:

var productosSinStock = productos.Where(p => p.Cantidad == 0).ToList();

Espero que les sirva, saludos!

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s