martes, 1 de diciembre de 2009

C# Nuevas Características

Veamos las nuevas características que se han incorporado en cada una de las entregas de este potente lenguaje de programación, comenzando por C# 2.0, C# 3.0 hasta C# 4.0

C# Evolucion, .Net, VS

C# es un lenguaje de programación que ha ido mejorando con el paso del tiempo, agregando nuevas e interesantes características en cada una de las versiones que han ido saliendo progresivamente con cada nueva entrega de Visual Studio, veamos entonces dichas mejoras:

C# 4.0, Lo Nuevo

Con la próxima llegada de Visual Studio 2010, sale la versión C# 4.0, incorporando las siguientes nuevas características:

  1. Parámetros Opcionales.
  2. Tipos Dinámicos (dynamic type).
  3. Covarianza y Contravarianza (Covariance and Contravariance).
Nota: Existen otras muchas nuevas características incorporadas en esta nueva versión (C# 4.0) que iré incorporando a medida que las valla manipulando y comprendiendo ... sean pacientes, jejejeje

C# 3.0, Lo Nuevo

Con la llegada de Visual Studio 2008, sale la versión C# 3.0, incorporando las siguientes nuevas características:

  1. LINQ
  2. Expresiones Lambda (Lambda Expressions).
  3. Tipos Anónimos (Anonymous Types).
  4. Inicializadores de Objetos y Colecciones (Object and Collection Intializers).
  5. Métodos Extensores (Extension Methods).
  6. Expression Trees.
  7. Partial Methods.
  8. Propiedades Auto-Implementadas (Auto-Implemented Properties).

C# 2.0, Lo nuevo

Con la llegada de Visual Studio 2005, sale la versión C# 2.0, incorporando las siguientes nuevas características:

  1. Generics.
  2. Métodos Anónimos (Anonymous Methods).
  3. Iterators.
  4. Partial Types.
  5. Nullable Types.
  6. Delegados (Delegate Inference).
  7. Friend  Assemblies.
  8. Pragma warning.
  9. Captured Variables.

Artículos Relacionados:

viernes, 20 de noviembre de 2009

C#, Inicializadores de Objeto y de Colección

Los inicializadores de objeto permiten asignar valores a los campos o propiedades de un objeto en el momento de la creación sin tener que invocar explícitamente un constructor.

C# 3.0, Nueva Característica

Esta característica fue incorporada a partir de la versión C# 3.0 y sigue el camino de la simplificación de código, al igual que otras características que iré comentando en sucesivos artículos. Pero en fin, veamos un ejemplo que nos deje el concepto del todo claro:

namespace Pruebas
{
    class Program
    {
        static void Main(string[] args)
        {
            // Inicializador de Objeto
            Contacto objContacto =
                new Contacto { IdContacto=1, Nombre="Pedro", Telefono = "601 01 01 01" };
           
            //Inicializador de Colección
            List<Contacto> lstContactos = new List<Contacto>
            {
                new Contacto { IdContacto=1, Nombre="Pedro", Telefono="601 01 01 01" },
                new Contacto { IdContacto=2, Nombre="Maria", Telefono="601 01 01 02" },
                new Contacto { IdContacto=3, Nombre="Juana", Telefono="601 01 01 03" }
            };
        }
    }
 
    public class Contacto
    {
        public int IdContacto {get; set;}
        public string Nombre { get; set; }
        public string Telefono { get; set; }
    }
}

Y así de simple es crearnos un objeto o una colección de objetos e inicializarlos en la misma línea.

Nota: En el ejemplo, hemos usado la clase Contacto y en ella hemos usado otra nueva característica de C# 3.0, se trata de las propiedades auto implementadas. Para obtener más información, consulte Propiedades auto implementadas.

Artículos Relacionados:

lunes, 9 de noviembre de 2009

C# Delegado

Veamos un ejemplo práctico y sencillo del uso de eventos delegados, de forma que nos quede claro su concepto y su uso.

¿Que es un Delegado?

Un delegado (delegate) es un tipo especial de clase cuyos objetos pueden almacenar referencias (punteros, apuntadores) a uno o más métodos, posibilitándonos (desde el objeto) lanzar la ejecución en cadena de todos estos métodos.

Hasta aquí la definición mas sencilla posible, pero igualmente algo complicada de entender, expliquémosla a través de un ejemplo abstracto con la esperanza de que se comprenda algo mejor:

Si tuviéramos una página Page1 y un control de usuario uc1, y quisiéramos desde un método de uc1 llamar a un método de Page1, tendríamos que declarar un delegado en uc1 y desde Page1 almacenar en el delegado el método de la página (uc1.Delegado1 = Page1.Método).

Creo que igual me enrede, en fin veamos un caso práctico y concreto que recientemente tuve, donde usé un delegado (delegate).

Delegado Ejemplo Práctico

Imaginemos la siguiente problemática: Tengo que implementar una búsqueda de vuelos aéreos (ver imagen):

Delegado, Buscador de Vuelo

Para ello crearemos una página que contendrá, entre otras cosas, 2 controles y un método:

  • ucBuscadorCriterios (marcada en rojo): Contiene las condiciones de filtros a establecer para la búsqueda del vuelo.
  • ucBuscadorResultado (marcada en azul): Contendrá los resultados de los vuelos que cumplen las condiciones establecidas.
  • BuscarVuelos(): Método que se encargará de buscar y devolver todos los vuelos que cumplen con unas ciertos criterios de búsqueda. Los criterios son definidos en ucBuscadorCriterios y los resultados los usaremos para mostrarlos en ucBuscadorResultado.

Hasta aquí todo bien, pero si nos fijamos en ucBuscadorCriterios (rojo) dentro tiene el botón btnBuscarVuelos, el cual debe lanzar la búsqueda, o sea, debe llamar al método BuscarVuelos() que está en la página. Nuestro problema sería:

¿Como llamar a Page1.BuscarVuelos() desde Page1.ucBuscadorCriterios?

La respuesta es sencilla, usaremos un delegado (delegate).

Usando Delegado (Delegate)

Lo primero que haremos es declarar el delegado, en nuestro ejemplo debemos abrir el código del control de usuario (ucBuscadorCriterios) y definimos nuestro delegado AereoBuscadorBuscarClick, posteriormente en el evento asociado al clic del botón “Buscar Vuelos” haremos la llamada al delegado AereoBuscadorBuscarClick. Ya lo tenemos casi todo echo solo nos falta asociar el delegado al método que nos interesa Page1.BuscarVuelos().

public partial class UserControlsAereoBuscadorCriterios : UserControl
{
  //Declarar el delegado
  //(puntero a la función que se encuentra en la pagina)
  public delegate void MyDelegadoBuscar();
  public event MyDelegadoBuscar AereoBuscadorBuscarClick;
  protected void Page_Load(object sender, EventArgs e) {}
 
  //Evento asociado al boton AereoBuscadorBuscar y que es un delegado o puntero 
    a la función que se encuentra en la pagina
  protected void AereoBuscadorBuscar_Click(object sender, EventArgs e)
  {
    if (AereoBuscadorBuscarClick == null) return;
   
    AereoBuscadorBuscarClick();
  }
}
Para asociar el delegado que hemos creado (AereoBuscadorBuscarClick) al método de la página (Page1.BuscarVuelos()) tenemos que ir al código de la página y en el evento Page_load hacer la asociación correspondiente:

protected void Page_Load(object sender, EventArgs e)
{
   //Asociar el delegado del control de usuario
   ucBuscadorCriterios.AereoBuscadorBuscarClick += BuscarVuelos;
}

Y todo listo, ya tenemos un ejemplo practico de un delegado (delegate)…

Después de escribir el artículo no se si ha quedado claro la idea de uso de un delegado, espero que se halla entendido.