¿Por qué ReSharper quiere usar ‘var’ para todo?

Recién comencé a usar ReSharper con Visual Studio (después de las muchas recomendaciones sobre SO). Para probarlo abrí un proyecto ASP.NET MVC reciente. Una de las primeras y más frecuentes cosas que he notado que sugiere es cambiar la mayoría / todas mis declaraciones explícitas a var lugar. Por ejemplo:

 //From This: MyObject foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1); //To This: var foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1); 

y así sucesivamente, incluso con tipos simples como int , bool , etc.

¿Por qué se recomienda esto? No procedo de una ciencia de la computación o de un fondo .NET, ya que desarrollé .NET “caído en” recientemente, así que realmente me gustaría entender qué está pasando y si es beneficioso o no.

Una razón es la legibilidad mejorada. ¿Cual es mejor?

 Dictionary dictionary = new Dictionary(); 

o

 var dictionary = new Dictionary(); 

Lo que ReSharper sugiere es claramente el uso excesivo de la palabra clave var. Puedes usarlo donde el tipo es obvio:

 var obj = new SomeObject(); 

Si el tipo no es obvio, mejor deberás escribirlo:

 SomeObject obj = DB.SomeClass.GetObject(42); 

Personalmente prefiero desactivar esta sugerencia. El uso de var menudo puede mejorar la legibilidad; pero como mencionaste, a veces lo reduce (con tipos simples, o cuando el tipo resultante es oscuro ).

Prefiero elegir cuándo uso var y cuándo no. Pero de nuevo, así soy yo.

var puede boost la legibilidad del código al tiempo que disminuye la comprensión inmediata del código. De todos modos, puede disminuir la legibilidad del código para otras situaciones. Algunas veces el uso de esta es neutral. La medida de legibilidad para la comprensión no es proporcional, sino que depende de la situación. A veces ambos aumentan o disminuyen juntos.

El factor es qué var se aplica y qué tan bien el objective admite la ofuscación inmediata de su tipo de datos para el lector, o si su tipo de información es necesaria para comprender la parte del progtwig en cuestión.

Por ejemplo, mal nombre puede llevar a var causa la disminución de la comprensión del código. Sin embargo, esto no es culpa de var :

 var value1 = GetNotObviousValue(); //What's the data type? //vs. var value2 = Math.Abs(-3); // Obviously a numeric data type. 

A veces no tiene sentido usar var para tipos de datos simples cuando el código es más legible en su ausencia:

 var num = GetNumber(); // But what type of number? // vs. double num = GetNumber(); // I see, it's a double type. 

A veces, var puede ser útil para ocultar información del tipo de datos que no necesariamente le importa ver las complejidades de:

  IEnumerable>>> q = from t in d where t.Key == null select t; // OMG! //vs. var q = from t in d where t.Key == null select t; // I simply want the first string, so the last version seems fine. q.First().Key; 

Debe usar var cuando hay un tipo anónimo presente porque no hay un nombre de tipo para llamarlo:

 var o = new { Num=3, Name="" }; 

Cuando tiene Visual Studio Intellisense que proporciona información de tipo a pesar de var , entonces necesita confiar menos en su comprensión a través de la lectura de código estricta sin una ayuda. Probablemente sea prudente suponer que no todos pueden tener o usar Intellisense.

En resumen, basado en los ejemplos anteriores, sugeriría que la aplicación de var carta blanca no es una buena idea porque la mayoría de las cosas se hacen mejor con moderación y de acuerdo con las circunstancias como se muestra aquí.

¿Por qué Resharper lo usa todo de manera predeterminada? Sugeriría por facilidad, porque no puede analizar los matices de las situaciones para decidir cuándo es mejor no usarlas.

En ReSharper (8.02, pero probablemente otras versiones), la opción para la sugerencia “Usar statement de variable local tipada implícitamente” se puede ajustar a su preferencia , sea lo que sea, abriendo primero el menú de opciones para ReSharper:

Menú de opciones ReSharper

Luego, en “Inspección del código” ajustando la “Gravedad de inspección” del idioma elegido, en mi caso c #:

Desactiva la sugerencia de variable local tipada implícitamente

