c# - studio - ¿Por qué ReSharper quiere usar ''var'' para todo?

resharper visual studio code (23)

Acabo de empezar a usar ReSharper con Visual Studio (después de las muchas recomendaciones sobre SO). Para probarlo, abrí un proyecto reciente de ASP.NET MVC. 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 . 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 provengo de un área de informática o de .NET, después de haber "caído en" el desarrollo de .NET recientemente, así que realmente me gustaría entender qué está pasando y si es de beneficio o no.

¡Var es increíble! Me he encontrado con muchos desarrolladores que tienen la impresión de que var está vinculado a un tipo dinámico, pero no lo está. Todavía se escribe estáticamente, solo lo decide el compilador.

Aquí hay algunos positivos sorprendentes de usar var

Menos var es más corto y más fácil de leer, por ejemplo

Dictionary<int,IList<string>> postcodes = new Dictionary<int,IList<string>>() Yuk.

var postcodes = new Dictionary<int,IList<string>>() / o / / o /

Nombres de variables más descriptivos : 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 desciptiva en lugar de dejar que el tipo hable por sí mismo.

Menos cambios de código : si el tipo de retorno de una llamada de método cambia. Solo tienes que cambiar el método de llamada, no todos los lugares que se usan.

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

A veces, sin embargo, es útil declarar explícitamente los tipos y esto me parece más útil en primitivos o estructuras. Por ejemplo, personalmente no encuentro esta sintaxis muy útil:

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

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

Todo depende de las preferencias personales, pero el uso de var realmente acelerará su desarrollo y desbloqueará todo un mundo de bondades anónimas.

''var'' agrega un tipo de elemento "dinámico" a su código (aunque, por supuesto, el código sigue siendo escrito estrictamente). Aconsejo no usarlo en los casos en que el tipo no esté claro. Considera este ejemplo:

