¿Definir explícitamente tipos de datos variables versus usar la palabra clave 'var'? [cerrado]

En C #, ¿me alienta usar la palabra clave var de uso múltiple para cada declaración de variable? En caso afirmativo, ¿debo mencionar esos caracteres especiales para valores literales dentro de la declaración de variable como la M para decimal en la siguiente declaración:

var myDecimal = 14.5M;

Si hace la diferencia, estoy tratando de hacer un desarrollo web con C #.

Ha habido mucha disputa sobre el uso de var. Mis reglas generales son las siguientes.

• Cuando el tipo es obvio, como cuando la mano derecha de la asignación es un constructor, use var.
• Cuando el tipo es complejo de escribir, como una consulta LINQ (la razón de var en primer lugar) use var.
• Para tipos ambivalentes (su decimal es un ejemplo) en los que desea asegurarse de que su variable esté correctamente escrita, deletreela.
• Los tipos anónimos tienen que usar var.
• En todos los demás casos, deletree el tipo.

Básicamente, el objetivo es facilitar la lectura del código. Si cree que var es suficiente porque la asignación es obvia, use var. Use el nombre de tipo completo como una pista para el lector cuando lo considere necesario.

Cuándo usar vares una programación "guerra santa". Precisamente hay un lugar donde se requiere: cuando el resultado de una operación crea un tipo anónimo, como:

var result = new { Name = "John", Age = 35 };

En cualquier otro lugar, es opcional y realmente depende de su estándar de codificación usarlo o no en otras situaciones.

Y sí, necesitará los caracteres especiales para los literales para que el compilador sepa qué es en el lado derecho. En su ejemplo, sin el M, el valor predeterminado es en doublelugar de decimal.

De MSDN :

Sin embargo, el uso de var tiene al menos el potencial de hacer que su código sea más difícil de entender para otros desarrolladores. Por esa razón, la documentación de C # generalmente usa var solo cuando es necesario.

Realmente, realmente no me gusta la escritura implícita. En la superficie, tiende a hacer que el código sea más legible, pero puede generar muchos problemas en el futuro. Si un desarrollador cambia un inicializador variable, digamos, de

var myFloat=100f;

a

var myFloat=100;

o

var myFloat=100.0;

El tipo cambiará, lo que dará como resultado una gran cantidad de errores del compilador o, si está en una vista web y no está utilizando el paso posterior a la compilación para precompilar sus vistas, una gran cantidad de errores de tiempo de ejecución que no se detectarán sin una efectiva pruebas previas a la implementación.

La escritura implícita tampoco funciona en todas partes (desde el mismo enlace de MSDN)

var solo se puede usar cuando una variable local se declara e inicializa en la misma instrucción; la variable no se puede inicializar a nulo, a un grupo de métodos o una función anónima.

var no se puede usar en campos en el ámbito de clase.

Las variables declaradas mediante el uso de var no se pueden usar en la expresión de inicialización. En otras palabras, esta expresión es legal: int i = (i = 20); pero esta expresión produce un error en tiempo de compilación: var i = (i = 20);

Múltiples variables tipadas implícitamente no se pueden inicializar en la misma declaración.

Si un tipo llamado var está dentro del alcance, la palabra clave var se resolverá con ese nombre de tipo y no se tratará como parte de una declaración de variable local tipada implícitamente.

Mantener un código coherente (en este caso, usar una escritura explícita en todas partes) es algo muy, muy bueno. En mi opinión, vares flojo y no proporciona ningún beneficio real, e introduce otro punto potencial de falla en un proceso ya complejo.

Actualización 2017

Cambié completamente de opinión. Cuando trabajo en C #, lo uso la varmayor parte del tiempo (excepto cosas como variables de tipo interfaz y tal). Mantiene el código conciso que mejora la legibilidad. Aún así, preste atención a cuál es realmente el tipo resuelto.

La Referencia de C # muestra lo siguiente para ilustrar el uso bueno o malo de esta construcción:

El siguiente ejemplo muestra dos expresiones de consulta. En la primera expresión, el uso de var está permitido pero no es obligatorio, ya que el tipo del resultado de la consulta se puede establecer explícitamente como un IEnumerable. Sin embargo, en la segunda expresión, se debe usar var porque el resultado es una colección de tipos anónimos, y el nombre de ese tipo no es accesible excepto para el compilador mismo. Tenga en cuenta que en el Ejemplo 2, el elemento variable de iteración foreach también debe escribirse implícitamente.

 // Example #1: var is optional because 
    // the select clause specifies a string 
    string[] words = { "apple", "strawberry", "grape", "peach", "banana" };
    var wordQuery = from word in words
                    where word[0] == 'g'
                    select word;

    // Because each element in the sequence is a string,  
    // not an anonymous type, var is optional here also. 
    foreach (string s in wordQuery)
    {
        Console.WriteLine(s);
    }

    // Example #2: var is required because 
    // the select clause specifies an anonymous type 
    var custQuery = from cust in customers
                    where cust.City == "Phoenix" 
                    select new { cust.Name, cust.Phone };

    // var must be used because each item  
    // in the sequence is an anonymous type 
    foreach (var item in custQuery)
    {
        Console.WriteLine("Name={0}, Phone={1}", item.Name, item.Phone);
    }

La palabra clave var solo solicita al compilador que deduzca el tipo de la variable de tipo var automáticamente. Por lo tanto, si desea almacenar una variable de tipo decimal en una variable var, debe usar m. Del mismo modo, si está almacenando una cadena, debe encerrarla entre comillas.

Para mí no uso var para los siguientes casos:

• Cuando quiero estar seguro del tipo de mi variable (por ejemplo, para asegurarme de que el tipo utilizado es doble y no decimal, ¡y esto es un gran problema, confía en mí!)
• Código polimórfico como Fruit foo = new Apple();. En este caso, creo que var es para evitar y usar la clase padre (aquí Fruit) es mejor al permitir una mejor comprensión de la lógica del código y la limitación de los errores probables (¡Con var, no se verifica el concepto polimórfico!)

Por lo demás, creo que depende del caso y de los antecedentes del desarrollador. Algunas personas del mundo PHP preferirán no ocuparse de los tipos de variables, y algunas personas del mundo Java simplemente pensarán que var es una herejía y cuanto más detallada sea, mejor es.

Tendrás que hacer tu opinión personal :)