Como puede ver, hay opciones para ajustar todas las sugerencias que ReSharper hace. Espera que esto ayude a alguien como yo que ya tiene una estrategia de uso de ‘var’ y solo quiere que ReSharper lo respete 🙂

Me sorprende que nadie haya mencionado que también es más fácil cambiar el tipo de objeto instanciado, porque

 AVeryLongTypeName myVariable = new AVeryLongTypeName( arguments ); 

es una forma de repetición Si deseo cambiar AVeryLongTypeName en una de sus clases derivadas, solo necesito cambiar esto una vez cuando use var y todavía pueda acceder a los métodos de las clases secundarias.

Aparte de eso, la legibilidad mejorada es un punto importante, pero como otros dijeron, var no debe ser usado en exceso, así que creo que desactivar la sugerencia en Resharper está absolutamente bien.

‘var’ se trata de ser claro

El principal debate sobre si se debe usar la palabra clave var o no es sobre qué tan legible es el código para usted y para otros desarrolladores.

Como si estuvieras escribiendo una historia, no hay una respuesta correcta definitiva. Pero veamos algunos ejemplos de esto en inglés simple.

Jake saludó a Bill. No le gustaba así que se giró y se fue por el otro lado.

¿Quién fue por el otro lado? ¿Jake o Bill? En este caso, usar los nombres “Jake” y “Bill” es como usar el nombre del tipo. Y “Él” y “él” es como usar la palabra clave var . En este caso, podría ser más específico. Lo siguiente, por ejemplo, es mucho más claro.

Jake saludó a Bill. A Jake no le gustó Bill, así que giró y se fue por el otro lado.

En este caso, ser más específico hizo que la oración fuera más clara. Pero eso no siempre va a ser el caso. En algunos casos, ser específico hace que sea más difícil de leer.

A Bill le gustan los libros, entonces Bill fue a la biblioteca y Bill sacó un libro que siempre le gustó a Bill.

En este caso, sería más fácil leer la oración si usáramos “él” y, en algunos casos, omitimos su nombre, lo que equivale a usar la palabra clave var .

A Bill le gustan los libros, así que fue a la biblioteca y sacó un libro que siempre le gustó.

Esos ejemplos cubren la esencia, pero no cuentan toda la historia. En esos ejemplos solo había una forma de referirse a la persona. Ya sea usando su nombre o usando un término más general como “él” y “él”.

En el caso del código, tenemos 3 formas de ayudar a agregar claridad. El tipo, el nombre de la variable y la asignación. Tome esta línea de código por ejemplo:

 Person p = GetPerson(); 

La pregunta ahora es si hay suficiente información en esa línea de código para ayudarlo a descubrir qué está pasando.

¿Qué pasa con la siguiente línea de código? ¿Todavía sabrías lo que p significa en este caso?

 var p = GetPerson(); 

Que tal ahora:

 var p = Get(); 

O ahora:

 var person = Get(); 

O este:

 var t = GetPerson(); 

O esto:

 var u = Person.Get(); 

Si la palabra clave var funciona en un escenario dado depende mucho del contexto del código, por ejemplo, cómo se nombran las variables, las clases y los métodos. También depende de la complejidad del código y del rest del código que lo rodea.

Personalmente, me gusta usar la palabra clave var Es más completa para mí la mayor parte del tiempo. Pero también tiendo a nombrar mis variables después del tipo, así que realmente no estoy perdiendo ninguna información.

Dicho eso, a veces, dependiendo del contexto en el que hago excepciones, esta es la naturaleza de cualquier cosa compleja, y el software no es nada si no complejo.

No me gustó esto también.

No quiero que esto se convierta en un debate sobre el uso de var , tiene sus usos, pero no debe usarse en todas partes.

La clave para recordar es que ReSharper está configurado para los estándares de encoding que desee.

Editar: ReSharper y var

Mi regla es esta:

  • ¿Estás declarando un tipo primitivo (es decir, byte , char , string , int[] , double? decimal , etc.)? -> Usa el tipo:

     string myStr = "foo"; int[] myIntArray = [123, 456, 789]; double? myDouble = 123.3; 
  • ¿Estás declarando un tipo complejo (es decir, List , Dictionary , MyObj )? -> Usar var :

     var myList = List(); var myDictionary = Dictionary(); var myObjInstance = new MyObj(); 

