Novedades C# 3.0

Una de las primeras novedades con que se encuentra cualquier programador de C# que empieza a asimilar las nuevas características de C# 3.0 es la palabra reservada contextual  var. Hablamos de palabra reservada contextual porque el lexema var (al igual que el resto de los términos incorporados al lenguaje en la versión 3.0) actúa o no como palabra clave en dependencia del contexto en que aparece. En el caso de var, éste es reconocido por el compilador como palabra clave únicamente cuando es el lexema que da inicio a una sentencia del lenguaje; en caso contrario, es tratado como un identificador común y corriente. Esto hace posible mantener la compatibilidad hacia atrás, y que sigan compilando correctamente programas escritos para versiones anteriores que utilicen var como nombre de variable o tipo:

static void Main(string[] args)

{

    int var = 4;

    Console.WriteLine(var);           

}

Cuando aparece al principio de una sentencia, var indica al compilador que está en presencia de una declaración de variable local con tipo implícito; esto es, una declaración de una variable local cuyo tipo no se especifica explícitamente por parte del programador, sino que se deja al compilador la tarea de inferirlo (deducirlo) en base al tipo de la expresión con la que la variable se inicializa. La inferencia de tipos es un recurso que se utilizó por primera vez en C# en la versión 2.0 y que en la versión 3.0 gana muchos enteros como mecanismo que hace posible una codificación más compacta y funcional.

A continuación se muestran algunos ejemplos sencillos de declaraciones de variables locales con tipo implícito:

var year = 2007; // el tipo de ‘year’ es int

var greeting = "IACYM Lince!"// el tipo de ‘greeting’ es string

var radio = 3.5;

var area = Math.PI * radio * radio;

// el tipo de ‘radio’ y ‘area’ es double

var today = new DateTime(2007, 12, 1);

// el tipo de ‘today’ es DateTime

Los siguientes son ejemplos de usos erróneos de var:

// usos erróneos de var

var a;        // la inicialización es obligatoria

var b = null; // imposible inferir el tipo de ‘b’

var c1 = 3,

    c2 = 5;  // no se admiten declaraciones múltiples

var d = ;    // un inicializador de array no es permitido

             // (para esto el lenguaje ofrece otra vía, los inicializadores de arrays y colecciones)

La palabra clave contextual var puede utilizarse también en otras construcciones del lenguaje, como el bucle foreach o la sentencia using:

var a = new int[]{} ;

using (var f = new StreamWriter("DATA.txt"))// el tipo de ‘f’ es StreamWriter

{

      foreach (var n in a)  // el tipo de ‘n’ es int

      f.WriteLine(n);

}

La semántica de ‘var’

Algunos programadores con experiencia de trabajo con lenguajes dinámicos o con débil control de tipos (como Javascript o Visual Basic 6) piensan, al ver por primera vez esta característica de C# 3.0, que están en presencia de algo que les es familiar: la posibilidad de declarar una variable cuyo tipo podrá variar en tiempo de ejecución según el libre albedrío del programador. Nada más lejos de la realidad: C# ha sido desde sus inicios un lenguaje con fuerte control de tipos, y esta característica no viene para nada a romper con esa tradición. La palabra clave contextual var es simple y sencillamente un recurso que nos libera de la necesidad de indicar explícitamente el tipo de una variable inicializada, haciendo que el compilador lo infiera automáticamente a partir del tipo de la expresión que se le asigna. A lo largo de todo el ámbito de utilización de la variable, el compilador verificará que el uso de ésta es consistente con el tipo que le ha asignado en el momento de la declaración.

La conveniencia de no abusar de ‘var’

Desde que se propuso originalmente esta característica en las presentaciones preliminares de C# 3.0, muchos comenzaron a alertar acerca del posible efecto nocivo sobre la legibilidad del código fuente que podría provocar el uso indiscriminado de var. Esto es en principio cierto: el uso de var en un fragmento de código requiere de un esfuerzo por parte de quien lo lee por primera vez para determinar el tipo de la variable, algo que no ocurriría si dicho tipo se indicara explícitamente.

Mi recomendación personal es utilizar var única y exclusivamente en las siguientes situaciones:

• En los casos en que el tipo de la variable es evidente; por ejemplo, si la expresión que se va a asignar a la variable es una llamada a un constructor, en el que queda reflejado claramente el tipo:

var hoy = new DateTime(2007, 12, 1);

 Cuando el valor que se asigna a la variable es una consulta integrada en el lenguaje. En general, el tipo de las consultas integradas es IEnumerable, donde T es el tipo de los elementos de la secuencia de salida, que generalmente se deduce fácilmente de la estructura de la consulta. Por ejemplo, si tenemos la siguiente clase:

public class Revista

{

     public string Nombre { get; set; }

     public string Idioma { get; set; }

     public DateTime Desde { get; set; }
}

y un array de objetos de ese tipo:

var misSuscripciones = new Revista[]

            {

                new Revista {

                    Nombre = "dotNetManía",

                    Idioma = "es",

                    Desde = new DateTime(2005, 11, 01)

                },

                new Revista {

                    Nombre = "MSDN Magazine",

                    Idioma = "en",

                    Desde = new DateTime(2004, 01, 01)

                },

                new Revista {

                    Nombre = "PC World",

                    Idioma = "es",

                    Desde = new DateTime(2007, 04, 01)

                }

            };

entonces la sentencia:

var suscripcionesEnEspañol =  from s in misSuscripciones

               where s.Idioma == "es" orderby s.Desde

               select s;

representa una consulta que producirá como resultado, al ser recorrida, una secuencia con los objetos de la clase Revista que pertenecen al array y cumplen la condición especificada. El tipo de la variable suscripcionesEnEspañol es IEnumerable.

La necesidad de disponer de ‘var’

Si las posibilidades que ofrece la utilización de var se limitaran exclusivamente a lo descrito hasta ahora, habría que aceptar que la declaración de variables con tipo implícito es simplemente un mecanismo de comodidad o conveniencia sin el que se podría vivir perfectamente. Aunque ya de por sí eso legitimaría la inclusión de esta característica en C# 3.0, lo cierto es que la existencia de un recurso como var en esta nueva versión del lenguaje es simplemente imprescindible.

La necesidad de disponer de declaraciones con tipo implícito tiene relación con el funcionamiento de las consultas integradas: hay casos en los que el tipo de los elementos de la secuencia resultante es generado “al vuelo” por el compilador, sin que el programador tenga acceso al nombre de ese tipo en el código fuente. Es lo que en C# 3.0 se conoce como tipos anónimos. Supongamos que nuestra consulta integrada tiene la siguiente forma:

var suscripcionesEnEspañol_2 = from s in misSuscripciones

               where s.Idioma == "es"orderby s.Desde

               select new { s.Nombre, s.Desde };

Aquí estamos solicitando solamente los nombres y fechas de suscripción de las publicaciones, y no los objetos Revista completos; es lo que técnicamente se conoce como una proyección. El resultado de esta consulta es IEnumerable, donde X es el nombre de un tipo que sintetiza automáticamente el compilador de C# con la siguiente estructura:

public class Revista_2 {

        public Revista_2(

        string nombre, DateTime desde)

        {

            this.nombre = nombre;

            this.desde = desde;

        }       

        public string Nombre

        {

            get { return nombre; }

        }

        private string nombre;

        public DateTime Desde

        {

            get { return desde; }

        }

        private DateTime desde;
}

Como el nombre de este tipo no está disponible al programador en el código fuente, es simplemente imprescindible que exista un mecanismo como var para que podamos asignar nuestra consulta a una variable.

Continuara…. Guiño

Jonnathan
http://masjovenesmj.blogspot.com/

 

About justindeveloper

I am MCP (Microsoft Certified Professional). MCTS (Microsoft Certified Technology Specialist) and MCPD (Microsoft Certified Professional Developer), also I am SAP Business One Certified!! Desarrollando desde el IDE de Visual Studio NET 2003 hasta ahora con el Visual Studio NET 2010. Desde Microsoft SQL Server 2000 hasta ahora con el Microsoft SQL Server 2008 R2 y tambien con SharePoint, desde WSS 3.0 y MOSS 2007 y ahora familirizandome con el Sharepoint Foundation 2010 & Sharepoint Server 2010. The software development will follow being every time more wonderful!
This entry was posted in Development. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s