var bar = GetTheObjectFromDatabase(); bar.DoSomething(); ClassA { void DoSomething() { //does something } } ClassB { void DoSomething() { //does something entirely different } }

Si el Tipo de retorno de GetTheObjectFromDatabase () se cambia de Tipo A a B no lo notaremos, ya que ambas Clases implementan DoSomething (). El código, sin embargo, ahora puede hacer algo completamente diferente.

Esto puede ser tan sutil como escribir cosas diferentes en un registro, por lo que es posible que no note que es demasiado tarde.

El siguiente uso de var siempre debería estar bien:

var abc = new Something();

En ReSharper (8.02, pero probablemente otras versiones), la opción para la sugerencia "Usar declaración de variable local escrita de forma implícita" se puede ajustar a su preferencia , cualquiera que sea, abriendo primero el menú de opciones para ReSharper:

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

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

Especificar un tipo de objeto explícito es de alguna manera redundante. Incluso traducido al inglés, suena redundante: "poner un objeto de tipo X en una variable de tipo X" vs "Poner un objeto de tipo X en una variable".

Sin embargo, usar ''var'' tiene sus limitaciones . Previene el uso del polimorfismo que se encuentra debajo, que es pura belleza :

Supongamos 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 compilará .

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 asumo que es lo suficientemente inteligente como para detectar cuándo no usar ''var''. :-)

La característica var de .Net 3.0 es solo una inferencia de tipo , que es segura y que a menudo hace que su código sea más fácil de leer. Pero no tiene que hacerlo, y puede desactivar esa recomendación en resharper si lo desea.

La palabra clave var se introdujo en C # 3.0, lo que nos permite olvidar especificar explícitamente nuestro tipo.

No hay diferencia real en si usas o no

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

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

excepto la legibilidad pura y menos posibilidades de error.

Parece un ejemplo cliché, pero digamos que lo siguiente puede ayudar a comprenderlo:

var myInt = 23;

devuelve un tipo int , mientras que

var myInt = "23";

devuelve un tipo de string .

Referencia de MSDN

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

var obj = new SomeObject();

Si el tipo no es obvio, deberías escribirlo:

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

Me gustaría señalar que se recomienda el uso de "var" en las Convenciones de codificación de C # "cuando el tipo de la variable es evidente desde el lado derecho de la asignación, o cuando el tipo exacto no es importante", por lo que Probablemente el motivo es que la sugerencia está activada de forma predeterminada en ReSharper. También proporcionan algunos casos en los que no mejoraría la legibilidad a continuación en el mismo documento.

Me sorprende que nadie mencione 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 quiero cambiar AVeryLongTypeName en una de sus clases derivadas, solo necesito cambiar esto una vez cuando uso var y todavía puedo acceder a los métodos de las clases secundarias.

Aparte de eso, la mejora de la legibilidad es un punto importante, pero, como han dicho otros, no se debe abusar de la var, por lo que creo que desactivar la sugerencia en Resharper es absolutamente correcto.

Mi regla es esta:

¿Está declarando un tipo primitivo (es decir, byte , char , string , int[] , double? decimal , etc.)? -> Utilice el tipo:
string myStr = "foo"; int[] myIntArray = [123, 456, 789]; double? myDouble = 123.3;
¿Está declarando un tipo complejo (es decir, List<T> , Dictionary<T, T> , MyObj )? -> Use var :
var myList = List<string>(); var myDictionary = Dictionary<string, string>(); var myObjInstance = new MyObj();

No hay diferencia técnica (como señaló eWolf). Puede usar uno u otro, el código CLR generado se verá igual.

En mi opinión, el principal beneficio es que esto obliga a usar una mejor asignación de nombres de variables. En su ejemplo, ''foo'' es una opción bastante mala para un nombre de variable.

No hay diferencia técnica, si utiliza var, el compilador implica el tipo. Si tienes un código como este:

var x = 1;

Se implica que x es un int y no se le puede asignar ningún otro valor.

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";

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

NOTA: también puede evitar que resharper vuelva por defecto a var cuando haga "introducir variable". Esto fue algo que me frustró durante mucho tiempo, siempre fue por defecto a var, y lo estaba cambiando cada vez.

Estas configuraciones se encuentran en Edición de código -> C # -> Estilo de código

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

Prefiero elegir cuando uso var y cuando no. Pero una vez más, eso es sólo yo.

Por cierto, ReSharper hace una distinción entre "es posible que desee aplicar esta sugerencia a su código" y "su código está roto, ¿quiere que lo arregle?". La palabra clave var está en la categoría de sugerencias, junto con elementos como "invertir para reducir el anidamiento"; no tienes que seguirlo

Puede configurar qué tan molestas son 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 ''usar método de extensión'' para que aparezca como un error real.

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 crea nuevos objetos explícitamente con "nuevo". Sin embargo, en su ejemplo, podría no ser obvio si las clases no se nombraron correctamente.

Según JetBrains (el autor de ReSharper), fomentan el uso de var por defecto.

Desde su website :

El uso de variables locales implícitamente tipificadas (también conocidas como palabra clave var) introducidas en C # 3.0 se ha vuelto bastante popular debido a la mejor legibilidad del código resultante. Por defecto, ReSharper también recomienda el uso de la palabra clave var, 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.

También me disgustó esto.

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 codificación que desee.

Edición: ReSharper y var

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

Dictionary<int, MyLongNamedObject> dictionary = new Dictionary<int, MyLongNamedObject>();

var dictionary = new Dictionary<int, MyLongNamedObject>();

Veo muchas respuestas correctas, pero falta la completa.

Es cierto que Resharper usa excesivamente 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 declaració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 configurarlas, pero no tenía la reputación de hacerlo. 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 -> Uso variable en declaraciones

Para tipos incorporados Use tipo explícito
Para tipos simples Use ''var'' cuando sea evidente
En otro lugar use ''var''

var puede aumentar 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. A veces su uso es neutral. La medida de la legibilidad a la comprensión no es proporcional sino que depende de la situación. A veces ambos aumentan o disminuyen juntos.

El factor es a qué var se aplican las variables y qué tan bien el objetivo admite la ofuscación inmediata de su tipo de datos al lector, o si se necesita la información de su tipo para comprender la parte del programa en cuestión.

Por ejemplo, una mala denominación puede llevar a que varíe la comprensión del código. Esto no es culpa de var sin embargo:

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 de tipos de datos que no necesariamente le interesa ver las complejidades de:

IEnumerable<KeyValuePair<string,List<Dictionary<int,bool>>>> 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 por:

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 mediante la lectura estricta de códigos sin ayuda. Probablemente sea prudente suponer que no todos pueden tener o usar Intellisense.

En resumen, sobre la base de los ejemplos anteriores, sugeriría que la aplicación de varte blanche de var no es una buena idea porque la mayoría de las cosas se hacen mejor con moderación y en función de las circunstancias en cuestión, como se muestra aquí.

¿Por qué Resharper lo usa todo por defecto? Lo sugeriría con facilidad, porque no puede analizar los matices de las situaciones para decidir cuándo es mejor no usarlo.

''var'' se trata de ser claro

El debate principal sobre si usar la palabra clave var o no es sobre qué tan legible es el código para usted y 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 dio la vuelta y se fue por el otro lado.

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

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

En este caso, siendo más específico, aclaró la oración. 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, así que Bill fue a la biblioteca y Bill sacó un libro que a Bill siempre le ha gustado.

En este caso, sería más fácil leer la oración si usáramos "él" y en algunos casos omitimos su nombre por completo, 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 ha gustado.

Esos ejemplos cubren la esencia, pero no cuentan toda la historia. En esos ejemplos solo había una manera 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 maneras en que podemos 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: ¿hay suficiente información en esa línea de código para ayudarte a descubrir qué está pasando?

¿Qué pasa con la siguiente línea de código? ¿Sabrías lo que significa p 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 determinado 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 resto del código que lo rodea.

Personalmente, me gusta usar la palabra clave var que es más completa para mí la mayor parte del tiempo. Pero también tiendo a nombrar mis variables según el tipo, por lo que no estoy perdiendo ninguna información.

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

En mi opinión, var solo debería usarse cuando está 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<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>> dict = new Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>>(); // This is a little easier to read than the above statement var dict = new Dictionary<SomeCustomKeyType, Dictionary<AnotherCustomKeyType, List<int>>>();

Aparte de estos escenarios, no veo ninguna ganancia que se genere utilizando var , pero puedo pensar en algunos escenarios en los que puede ser perjudicial:

Por ejemplo, un tipo desechable cuyo valor variable del lado derecho no muestra claramente el tipo. La eliminación de lo IDisposable se puede olvidar 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.