Me gustaría señalar que el uso de “var” se recomienda en las Convenciones de Codificación C # “cuando el tipo de variable es obvio desde el lado derecho de la tarea, o cuando el tipo exacto no es importante”, entonces eso es probablemente por qué la sugerencia está activada por defecto en ReSharper. También proporcionan algunos casos donde no mejoraría la legibilidad justo debajo en el mismo documento.

Veo muchas respuestas correctas, pero falta la completa.

Es cierto que Resharper usa de forma excesiva var por defecto. Creo que la mayoría de la gente estaría de acuerdo con eso. También es más fácil de leer cuando se usa var y el tipo es obvio, como cuando se usa una nueva instrucción. Vi una publicación que mostraba cómo actualizar la severidad de la inspección para mostrar solo sugerencias para el uso de var.

Intenté comentar en otras publicaciones primero para agregar dónde establecerlas, pero no tenía la reputación para ello. Al parecer, tampoco tenía la reputación de publicar mi captura de pantalla de la configuración.

Tendré que explicar cómo llegar allí.

En Visual Studio -> Menú principal -> Resharper -> Opciones -> Edición de código -> C # -> Estilo de código -> Var. Uso en declaraciones

  • Para tipos incorporados Use el tipo explícito
  • Para tipos simples Use ‘var’ cuando sea evidente
  • En otro lugar Use’var ‘

enter image description here

ReSharper recomienda var porque tiende a despejar la creación de objetos.

Compara estos dos ejemplos:

 StringBuilder bld = new StringBuilder(); var bld = new StringBuilder(); 

Es solo una taquigrafía que se supone que es más fácil de leer.

Creo que está bien cuando creas nuevos objetos explícitamente con “nuevo”. Sin embargo, en su ejemplo, puede que no sea obvio si las clases no se nombraron correctamente.

Por cierto, ReSharper establece una distinción entre ‘quizás quieras aplicar esta sugerencia a tu código’ y ‘tu código está roto, ¿quieres que lo arregle?’. La palabra clave var está en la categoría de sugerencia, junto con cosas como “invertir si para reducir la anidación”; no tienes que seguirlo

Puede configurar qué tan molesto es cada una de sus alertas a través del cuadro de diálogo Opciones, o directamente a través del menú emergente para esa alerta. Puede degradar cosas como la sugerencia de var para que sean menos prominentes, o puede actualizar cosas como la alerta de ‘usar método de extensión’ para que se muestre como un error real.

La función var de .Net 3.0 es simplemente inferencia tipográfica , que es segura y a menudo hace que su código sea más fácil de leer. Pero no es necesario, y puede desactivar esa recomendación en reafilamiento si lo desea.

No hay diferencia técnica, si usas var, el tipo está implícito en el comstackdor. Si tienes un código como este:

 var x = 1; 

x implica que es un int y no se le pueden asignar otros valores.

La palabra clave var es útil si cambia el tipo de la variable; entonces solo tienes que hacer un cambio en lugar de dos:

 var x = 1; --> var x = "hello"; int x = 1; --> string x = "hello"; 

La palabra clave var se introdujo en C # 3.0. Nos permite olvidarnos de especificar nuestro tipo explícitamente.

No hay diferencia real en cuanto a si usa

MyObject foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

o

var foo = DB.MyObjects.SingleOrDefault(w => w.Id == 1);

excepto la legibilidad pura y menos posibilidades de error.

Parece un ejemplo cliché, pero di lo siguiente puede ayudarte a comprender:

 var myInt = 23; 

devuelve un tipo int , mientras que

 var myInt = "23"; 

devuelve un tipo de string .

Referencia de MSDN

Especificar un tipo de objeto explícito es de alguna manera redundante. Incluso traducido en inglés, suena redundante: “pon un objeto de tipo X en una variable de tipo X” frente a “pon un objeto de tipo X en una variable”.

Sin embargo, usar ‘var’ tiene sus limitaciones . Impide el uso a continuación del polymorphism, que es belleza pura :

Suponga que un perro se extiende Animal; El gato extiende la jerarquía de la clase animal:

 Animal x = new Dog(); DoStuffWithDog(x as Dog); x = new Cat(); DoStuffWithCat(x as Cat); void DoStuffWithDog(Dog d){} void DoStuffWithCat(Cat c){} 

El mismo código, con x declarado con ‘var’ no se comstackrá .

 var x = new Dog(); // from this point, x is a Dog DoStuffWithDog(x as Dog); x = new Cat(); // cannot assign a Cat instance to a Dog DoStuffWithCat(x as Cat); void DoStuffWithDog(Dog d){} void DoStuffWithCat(Cat c){} 

De todos modos, volviendo a la pregunta original, no uso Resharper, pero supongo que es lo suficientemente inteligente como para detectar cuándo no usar ‘var’. 🙂

Var es increíble! Me he encontrado con muchos desarrolladores que tienen la impresión de que var está vinculado a un tipo dynamic, no lo es. Todavía está tipado estáticamente, simplemente lo decide el comstackdor.

Aquí hay algunos aspectos positivos sorprendentes de usar var

Var menos tipado es más corto y más fácil de leer, por ejemplo

Dictionary> postcodes = new Dictionary>() Yuk.

var postcodes = new Dictionary>() \ o / \ o /

Nombres de variables más descriptivos : uno tenue, pero creo que es importante dejar que la naturaleza fluida de var brille aquí. Como var es un poco vago, realmente fomenta un nombre de variable más descriptivo en lugar de dejar que el tipo hable por sí mismo.

Menos cambios de código : si cambia el tipo de devolución de una llamada a método. Solo tiene que cambiar la llamada al método, no en todos los lugares donde se usa.

Tipos anónimos: los tipos anónimos son un concepto realmente poderoso, especialmente en áreas como los recursos parciales de WebApi. Sin var, no pueden ser utilizados.

A veces, sin embargo, es útil declarar explícitamente los tipos y considero que esto es más útil en primitivas o estructuras. Por ejemplo, personalmente no encuentro esta syntax muy útil:

 for(var i = 0; i < 10; i++) { } 

vs

 for(int i = 0; i < 10; i++) { } 

Todo depende de las preferencias personales, pero usar var realmente acelerará tu desarrollo y desbloqueará todo un mundo de bondad de tipo anónimo.

Para aquellos que no les gusta el uso constante de “var”:

NOTA: también puede detener el reajuste de default a var al hacer “introducir variable”. Esto fue algo que me frustró por mucho tiempo, siempre estaba en default para var, y lo estaba cambiando cada vez.

Estas configuraciones están en Edición de código -> C # -> Estilo de código

enter image description here

Desde mi punto de vista, var debería usarse solo cuando quede inmediatamente claro cuál es el tipo al definir el valor de la variable.

Ejemplo:

 var s = "string value"; 

Es obvio que s es una string .

Creo que también es apropiado cuando el nombre del tipo de variable es muy complejo.

Ejemplo:

 Dictionary>> dict = new Dictionary>>(); // This is a little easier to read than the above statement var dict = new Dictionary>>(); 

Aparte de estos escenarios, no veo ninguna ganancia que se realice mediante el uso de var , pero puedo pensar en algunos escenarios en los que puede ser perjudicial:

Por ejemplo, un tipo desechable cuyo valor de la variable del lado derecho no muestra claramente el tipo. La eliminación del IDisposable puede olvidarse fácilmente

Ejemplo:

 // returns some file writer var wr = GetWriter(); wr.add("stuff"); wr.add("more stuff"); //... //... // Now `wr` needs to be disposed, // but there is no clear indication of the type of `wr`, // so it will be easily overlooked by code writer and code reviewer. 

No hay diferencia técnica (como lo señaló EWolf). Puede usar uno u otro, el código CLR generado tendrá el mismo aspecto.

En mi opinión, el principal beneficio es que esto tiende a forzarlo a usar un mejor nombre variable. En su ejemplo, ‘foo’ es una opción bastante pobre para un nombre de variable.

De acuerdo con JetBrains (el autor de ReSharper), fomentan el uso de var por defecto.

De su sitio web :

El uso de variables locales implícitamente tipadas (también conocido como var keyword) introducido en C # 3.0 se ha vuelto bastante popular debido a la legibilidad mejorada del código resultante. Por defecto, ReSharper también alienta el uso de var palabra clave, pero las preferencias de su uso son configurables de manera flexible. Por ejemplo, puede optar por usar tipos explícitos en casos específicos o en cualquier lugar.